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 void 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
);
115 void log_out_nn (FILE *fp
, const char *fmt
, ...)
117 if (SUPPRESS_OUTPUT
) return;
123 log_final (fp
, fmt
, ap
);
128 void log_info_nn (const char *fmt
, ...)
130 if (SUPPRESS_OUTPUT
) return;
136 log_final (stdout
, fmt
, ap
);
141 void log_error_nn (const char *fmt
, ...)
143 if (SUPPRESS_OUTPUT
) return;
149 log_final (stderr
, fmt
, ap
);
154 void log_out (FILE *fp
, const char *fmt
, ...)
156 if (SUPPRESS_OUTPUT
) return;
162 log_final (fp
, fmt
, ap
);
171 void log_info (const char *fmt
, ...)
173 if (SUPPRESS_OUTPUT
) return;
179 log_final (stdout
, fmt
, ap
);
183 fputc ('\n', stdout
);
188 void log_error (const char *fmt
, ...)
190 if (SUPPRESS_OUTPUT
) return;
192 fputc ('\n', stderr
);
193 fputc ('\n', stderr
);
199 log_final (stderr
, fmt
, ap
);
203 fputc ('\n', stderr
);
204 fputc ('\n', stderr
);
213 u8
int_to_base32 (const u8 c
)
215 static const u8 tbl
[0x20] =
217 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
218 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
224 u8
base32_to_int (const u8 c
)
226 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
227 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
232 u8
int_to_itoa32 (const u8 c
)
234 static const u8 tbl
[0x20] =
236 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
237 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
243 u8
itoa32_to_int (const u8 c
)
245 if ((c
>= '0') && (c
<= '9')) return c
- '0';
246 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
251 u8
int_to_itoa64 (const u8 c
)
253 static const u8 tbl
[0x40] =
255 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
256 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
257 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
258 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
264 u8
itoa64_to_int (const u8 c
)
266 static const u8 tbl
[0x100] =
268 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
269 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
270 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
271 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
272 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
273 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
274 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
275 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
276 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
277 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
278 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
279 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
280 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
281 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
282 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
283 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
289 u8
int_to_base64 (const u8 c
)
291 static const u8 tbl
[0x40] =
293 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
294 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
295 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
296 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
302 u8
base64_to_int (const u8 c
)
304 static const u8 tbl
[0x100] =
306 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
307 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
308 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
309 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
310 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
311 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
312 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
313 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
314 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
315 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
316 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
317 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
318 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
319 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
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,
327 u8
int_to_bf64 (const u8 c
)
329 static const u8 tbl
[0x40] =
331 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
332 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
333 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
334 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
340 u8
bf64_to_int (const u8 c
)
342 static const u8 tbl
[0x100] =
344 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
345 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
346 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
347 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
348 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
349 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
350 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
351 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
352 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
353 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
354 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
355 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
356 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
357 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
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,
365 u8
int_to_lotus64 (const u8 c
)
367 if (c
< 10) return '0' + c
;
368 else if (c
< 36) return 'A' + c
- 10;
369 else if (c
< 62) return 'a' + c
- 36;
370 else if (c
== 62) return '+';
371 else if (c
== 63) return '/';
376 u8
lotus64_to_int (const u8 c
)
378 if ((c
>= '0') && (c
<= '9')) return c
- '0';
379 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
380 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
381 else if (c
== '+') return 62;
382 else if (c
== '/') return 63;
388 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
390 const u8
*in_ptr
= in_buf
;
392 u8
*out_ptr
= out_buf
;
394 for (int i
= 0; i
< in_len
; i
+= 8)
396 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
397 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
398 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
399 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
400 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
401 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
402 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
403 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
405 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
406 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
407 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
408 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
409 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
415 for (int i
= 0; i
< in_len
; i
++)
417 if (in_buf
[i
] != '=') continue;
422 int out_len
= (in_len
* 5) / 8;
427 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
429 const u8
*in_ptr
= in_buf
;
431 u8
*out_ptr
= out_buf
;
433 for (int i
= 0; i
< in_len
; i
+= 5)
435 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
436 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
437 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
438 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
439 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
440 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
441 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
442 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
444 out_ptr
[0] = out_val0
& 0x7f;
445 out_ptr
[1] = out_val1
& 0x7f;
446 out_ptr
[2] = out_val2
& 0x7f;
447 out_ptr
[3] = out_val3
& 0x7f;
448 out_ptr
[4] = out_val4
& 0x7f;
449 out_ptr
[5] = out_val5
& 0x7f;
450 out_ptr
[6] = out_val6
& 0x7f;
451 out_ptr
[7] = out_val7
& 0x7f;
457 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
461 out_buf
[out_len
] = '=';
469 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
471 const u8
*in_ptr
= in_buf
;
473 u8
*out_ptr
= out_buf
;
475 for (int i
= 0; i
< in_len
; i
+= 4)
477 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
478 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
479 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
480 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
482 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
483 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
484 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
490 for (int i
= 0; i
< in_len
; i
++)
492 if (in_buf
[i
] != '=') continue;
497 int out_len
= (in_len
* 6) / 8;
502 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
504 const u8
*in_ptr
= in_buf
;
506 u8
*out_ptr
= out_buf
;
508 for (int i
= 0; i
< in_len
; i
+= 3)
510 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
511 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
512 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
513 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
515 out_ptr
[0] = out_val0
& 0x7f;
516 out_ptr
[1] = out_val1
& 0x7f;
517 out_ptr
[2] = out_val2
& 0x7f;
518 out_ptr
[3] = out_val3
& 0x7f;
524 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
528 out_buf
[out_len
] = '=';
536 int is_valid_hex_char (const u8 c
)
538 if ((c
>= '0') && (c
<= '9')) return 1;
539 if ((c
>= 'A') && (c
<= 'F')) return 1;
540 if ((c
>= 'a') && (c
<= 'f')) return 1;
545 u8
hex_convert (const u8 c
)
547 return (c
& 15) + (c
>> 6) * 9;
550 u8
hex_to_u8 (const u8 hex
[2])
554 v
|= (hex_convert (hex
[1]) << 0);
555 v
|= (hex_convert (hex
[0]) << 4);
560 u32
hex_to_u32 (const u8 hex
[8])
564 v
|= ((u32
) hex_convert (hex
[7])) << 0;
565 v
|= ((u32
) hex_convert (hex
[6])) << 4;
566 v
|= ((u32
) hex_convert (hex
[5])) << 8;
567 v
|= ((u32
) hex_convert (hex
[4])) << 12;
568 v
|= ((u32
) hex_convert (hex
[3])) << 16;
569 v
|= ((u32
) hex_convert (hex
[2])) << 20;
570 v
|= ((u32
) hex_convert (hex
[1])) << 24;
571 v
|= ((u32
) hex_convert (hex
[0])) << 28;
576 u64
hex_to_u64 (const u8 hex
[16])
580 v
|= ((u64
) hex_convert (hex
[15]) << 0);
581 v
|= ((u64
) hex_convert (hex
[14]) << 4);
582 v
|= ((u64
) hex_convert (hex
[13]) << 8);
583 v
|= ((u64
) hex_convert (hex
[12]) << 12);
584 v
|= ((u64
) hex_convert (hex
[11]) << 16);
585 v
|= ((u64
) hex_convert (hex
[10]) << 20);
586 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
587 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
588 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
589 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
590 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
591 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
592 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
593 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
594 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
595 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
600 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
602 hex
[0] = v
>> 28 & 15;
603 hex
[1] = v
>> 24 & 15;
604 hex
[2] = v
>> 20 & 15;
605 hex
[3] = v
>> 16 & 15;
606 hex
[4] = v
>> 12 & 15;
607 hex
[5] = v
>> 8 & 15;
608 hex
[6] = v
>> 4 & 15;
609 hex
[7] = v
>> 0 & 15;
613 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
614 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
615 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
616 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
617 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
618 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
619 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
620 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
627 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
631 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
640 for (int i
= 0; i
< 16; i
+= 4)
650 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
657 out
[i
+ 0] = _out
[0];
658 out
[i
+ 1] = _out
[1];
659 out
[i
+ 2] = _out
[2];
660 out
[i
+ 3] = _out
[3];
669 static void juniper_decrypt_hash (char *in
, char *out
)
673 u8 base64_buf
[100] = { 0 };
675 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
679 u32 juniper_iv
[4] = { 0 };
681 memcpy (juniper_iv
, base64_buf
, 12);
683 memcpy (out
, juniper_iv
, 12);
687 u32 juniper_key
[4] = { 0 };
689 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
690 juniper_key
[1] = byte_swap_32 (0x8df91059);
691 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
692 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
696 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
697 u32
*out_ptr
= (u32
*) (out
+ 12);
699 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
702 void phpass_decode (u8 digest
[16], u8 buf
[22])
706 l
= itoa64_to_int (buf
[ 0]) << 0;
707 l
|= itoa64_to_int (buf
[ 1]) << 6;
708 l
|= itoa64_to_int (buf
[ 2]) << 12;
709 l
|= itoa64_to_int (buf
[ 3]) << 18;
711 digest
[ 0] = (l
>> 0) & 0xff;
712 digest
[ 1] = (l
>> 8) & 0xff;
713 digest
[ 2] = (l
>> 16) & 0xff;
715 l
= itoa64_to_int (buf
[ 4]) << 0;
716 l
|= itoa64_to_int (buf
[ 5]) << 6;
717 l
|= itoa64_to_int (buf
[ 6]) << 12;
718 l
|= itoa64_to_int (buf
[ 7]) << 18;
720 digest
[ 3] = (l
>> 0) & 0xff;
721 digest
[ 4] = (l
>> 8) & 0xff;
722 digest
[ 5] = (l
>> 16) & 0xff;
724 l
= itoa64_to_int (buf
[ 8]) << 0;
725 l
|= itoa64_to_int (buf
[ 9]) << 6;
726 l
|= itoa64_to_int (buf
[10]) << 12;
727 l
|= itoa64_to_int (buf
[11]) << 18;
729 digest
[ 6] = (l
>> 0) & 0xff;
730 digest
[ 7] = (l
>> 8) & 0xff;
731 digest
[ 8] = (l
>> 16) & 0xff;
733 l
= itoa64_to_int (buf
[12]) << 0;
734 l
|= itoa64_to_int (buf
[13]) << 6;
735 l
|= itoa64_to_int (buf
[14]) << 12;
736 l
|= itoa64_to_int (buf
[15]) << 18;
738 digest
[ 9] = (l
>> 0) & 0xff;
739 digest
[10] = (l
>> 8) & 0xff;
740 digest
[11] = (l
>> 16) & 0xff;
742 l
= itoa64_to_int (buf
[16]) << 0;
743 l
|= itoa64_to_int (buf
[17]) << 6;
744 l
|= itoa64_to_int (buf
[18]) << 12;
745 l
|= itoa64_to_int (buf
[19]) << 18;
747 digest
[12] = (l
>> 0) & 0xff;
748 digest
[13] = (l
>> 8) & 0xff;
749 digest
[14] = (l
>> 16) & 0xff;
751 l
= itoa64_to_int (buf
[20]) << 0;
752 l
|= itoa64_to_int (buf
[21]) << 6;
754 digest
[15] = (l
>> 0) & 0xff;
757 void phpass_encode (u8 digest
[16], u8 buf
[22])
761 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
763 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
764 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
765 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
766 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
768 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
770 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
771 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
772 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
773 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
775 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
777 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
778 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
779 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
780 buf
[11] = int_to_itoa64 (l
& 0x3f);
782 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
784 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
785 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
786 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
787 buf
[15] = int_to_itoa64 (l
& 0x3f);
789 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
791 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
792 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
793 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
794 buf
[19] = int_to_itoa64 (l
& 0x3f);
796 l
= (digest
[15] << 0);
798 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
799 buf
[21] = int_to_itoa64 (l
& 0x3f);
802 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
806 l
= itoa64_to_int (buf
[ 0]) << 0;
807 l
|= itoa64_to_int (buf
[ 1]) << 6;
808 l
|= itoa64_to_int (buf
[ 2]) << 12;
809 l
|= itoa64_to_int (buf
[ 3]) << 18;
811 digest
[ 0] = (l
>> 16) & 0xff;
812 digest
[ 6] = (l
>> 8) & 0xff;
813 digest
[12] = (l
>> 0) & 0xff;
815 l
= itoa64_to_int (buf
[ 4]) << 0;
816 l
|= itoa64_to_int (buf
[ 5]) << 6;
817 l
|= itoa64_to_int (buf
[ 6]) << 12;
818 l
|= itoa64_to_int (buf
[ 7]) << 18;
820 digest
[ 1] = (l
>> 16) & 0xff;
821 digest
[ 7] = (l
>> 8) & 0xff;
822 digest
[13] = (l
>> 0) & 0xff;
824 l
= itoa64_to_int (buf
[ 8]) << 0;
825 l
|= itoa64_to_int (buf
[ 9]) << 6;
826 l
|= itoa64_to_int (buf
[10]) << 12;
827 l
|= itoa64_to_int (buf
[11]) << 18;
829 digest
[ 2] = (l
>> 16) & 0xff;
830 digest
[ 8] = (l
>> 8) & 0xff;
831 digest
[14] = (l
>> 0) & 0xff;
833 l
= itoa64_to_int (buf
[12]) << 0;
834 l
|= itoa64_to_int (buf
[13]) << 6;
835 l
|= itoa64_to_int (buf
[14]) << 12;
836 l
|= itoa64_to_int (buf
[15]) << 18;
838 digest
[ 3] = (l
>> 16) & 0xff;
839 digest
[ 9] = (l
>> 8) & 0xff;
840 digest
[15] = (l
>> 0) & 0xff;
842 l
= itoa64_to_int (buf
[16]) << 0;
843 l
|= itoa64_to_int (buf
[17]) << 6;
844 l
|= itoa64_to_int (buf
[18]) << 12;
845 l
|= itoa64_to_int (buf
[19]) << 18;
847 digest
[ 4] = (l
>> 16) & 0xff;
848 digest
[10] = (l
>> 8) & 0xff;
849 digest
[ 5] = (l
>> 0) & 0xff;
851 l
= itoa64_to_int (buf
[20]) << 0;
852 l
|= itoa64_to_int (buf
[21]) << 6;
854 digest
[11] = (l
>> 0) & 0xff;
857 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
861 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
863 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
864 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
865 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
866 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
868 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
870 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
871 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
872 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
873 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
875 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
877 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
879 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
880 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
882 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
884 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
886 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
887 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
889 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
891 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
893 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
894 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
896 l
= (digest
[11] << 0);
898 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
899 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
902 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
906 l
= itoa64_to_int (buf
[ 0]) << 0;
907 l
|= itoa64_to_int (buf
[ 1]) << 6;
908 l
|= itoa64_to_int (buf
[ 2]) << 12;
909 l
|= itoa64_to_int (buf
[ 3]) << 18;
911 digest
[ 0] = (l
>> 16) & 0xff;
912 digest
[21] = (l
>> 8) & 0xff;
913 digest
[42] = (l
>> 0) & 0xff;
915 l
= itoa64_to_int (buf
[ 4]) << 0;
916 l
|= itoa64_to_int (buf
[ 5]) << 6;
917 l
|= itoa64_to_int (buf
[ 6]) << 12;
918 l
|= itoa64_to_int (buf
[ 7]) << 18;
920 digest
[22] = (l
>> 16) & 0xff;
921 digest
[43] = (l
>> 8) & 0xff;
922 digest
[ 1] = (l
>> 0) & 0xff;
924 l
= itoa64_to_int (buf
[ 8]) << 0;
925 l
|= itoa64_to_int (buf
[ 9]) << 6;
926 l
|= itoa64_to_int (buf
[10]) << 12;
927 l
|= itoa64_to_int (buf
[11]) << 18;
929 digest
[44] = (l
>> 16) & 0xff;
930 digest
[ 2] = (l
>> 8) & 0xff;
931 digest
[23] = (l
>> 0) & 0xff;
933 l
= itoa64_to_int (buf
[12]) << 0;
934 l
|= itoa64_to_int (buf
[13]) << 6;
935 l
|= itoa64_to_int (buf
[14]) << 12;
936 l
|= itoa64_to_int (buf
[15]) << 18;
938 digest
[ 3] = (l
>> 16) & 0xff;
939 digest
[24] = (l
>> 8) & 0xff;
940 digest
[45] = (l
>> 0) & 0xff;
942 l
= itoa64_to_int (buf
[16]) << 0;
943 l
|= itoa64_to_int (buf
[17]) << 6;
944 l
|= itoa64_to_int (buf
[18]) << 12;
945 l
|= itoa64_to_int (buf
[19]) << 18;
947 digest
[25] = (l
>> 16) & 0xff;
948 digest
[46] = (l
>> 8) & 0xff;
949 digest
[ 4] = (l
>> 0) & 0xff;
951 l
= itoa64_to_int (buf
[20]) << 0;
952 l
|= itoa64_to_int (buf
[21]) << 6;
953 l
|= itoa64_to_int (buf
[22]) << 12;
954 l
|= itoa64_to_int (buf
[23]) << 18;
956 digest
[47] = (l
>> 16) & 0xff;
957 digest
[ 5] = (l
>> 8) & 0xff;
958 digest
[26] = (l
>> 0) & 0xff;
960 l
= itoa64_to_int (buf
[24]) << 0;
961 l
|= itoa64_to_int (buf
[25]) << 6;
962 l
|= itoa64_to_int (buf
[26]) << 12;
963 l
|= itoa64_to_int (buf
[27]) << 18;
965 digest
[ 6] = (l
>> 16) & 0xff;
966 digest
[27] = (l
>> 8) & 0xff;
967 digest
[48] = (l
>> 0) & 0xff;
969 l
= itoa64_to_int (buf
[28]) << 0;
970 l
|= itoa64_to_int (buf
[29]) << 6;
971 l
|= itoa64_to_int (buf
[30]) << 12;
972 l
|= itoa64_to_int (buf
[31]) << 18;
974 digest
[28] = (l
>> 16) & 0xff;
975 digest
[49] = (l
>> 8) & 0xff;
976 digest
[ 7] = (l
>> 0) & 0xff;
978 l
= itoa64_to_int (buf
[32]) << 0;
979 l
|= itoa64_to_int (buf
[33]) << 6;
980 l
|= itoa64_to_int (buf
[34]) << 12;
981 l
|= itoa64_to_int (buf
[35]) << 18;
983 digest
[50] = (l
>> 16) & 0xff;
984 digest
[ 8] = (l
>> 8) & 0xff;
985 digest
[29] = (l
>> 0) & 0xff;
987 l
= itoa64_to_int (buf
[36]) << 0;
988 l
|= itoa64_to_int (buf
[37]) << 6;
989 l
|= itoa64_to_int (buf
[38]) << 12;
990 l
|= itoa64_to_int (buf
[39]) << 18;
992 digest
[ 9] = (l
>> 16) & 0xff;
993 digest
[30] = (l
>> 8) & 0xff;
994 digest
[51] = (l
>> 0) & 0xff;
996 l
= itoa64_to_int (buf
[40]) << 0;
997 l
|= itoa64_to_int (buf
[41]) << 6;
998 l
|= itoa64_to_int (buf
[42]) << 12;
999 l
|= itoa64_to_int (buf
[43]) << 18;
1001 digest
[31] = (l
>> 16) & 0xff;
1002 digest
[52] = (l
>> 8) & 0xff;
1003 digest
[10] = (l
>> 0) & 0xff;
1005 l
= itoa64_to_int (buf
[44]) << 0;
1006 l
|= itoa64_to_int (buf
[45]) << 6;
1007 l
|= itoa64_to_int (buf
[46]) << 12;
1008 l
|= itoa64_to_int (buf
[47]) << 18;
1010 digest
[53] = (l
>> 16) & 0xff;
1011 digest
[11] = (l
>> 8) & 0xff;
1012 digest
[32] = (l
>> 0) & 0xff;
1014 l
= itoa64_to_int (buf
[48]) << 0;
1015 l
|= itoa64_to_int (buf
[49]) << 6;
1016 l
|= itoa64_to_int (buf
[50]) << 12;
1017 l
|= itoa64_to_int (buf
[51]) << 18;
1019 digest
[12] = (l
>> 16) & 0xff;
1020 digest
[33] = (l
>> 8) & 0xff;
1021 digest
[54] = (l
>> 0) & 0xff;
1023 l
= itoa64_to_int (buf
[52]) << 0;
1024 l
|= itoa64_to_int (buf
[53]) << 6;
1025 l
|= itoa64_to_int (buf
[54]) << 12;
1026 l
|= itoa64_to_int (buf
[55]) << 18;
1028 digest
[34] = (l
>> 16) & 0xff;
1029 digest
[55] = (l
>> 8) & 0xff;
1030 digest
[13] = (l
>> 0) & 0xff;
1032 l
= itoa64_to_int (buf
[56]) << 0;
1033 l
|= itoa64_to_int (buf
[57]) << 6;
1034 l
|= itoa64_to_int (buf
[58]) << 12;
1035 l
|= itoa64_to_int (buf
[59]) << 18;
1037 digest
[56] = (l
>> 16) & 0xff;
1038 digest
[14] = (l
>> 8) & 0xff;
1039 digest
[35] = (l
>> 0) & 0xff;
1041 l
= itoa64_to_int (buf
[60]) << 0;
1042 l
|= itoa64_to_int (buf
[61]) << 6;
1043 l
|= itoa64_to_int (buf
[62]) << 12;
1044 l
|= itoa64_to_int (buf
[63]) << 18;
1046 digest
[15] = (l
>> 16) & 0xff;
1047 digest
[36] = (l
>> 8) & 0xff;
1048 digest
[57] = (l
>> 0) & 0xff;
1050 l
= itoa64_to_int (buf
[64]) << 0;
1051 l
|= itoa64_to_int (buf
[65]) << 6;
1052 l
|= itoa64_to_int (buf
[66]) << 12;
1053 l
|= itoa64_to_int (buf
[67]) << 18;
1055 digest
[37] = (l
>> 16) & 0xff;
1056 digest
[58] = (l
>> 8) & 0xff;
1057 digest
[16] = (l
>> 0) & 0xff;
1059 l
= itoa64_to_int (buf
[68]) << 0;
1060 l
|= itoa64_to_int (buf
[69]) << 6;
1061 l
|= itoa64_to_int (buf
[70]) << 12;
1062 l
|= itoa64_to_int (buf
[71]) << 18;
1064 digest
[59] = (l
>> 16) & 0xff;
1065 digest
[17] = (l
>> 8) & 0xff;
1066 digest
[38] = (l
>> 0) & 0xff;
1068 l
= itoa64_to_int (buf
[72]) << 0;
1069 l
|= itoa64_to_int (buf
[73]) << 6;
1070 l
|= itoa64_to_int (buf
[74]) << 12;
1071 l
|= itoa64_to_int (buf
[75]) << 18;
1073 digest
[18] = (l
>> 16) & 0xff;
1074 digest
[39] = (l
>> 8) & 0xff;
1075 digest
[60] = (l
>> 0) & 0xff;
1077 l
= itoa64_to_int (buf
[76]) << 0;
1078 l
|= itoa64_to_int (buf
[77]) << 6;
1079 l
|= itoa64_to_int (buf
[78]) << 12;
1080 l
|= itoa64_to_int (buf
[79]) << 18;
1082 digest
[40] = (l
>> 16) & 0xff;
1083 digest
[61] = (l
>> 8) & 0xff;
1084 digest
[19] = (l
>> 0) & 0xff;
1086 l
= itoa64_to_int (buf
[80]) << 0;
1087 l
|= itoa64_to_int (buf
[81]) << 6;
1088 l
|= itoa64_to_int (buf
[82]) << 12;
1089 l
|= itoa64_to_int (buf
[83]) << 18;
1091 digest
[62] = (l
>> 16) & 0xff;
1092 digest
[20] = (l
>> 8) & 0xff;
1093 digest
[41] = (l
>> 0) & 0xff;
1095 l
= itoa64_to_int (buf
[84]) << 0;
1096 l
|= itoa64_to_int (buf
[85]) << 6;
1098 digest
[63] = (l
>> 0) & 0xff;
1101 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1105 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1107 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1108 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1109 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1110 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1112 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1114 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1115 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1116 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1117 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1119 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1121 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1123 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1124 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1126 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1128 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1130 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1131 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1133 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1135 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1137 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1138 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1140 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1142 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1144 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1145 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1147 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1149 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1151 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1152 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1154 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1156 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1158 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1159 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1161 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1163 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1165 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1166 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1168 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1170 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1172 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1173 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1175 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1177 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1179 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1180 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1182 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1184 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1186 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1187 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1189 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1191 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1193 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1194 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1196 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1198 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1200 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1201 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1203 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1205 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1207 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1208 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1210 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1212 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1214 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1215 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1217 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1219 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1221 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1222 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1224 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1226 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1228 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1229 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1231 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1233 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1235 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1236 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1238 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1240 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1242 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1243 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1245 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1247 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1249 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1250 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1252 l
= 0 | 0 | (digest
[63] << 0);
1254 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1255 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1258 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1262 l
= itoa64_to_int (buf
[ 0]) << 0;
1263 l
|= itoa64_to_int (buf
[ 1]) << 6;
1264 l
|= itoa64_to_int (buf
[ 2]) << 12;
1265 l
|= itoa64_to_int (buf
[ 3]) << 18;
1267 digest
[ 2] = (l
>> 0) & 0xff;
1268 digest
[ 1] = (l
>> 8) & 0xff;
1269 digest
[ 0] = (l
>> 16) & 0xff;
1271 l
= itoa64_to_int (buf
[ 4]) << 0;
1272 l
|= itoa64_to_int (buf
[ 5]) << 6;
1273 l
|= itoa64_to_int (buf
[ 6]) << 12;
1274 l
|= itoa64_to_int (buf
[ 7]) << 18;
1276 digest
[ 5] = (l
>> 0) & 0xff;
1277 digest
[ 4] = (l
>> 8) & 0xff;
1278 digest
[ 3] = (l
>> 16) & 0xff;
1280 l
= itoa64_to_int (buf
[ 8]) << 0;
1281 l
|= itoa64_to_int (buf
[ 9]) << 6;
1282 l
|= itoa64_to_int (buf
[10]) << 12;
1283 l
|= itoa64_to_int (buf
[11]) << 18;
1285 digest
[ 8] = (l
>> 0) & 0xff;
1286 digest
[ 7] = (l
>> 8) & 0xff;
1287 digest
[ 6] = (l
>> 16) & 0xff;
1289 l
= itoa64_to_int (buf
[12]) << 0;
1290 l
|= itoa64_to_int (buf
[13]) << 6;
1291 l
|= itoa64_to_int (buf
[14]) << 12;
1292 l
|= itoa64_to_int (buf
[15]) << 18;
1294 digest
[11] = (l
>> 0) & 0xff;
1295 digest
[10] = (l
>> 8) & 0xff;
1296 digest
[ 9] = (l
>> 16) & 0xff;
1298 l
= itoa64_to_int (buf
[16]) << 0;
1299 l
|= itoa64_to_int (buf
[17]) << 6;
1300 l
|= itoa64_to_int (buf
[18]) << 12;
1301 l
|= itoa64_to_int (buf
[19]) << 18;
1303 digest
[14] = (l
>> 0) & 0xff;
1304 digest
[13] = (l
>> 8) & 0xff;
1305 digest
[12] = (l
>> 16) & 0xff;
1307 l
= itoa64_to_int (buf
[20]) << 0;
1308 l
|= itoa64_to_int (buf
[21]) << 6;
1309 l
|= itoa64_to_int (buf
[22]) << 12;
1310 l
|= itoa64_to_int (buf
[23]) << 18;
1312 digest
[17] = (l
>> 0) & 0xff;
1313 digest
[16] = (l
>> 8) & 0xff;
1314 digest
[15] = (l
>> 16) & 0xff;
1316 l
= itoa64_to_int (buf
[24]) << 0;
1317 l
|= itoa64_to_int (buf
[25]) << 6;
1318 l
|= itoa64_to_int (buf
[26]) << 12;
1320 digest
[19] = (l
>> 8) & 0xff;
1321 digest
[18] = (l
>> 16) & 0xff;
1324 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1328 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1330 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1331 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1332 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1333 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1335 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1337 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1338 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1339 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1340 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1342 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1344 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1345 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1346 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1347 buf
[11] = int_to_itoa64 (l
& 0x3f);
1349 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1351 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1352 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1353 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1354 buf
[15] = int_to_itoa64 (l
& 0x3f);
1356 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1358 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1359 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1360 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1361 buf
[19] = int_to_itoa64 (l
& 0x3f);
1363 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1365 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1366 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1367 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1368 buf
[23] = int_to_itoa64 (l
& 0x3f);
1370 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1372 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1373 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1374 buf
[26] = int_to_itoa64 (l
& 0x3f);
1377 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1381 l
= itoa64_to_int (buf
[ 0]) << 0;
1382 l
|= itoa64_to_int (buf
[ 1]) << 6;
1383 l
|= itoa64_to_int (buf
[ 2]) << 12;
1384 l
|= itoa64_to_int (buf
[ 3]) << 18;
1386 digest
[ 2] = (l
>> 0) & 0xff;
1387 digest
[ 1] = (l
>> 8) & 0xff;
1388 digest
[ 0] = (l
>> 16) & 0xff;
1390 l
= itoa64_to_int (buf
[ 4]) << 0;
1391 l
|= itoa64_to_int (buf
[ 5]) << 6;
1392 l
|= itoa64_to_int (buf
[ 6]) << 12;
1393 l
|= itoa64_to_int (buf
[ 7]) << 18;
1395 digest
[ 5] = (l
>> 0) & 0xff;
1396 digest
[ 4] = (l
>> 8) & 0xff;
1397 digest
[ 3] = (l
>> 16) & 0xff;
1399 l
= itoa64_to_int (buf
[ 8]) << 0;
1400 l
|= itoa64_to_int (buf
[ 9]) << 6;
1401 l
|= itoa64_to_int (buf
[10]) << 12;
1402 l
|= itoa64_to_int (buf
[11]) << 18;
1404 digest
[ 8] = (l
>> 0) & 0xff;
1405 digest
[ 7] = (l
>> 8) & 0xff;
1406 digest
[ 6] = (l
>> 16) & 0xff;
1408 l
= itoa64_to_int (buf
[12]) << 0;
1409 l
|= itoa64_to_int (buf
[13]) << 6;
1410 l
|= itoa64_to_int (buf
[14]) << 12;
1411 l
|= itoa64_to_int (buf
[15]) << 18;
1413 digest
[11] = (l
>> 0) & 0xff;
1414 digest
[10] = (l
>> 8) & 0xff;
1415 digest
[ 9] = (l
>> 16) & 0xff;
1417 l
= itoa64_to_int (buf
[16]) << 0;
1418 l
|= itoa64_to_int (buf
[17]) << 6;
1419 l
|= itoa64_to_int (buf
[18]) << 12;
1420 l
|= itoa64_to_int (buf
[19]) << 18;
1422 digest
[14] = (l
>> 0) & 0xff;
1423 digest
[13] = (l
>> 8) & 0xff;
1424 digest
[12] = (l
>> 16) & 0xff;
1426 l
= itoa64_to_int (buf
[20]) << 0;
1427 l
|= itoa64_to_int (buf
[21]) << 6;
1428 l
|= itoa64_to_int (buf
[22]) << 12;
1429 l
|= itoa64_to_int (buf
[23]) << 18;
1431 digest
[17] = (l
>> 0) & 0xff;
1432 digest
[16] = (l
>> 8) & 0xff;
1433 digest
[15] = (l
>> 16) & 0xff;
1435 l
= itoa64_to_int (buf
[24]) << 0;
1436 l
|= itoa64_to_int (buf
[25]) << 6;
1437 l
|= itoa64_to_int (buf
[26]) << 12;
1438 l
|= itoa64_to_int (buf
[27]) << 18;
1440 digest
[20] = (l
>> 0) & 0xff;
1441 digest
[19] = (l
>> 8) & 0xff;
1442 digest
[18] = (l
>> 16) & 0xff;
1444 l
= itoa64_to_int (buf
[28]) << 0;
1445 l
|= itoa64_to_int (buf
[29]) << 6;
1446 l
|= itoa64_to_int (buf
[30]) << 12;
1447 l
|= itoa64_to_int (buf
[31]) << 18;
1449 digest
[23] = (l
>> 0) & 0xff;
1450 digest
[22] = (l
>> 8) & 0xff;
1451 digest
[21] = (l
>> 16) & 0xff;
1453 l
= itoa64_to_int (buf
[32]) << 0;
1454 l
|= itoa64_to_int (buf
[33]) << 6;
1455 l
|= itoa64_to_int (buf
[34]) << 12;
1456 l
|= itoa64_to_int (buf
[35]) << 18;
1458 digest
[26] = (l
>> 0) & 0xff;
1459 digest
[25] = (l
>> 8) & 0xff;
1460 digest
[24] = (l
>> 16) & 0xff;
1462 l
= itoa64_to_int (buf
[36]) << 0;
1463 l
|= itoa64_to_int (buf
[37]) << 6;
1464 l
|= itoa64_to_int (buf
[38]) << 12;
1465 l
|= itoa64_to_int (buf
[39]) << 18;
1467 digest
[29] = (l
>> 0) & 0xff;
1468 digest
[28] = (l
>> 8) & 0xff;
1469 digest
[27] = (l
>> 16) & 0xff;
1471 l
= itoa64_to_int (buf
[40]) << 0;
1472 l
|= itoa64_to_int (buf
[41]) << 6;
1473 l
|= itoa64_to_int (buf
[42]) << 12;
1475 //digest[32] = (l >> 0) & 0xff;
1476 digest
[31] = (l
>> 8) & 0xff;
1477 digest
[30] = (l
>> 16) & 0xff;
1480 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1484 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1486 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1487 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1488 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1489 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1491 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1493 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1494 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1495 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1496 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1498 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1500 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1501 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1502 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1503 buf
[11] = int_to_itoa64 (l
& 0x3f);
1505 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1507 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1508 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1509 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1510 buf
[15] = int_to_itoa64 (l
& 0x3f);
1512 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1514 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1515 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1516 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1517 buf
[19] = int_to_itoa64 (l
& 0x3f);
1519 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1521 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1522 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1523 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1524 buf
[23] = int_to_itoa64 (l
& 0x3f);
1526 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1528 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1529 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1530 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1531 buf
[27] = int_to_itoa64 (l
& 0x3f);
1533 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1535 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1536 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1537 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1538 buf
[31] = int_to_itoa64 (l
& 0x3f);
1540 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1542 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1543 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1544 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1545 buf
[35] = int_to_itoa64 (l
& 0x3f);
1547 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1549 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1550 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1551 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1552 buf
[39] = int_to_itoa64 (l
& 0x3f);
1554 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1556 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1557 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1558 buf
[42] = int_to_itoa64 (l
& 0x3f);
1561 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1565 l
= itoa64_to_int (buf
[ 0]) << 0;
1566 l
|= itoa64_to_int (buf
[ 1]) << 6;
1567 l
|= itoa64_to_int (buf
[ 2]) << 12;
1568 l
|= itoa64_to_int (buf
[ 3]) << 18;
1570 digest
[ 2] = (l
>> 0) & 0xff;
1571 digest
[ 1] = (l
>> 8) & 0xff;
1572 digest
[ 0] = (l
>> 16) & 0xff;
1574 l
= itoa64_to_int (buf
[ 4]) << 0;
1575 l
|= itoa64_to_int (buf
[ 5]) << 6;
1576 l
|= itoa64_to_int (buf
[ 6]) << 12;
1577 l
|= itoa64_to_int (buf
[ 7]) << 18;
1579 digest
[ 5] = (l
>> 0) & 0xff;
1580 digest
[ 4] = (l
>> 8) & 0xff;
1581 digest
[ 3] = (l
>> 16) & 0xff;
1583 l
= itoa64_to_int (buf
[ 8]) << 0;
1584 l
|= itoa64_to_int (buf
[ 9]) << 6;
1585 l
|= itoa64_to_int (buf
[10]) << 12;
1586 l
|= itoa64_to_int (buf
[11]) << 18;
1588 digest
[ 8] = (l
>> 0) & 0xff;
1589 digest
[ 7] = (l
>> 8) & 0xff;
1590 digest
[ 6] = (l
>> 16) & 0xff;
1592 l
= itoa64_to_int (buf
[12]) << 0;
1593 l
|= itoa64_to_int (buf
[13]) << 6;
1594 l
|= itoa64_to_int (buf
[14]) << 12;
1595 l
|= itoa64_to_int (buf
[15]) << 18;
1597 digest
[11] = (l
>> 0) & 0xff;
1598 digest
[10] = (l
>> 8) & 0xff;
1599 digest
[ 9] = (l
>> 16) & 0xff;
1601 l
= itoa64_to_int (buf
[16]) << 0;
1602 l
|= itoa64_to_int (buf
[17]) << 6;
1603 l
|= itoa64_to_int (buf
[18]) << 12;
1604 l
|= itoa64_to_int (buf
[19]) << 18;
1606 digest
[14] = (l
>> 0) & 0xff;
1607 digest
[13] = (l
>> 8) & 0xff;
1608 digest
[12] = (l
>> 16) & 0xff;
1610 l
= itoa64_to_int (buf
[20]) << 0;
1611 l
|= itoa64_to_int (buf
[21]) << 6;
1612 l
|= itoa64_to_int (buf
[22]) << 12;
1613 l
|= itoa64_to_int (buf
[23]) << 18;
1615 digest
[17] = (l
>> 0) & 0xff;
1616 digest
[16] = (l
>> 8) & 0xff;
1617 digest
[15] = (l
>> 16) & 0xff;
1619 l
= itoa64_to_int (buf
[24]) << 0;
1620 l
|= itoa64_to_int (buf
[25]) << 6;
1621 l
|= itoa64_to_int (buf
[26]) << 12;
1622 l
|= itoa64_to_int (buf
[27]) << 18;
1624 digest
[20] = (l
>> 0) & 0xff;
1625 digest
[19] = (l
>> 8) & 0xff;
1626 digest
[18] = (l
>> 16) & 0xff;
1628 l
= itoa64_to_int (buf
[28]) << 0;
1629 l
|= itoa64_to_int (buf
[29]) << 6;
1630 l
|= itoa64_to_int (buf
[30]) << 12;
1631 l
|= itoa64_to_int (buf
[31]) << 18;
1633 digest
[23] = (l
>> 0) & 0xff;
1634 digest
[22] = (l
>> 8) & 0xff;
1635 digest
[21] = (l
>> 16) & 0xff;
1637 l
= itoa64_to_int (buf
[32]) << 0;
1638 l
|= itoa64_to_int (buf
[33]) << 6;
1639 l
|= itoa64_to_int (buf
[34]) << 12;
1640 l
|= itoa64_to_int (buf
[35]) << 18;
1642 digest
[26] = (l
>> 0) & 0xff;
1643 digest
[25] = (l
>> 8) & 0xff;
1644 digest
[24] = (l
>> 16) & 0xff;
1646 l
= itoa64_to_int (buf
[36]) << 0;
1647 l
|= itoa64_to_int (buf
[37]) << 6;
1648 l
|= itoa64_to_int (buf
[38]) << 12;
1649 l
|= itoa64_to_int (buf
[39]) << 18;
1651 digest
[29] = (l
>> 0) & 0xff;
1652 digest
[28] = (l
>> 8) & 0xff;
1653 digest
[27] = (l
>> 16) & 0xff;
1655 l
= itoa64_to_int (buf
[40]) << 0;
1656 l
|= itoa64_to_int (buf
[41]) << 6;
1657 l
|= itoa64_to_int (buf
[42]) << 12;
1658 l
|= itoa64_to_int (buf
[43]) << 18;
1660 digest
[32] = (l
>> 0) & 0xff;
1661 digest
[31] = (l
>> 8) & 0xff;
1662 digest
[30] = (l
>> 16) & 0xff;
1664 l
= itoa64_to_int (buf
[44]) << 0;
1665 l
|= itoa64_to_int (buf
[45]) << 6;
1666 l
|= itoa64_to_int (buf
[46]) << 12;
1667 l
|= itoa64_to_int (buf
[47]) << 18;
1669 digest
[35] = (l
>> 0) & 0xff;
1670 digest
[34] = (l
>> 8) & 0xff;
1671 digest
[33] = (l
>> 16) & 0xff;
1673 l
= itoa64_to_int (buf
[48]) << 0;
1674 l
|= itoa64_to_int (buf
[49]) << 6;
1675 l
|= itoa64_to_int (buf
[50]) << 12;
1676 l
|= itoa64_to_int (buf
[51]) << 18;
1678 digest
[38] = (l
>> 0) & 0xff;
1679 digest
[37] = (l
>> 8) & 0xff;
1680 digest
[36] = (l
>> 16) & 0xff;
1682 l
= itoa64_to_int (buf
[52]) << 0;
1683 l
|= itoa64_to_int (buf
[53]) << 6;
1684 l
|= itoa64_to_int (buf
[54]) << 12;
1685 l
|= itoa64_to_int (buf
[55]) << 18;
1687 digest
[41] = (l
>> 0) & 0xff;
1688 digest
[40] = (l
>> 8) & 0xff;
1689 digest
[39] = (l
>> 16) & 0xff;
1691 l
= itoa64_to_int (buf
[56]) << 0;
1692 l
|= itoa64_to_int (buf
[57]) << 6;
1693 l
|= itoa64_to_int (buf
[58]) << 12;
1694 l
|= itoa64_to_int (buf
[59]) << 18;
1696 digest
[44] = (l
>> 0) & 0xff;
1697 digest
[43] = (l
>> 8) & 0xff;
1698 digest
[42] = (l
>> 16) & 0xff;
1700 l
= itoa64_to_int (buf
[60]) << 0;
1701 l
|= itoa64_to_int (buf
[61]) << 6;
1702 l
|= itoa64_to_int (buf
[62]) << 12;
1703 l
|= itoa64_to_int (buf
[63]) << 18;
1705 digest
[47] = (l
>> 0) & 0xff;
1706 digest
[46] = (l
>> 8) & 0xff;
1707 digest
[45] = (l
>> 16) & 0xff;
1709 l
= itoa64_to_int (buf
[64]) << 0;
1710 l
|= itoa64_to_int (buf
[65]) << 6;
1711 l
|= itoa64_to_int (buf
[66]) << 12;
1712 l
|= itoa64_to_int (buf
[67]) << 18;
1714 digest
[50] = (l
>> 0) & 0xff;
1715 digest
[49] = (l
>> 8) & 0xff;
1716 digest
[48] = (l
>> 16) & 0xff;
1718 l
= itoa64_to_int (buf
[68]) << 0;
1719 l
|= itoa64_to_int (buf
[69]) << 6;
1720 l
|= itoa64_to_int (buf
[70]) << 12;
1721 l
|= itoa64_to_int (buf
[71]) << 18;
1723 digest
[53] = (l
>> 0) & 0xff;
1724 digest
[52] = (l
>> 8) & 0xff;
1725 digest
[51] = (l
>> 16) & 0xff;
1727 l
= itoa64_to_int (buf
[72]) << 0;
1728 l
|= itoa64_to_int (buf
[73]) << 6;
1729 l
|= itoa64_to_int (buf
[74]) << 12;
1730 l
|= itoa64_to_int (buf
[75]) << 18;
1732 digest
[56] = (l
>> 0) & 0xff;
1733 digest
[55] = (l
>> 8) & 0xff;
1734 digest
[54] = (l
>> 16) & 0xff;
1736 l
= itoa64_to_int (buf
[76]) << 0;
1737 l
|= itoa64_to_int (buf
[77]) << 6;
1738 l
|= itoa64_to_int (buf
[78]) << 12;
1739 l
|= itoa64_to_int (buf
[79]) << 18;
1741 digest
[59] = (l
>> 0) & 0xff;
1742 digest
[58] = (l
>> 8) & 0xff;
1743 digest
[57] = (l
>> 16) & 0xff;
1745 l
= itoa64_to_int (buf
[80]) << 0;
1746 l
|= itoa64_to_int (buf
[81]) << 6;
1747 l
|= itoa64_to_int (buf
[82]) << 12;
1748 l
|= itoa64_to_int (buf
[83]) << 18;
1750 digest
[62] = (l
>> 0) & 0xff;
1751 digest
[61] = (l
>> 8) & 0xff;
1752 digest
[60] = (l
>> 16) & 0xff;
1754 l
= itoa64_to_int (buf
[84]) << 0;
1755 l
|= itoa64_to_int (buf
[85]) << 6;
1757 digest
[63] = (l
>> 16) & 0xff;
1760 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1764 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1766 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1767 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1768 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1769 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1771 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1773 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1774 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1775 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1776 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1778 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1780 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1781 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1782 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1783 buf
[11] = int_to_itoa64 (l
& 0x3f);
1785 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1787 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1788 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1789 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1790 buf
[15] = int_to_itoa64 (l
& 0x3f);
1792 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1794 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1795 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1796 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1797 buf
[19] = int_to_itoa64 (l
& 0x3f);
1799 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1801 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1802 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1803 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1804 buf
[23] = int_to_itoa64 (l
& 0x3f);
1806 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1808 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1809 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1810 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1811 buf
[27] = int_to_itoa64 (l
& 0x3f);
1813 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1815 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1816 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1817 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1818 buf
[31] = int_to_itoa64 (l
& 0x3f);
1820 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1822 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1823 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1824 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1825 buf
[35] = int_to_itoa64 (l
& 0x3f);
1827 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1829 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1830 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1831 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1832 buf
[39] = int_to_itoa64 (l
& 0x3f);
1834 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1836 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1837 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1838 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1839 buf
[43] = int_to_itoa64 (l
& 0x3f);
1841 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1843 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1844 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1845 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1846 buf
[47] = int_to_itoa64 (l
& 0x3f);
1848 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1850 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1851 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1852 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1853 buf
[51] = int_to_itoa64 (l
& 0x3f);
1855 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1857 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1858 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1859 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1860 buf
[55] = int_to_itoa64 (l
& 0x3f);
1862 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1864 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1865 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1866 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1867 buf
[59] = int_to_itoa64 (l
& 0x3f);
1869 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1871 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1872 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1873 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1874 buf
[63] = int_to_itoa64 (l
& 0x3f);
1876 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1878 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1879 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1880 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1881 buf
[67] = int_to_itoa64 (l
& 0x3f);
1883 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1885 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1886 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1887 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1888 buf
[71] = int_to_itoa64 (l
& 0x3f);
1890 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1892 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1893 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1894 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1895 buf
[75] = int_to_itoa64 (l
& 0x3f);
1897 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1899 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1900 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1901 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1902 buf
[79] = int_to_itoa64 (l
& 0x3f);
1904 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1906 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1907 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1908 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1909 buf
[83] = int_to_itoa64 (l
& 0x3f);
1911 l
= 0 | 0 | (digest
[63] << 16);
1913 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1914 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1917 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1921 l
= itoa64_to_int (buf
[ 0]) << 0;
1922 l
|= itoa64_to_int (buf
[ 1]) << 6;
1923 l
|= itoa64_to_int (buf
[ 2]) << 12;
1924 l
|= itoa64_to_int (buf
[ 3]) << 18;
1926 digest
[ 0] = (l
>> 16) & 0xff;
1927 digest
[10] = (l
>> 8) & 0xff;
1928 digest
[20] = (l
>> 0) & 0xff;
1930 l
= itoa64_to_int (buf
[ 4]) << 0;
1931 l
|= itoa64_to_int (buf
[ 5]) << 6;
1932 l
|= itoa64_to_int (buf
[ 6]) << 12;
1933 l
|= itoa64_to_int (buf
[ 7]) << 18;
1935 digest
[21] = (l
>> 16) & 0xff;
1936 digest
[ 1] = (l
>> 8) & 0xff;
1937 digest
[11] = (l
>> 0) & 0xff;
1939 l
= itoa64_to_int (buf
[ 8]) << 0;
1940 l
|= itoa64_to_int (buf
[ 9]) << 6;
1941 l
|= itoa64_to_int (buf
[10]) << 12;
1942 l
|= itoa64_to_int (buf
[11]) << 18;
1944 digest
[12] = (l
>> 16) & 0xff;
1945 digest
[22] = (l
>> 8) & 0xff;
1946 digest
[ 2] = (l
>> 0) & 0xff;
1948 l
= itoa64_to_int (buf
[12]) << 0;
1949 l
|= itoa64_to_int (buf
[13]) << 6;
1950 l
|= itoa64_to_int (buf
[14]) << 12;
1951 l
|= itoa64_to_int (buf
[15]) << 18;
1953 digest
[ 3] = (l
>> 16) & 0xff;
1954 digest
[13] = (l
>> 8) & 0xff;
1955 digest
[23] = (l
>> 0) & 0xff;
1957 l
= itoa64_to_int (buf
[16]) << 0;
1958 l
|= itoa64_to_int (buf
[17]) << 6;
1959 l
|= itoa64_to_int (buf
[18]) << 12;
1960 l
|= itoa64_to_int (buf
[19]) << 18;
1962 digest
[24] = (l
>> 16) & 0xff;
1963 digest
[ 4] = (l
>> 8) & 0xff;
1964 digest
[14] = (l
>> 0) & 0xff;
1966 l
= itoa64_to_int (buf
[20]) << 0;
1967 l
|= itoa64_to_int (buf
[21]) << 6;
1968 l
|= itoa64_to_int (buf
[22]) << 12;
1969 l
|= itoa64_to_int (buf
[23]) << 18;
1971 digest
[15] = (l
>> 16) & 0xff;
1972 digest
[25] = (l
>> 8) & 0xff;
1973 digest
[ 5] = (l
>> 0) & 0xff;
1975 l
= itoa64_to_int (buf
[24]) << 0;
1976 l
|= itoa64_to_int (buf
[25]) << 6;
1977 l
|= itoa64_to_int (buf
[26]) << 12;
1978 l
|= itoa64_to_int (buf
[27]) << 18;
1980 digest
[ 6] = (l
>> 16) & 0xff;
1981 digest
[16] = (l
>> 8) & 0xff;
1982 digest
[26] = (l
>> 0) & 0xff;
1984 l
= itoa64_to_int (buf
[28]) << 0;
1985 l
|= itoa64_to_int (buf
[29]) << 6;
1986 l
|= itoa64_to_int (buf
[30]) << 12;
1987 l
|= itoa64_to_int (buf
[31]) << 18;
1989 digest
[27] = (l
>> 16) & 0xff;
1990 digest
[ 7] = (l
>> 8) & 0xff;
1991 digest
[17] = (l
>> 0) & 0xff;
1993 l
= itoa64_to_int (buf
[32]) << 0;
1994 l
|= itoa64_to_int (buf
[33]) << 6;
1995 l
|= itoa64_to_int (buf
[34]) << 12;
1996 l
|= itoa64_to_int (buf
[35]) << 18;
1998 digest
[18] = (l
>> 16) & 0xff;
1999 digest
[28] = (l
>> 8) & 0xff;
2000 digest
[ 8] = (l
>> 0) & 0xff;
2002 l
= itoa64_to_int (buf
[36]) << 0;
2003 l
|= itoa64_to_int (buf
[37]) << 6;
2004 l
|= itoa64_to_int (buf
[38]) << 12;
2005 l
|= itoa64_to_int (buf
[39]) << 18;
2007 digest
[ 9] = (l
>> 16) & 0xff;
2008 digest
[19] = (l
>> 8) & 0xff;
2009 digest
[29] = (l
>> 0) & 0xff;
2011 l
= itoa64_to_int (buf
[40]) << 0;
2012 l
|= itoa64_to_int (buf
[41]) << 6;
2013 l
|= itoa64_to_int (buf
[42]) << 12;
2015 digest
[31] = (l
>> 8) & 0xff;
2016 digest
[30] = (l
>> 0) & 0xff;
2019 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2023 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2025 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2026 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2027 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2028 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2030 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2032 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2033 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2034 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2035 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2037 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2039 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2041 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2042 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2044 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2046 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2048 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2049 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2051 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2053 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2055 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2056 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2058 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2060 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2062 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2063 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2065 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2067 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2069 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2070 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2072 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2074 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2076 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2077 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2079 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2081 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2083 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2084 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2086 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2088 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2090 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2091 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2093 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2095 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2096 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2097 buf
[42] = int_to_itoa64 (l
& 0x3f);
2100 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2104 l
= itoa64_to_int (buf
[ 0]) << 0;
2105 l
|= itoa64_to_int (buf
[ 1]) << 6;
2106 l
|= itoa64_to_int (buf
[ 2]) << 12;
2107 l
|= itoa64_to_int (buf
[ 3]) << 18;
2109 digest
[ 0] = (l
>> 0) & 0xff;
2110 digest
[ 1] = (l
>> 8) & 0xff;
2111 digest
[ 2] = (l
>> 16) & 0xff;
2113 l
= itoa64_to_int (buf
[ 4]) << 0;
2114 l
|= itoa64_to_int (buf
[ 5]) << 6;
2115 l
|= itoa64_to_int (buf
[ 6]) << 12;
2116 l
|= itoa64_to_int (buf
[ 7]) << 18;
2118 digest
[ 3] = (l
>> 0) & 0xff;
2119 digest
[ 4] = (l
>> 8) & 0xff;
2120 digest
[ 5] = (l
>> 16) & 0xff;
2122 l
= itoa64_to_int (buf
[ 8]) << 0;
2123 l
|= itoa64_to_int (buf
[ 9]) << 6;
2124 l
|= itoa64_to_int (buf
[10]) << 12;
2125 l
|= itoa64_to_int (buf
[11]) << 18;
2127 digest
[ 6] = (l
>> 0) & 0xff;
2128 digest
[ 7] = (l
>> 8) & 0xff;
2129 digest
[ 8] = (l
>> 16) & 0xff;
2131 l
= itoa64_to_int (buf
[12]) << 0;
2132 l
|= itoa64_to_int (buf
[13]) << 6;
2133 l
|= itoa64_to_int (buf
[14]) << 12;
2134 l
|= itoa64_to_int (buf
[15]) << 18;
2136 digest
[ 9] = (l
>> 0) & 0xff;
2137 digest
[10] = (l
>> 8) & 0xff;
2138 digest
[11] = (l
>> 16) & 0xff;
2140 l
= itoa64_to_int (buf
[16]) << 0;
2141 l
|= itoa64_to_int (buf
[17]) << 6;
2142 l
|= itoa64_to_int (buf
[18]) << 12;
2143 l
|= itoa64_to_int (buf
[19]) << 18;
2145 digest
[12] = (l
>> 0) & 0xff;
2146 digest
[13] = (l
>> 8) & 0xff;
2147 digest
[14] = (l
>> 16) & 0xff;
2149 l
= itoa64_to_int (buf
[20]) << 0;
2150 l
|= itoa64_to_int (buf
[21]) << 6;
2151 l
|= itoa64_to_int (buf
[22]) << 12;
2152 l
|= itoa64_to_int (buf
[23]) << 18;
2154 digest
[15] = (l
>> 0) & 0xff;
2155 digest
[16] = (l
>> 8) & 0xff;
2156 digest
[17] = (l
>> 16) & 0xff;
2158 l
= itoa64_to_int (buf
[24]) << 0;
2159 l
|= itoa64_to_int (buf
[25]) << 6;
2160 l
|= itoa64_to_int (buf
[26]) << 12;
2161 l
|= itoa64_to_int (buf
[27]) << 18;
2163 digest
[18] = (l
>> 0) & 0xff;
2164 digest
[19] = (l
>> 8) & 0xff;
2165 digest
[20] = (l
>> 16) & 0xff;
2167 l
= itoa64_to_int (buf
[28]) << 0;
2168 l
|= itoa64_to_int (buf
[29]) << 6;
2169 l
|= itoa64_to_int (buf
[30]) << 12;
2170 l
|= itoa64_to_int (buf
[31]) << 18;
2172 digest
[21] = (l
>> 0) & 0xff;
2173 digest
[22] = (l
>> 8) & 0xff;
2174 digest
[23] = (l
>> 16) & 0xff;
2176 l
= itoa64_to_int (buf
[32]) << 0;
2177 l
|= itoa64_to_int (buf
[33]) << 6;
2178 l
|= itoa64_to_int (buf
[34]) << 12;
2179 l
|= itoa64_to_int (buf
[35]) << 18;
2181 digest
[24] = (l
>> 0) & 0xff;
2182 digest
[25] = (l
>> 8) & 0xff;
2183 digest
[26] = (l
>> 16) & 0xff;
2185 l
= itoa64_to_int (buf
[36]) << 0;
2186 l
|= itoa64_to_int (buf
[37]) << 6;
2187 l
|= itoa64_to_int (buf
[38]) << 12;
2188 l
|= itoa64_to_int (buf
[39]) << 18;
2190 digest
[27] = (l
>> 0) & 0xff;
2191 digest
[28] = (l
>> 8) & 0xff;
2192 digest
[29] = (l
>> 16) & 0xff;
2194 l
= itoa64_to_int (buf
[40]) << 0;
2195 l
|= itoa64_to_int (buf
[41]) << 6;
2196 l
|= itoa64_to_int (buf
[42]) << 12;
2197 l
|= itoa64_to_int (buf
[43]) << 18;
2199 digest
[30] = (l
>> 0) & 0xff;
2200 digest
[31] = (l
>> 8) & 0xff;
2201 digest
[32] = (l
>> 16) & 0xff;
2236 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2240 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2242 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2243 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2244 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2245 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2247 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2249 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2250 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2251 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2252 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2254 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2256 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2257 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2258 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2259 buf
[11] = int_to_itoa64 (l
& 0x3f);
2261 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2263 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2264 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2265 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2266 buf
[15] = int_to_itoa64 (l
& 0x3f);
2268 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2270 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2271 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2272 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2273 buf
[19] = int_to_itoa64 (l
& 0x3f);
2275 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2277 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2278 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2279 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2280 buf
[23] = int_to_itoa64 (l
& 0x3f);
2282 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2284 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2285 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2286 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2287 buf
[27] = int_to_itoa64 (l
& 0x3f);
2289 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2291 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2292 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2293 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2294 buf
[31] = int_to_itoa64 (l
& 0x3f);
2296 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2298 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2299 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2300 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2301 buf
[35] = int_to_itoa64 (l
& 0x3f);
2303 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2305 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2306 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2307 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2308 buf
[39] = int_to_itoa64 (l
& 0x3f);
2310 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2312 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2313 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2314 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2315 //buf[43] = int_to_itoa64 (l & 0x3f);
2323 static struct termio savemodes
;
2324 static int havemodes
= 0;
2328 struct termio modmodes
;
2330 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2334 modmodes
= savemodes
;
2335 modmodes
.c_lflag
&= ~ICANON
;
2336 modmodes
.c_cc
[VMIN
] = 1;
2337 modmodes
.c_cc
[VTIME
] = 0;
2339 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2348 FD_SET (fileno (stdin
), &rfds
);
2355 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2357 if (retval
== 0) return 0;
2358 if (retval
== -1) return -1;
2365 if (!havemodes
) return 0;
2367 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2372 static struct termios savemodes
;
2373 static int havemodes
= 0;
2377 struct termios modmodes
;
2379 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2383 modmodes
= savemodes
;
2384 modmodes
.c_lflag
&= ~ICANON
;
2385 modmodes
.c_cc
[VMIN
] = 1;
2386 modmodes
.c_cc
[VTIME
] = 0;
2388 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2397 FD_SET (fileno (stdin
), &rfds
);
2404 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2406 if (retval
== 0) return 0;
2407 if (retval
== -1) return -1;
2414 if (!havemodes
) return 0;
2416 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2421 static DWORD saveMode
= 0;
2425 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2427 GetConsoleMode (stdinHandle
, &saveMode
);
2428 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2435 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2437 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2439 if (rc
== WAIT_TIMEOUT
) return 0;
2440 if (rc
== WAIT_ABANDONED
) return -1;
2441 if (rc
== WAIT_FAILED
) return -1;
2443 // The whole ReadConsoleInput () part is a workaround.
2444 // For some unknown reason, maybe a mingw bug, a random signal
2445 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2446 // Then it wants to read with getche () a keyboard input
2447 // which has never been made.
2449 INPUT_RECORD buf
[100];
2453 memset (buf
, 0, sizeof (buf
));
2455 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2457 FlushConsoleInputBuffer (stdinHandle
);
2459 for (uint i
= 0; i
< num
; i
++)
2461 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2463 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2465 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2467 return KeyEvent
.uChar
.AsciiChar
;
2475 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2477 SetConsoleMode (stdinHandle
, saveMode
);
2487 #define MSG_ENOMEM "Insufficient memory available"
2489 void *mycalloc (size_t nmemb
, size_t size
)
2491 void *p
= calloc (nmemb
, size
);
2495 log_error ("ERROR: %s", MSG_ENOMEM
);
2503 void *mymalloc (size_t size
)
2505 void *p
= malloc (size
);
2509 log_error ("ERROR: %s", MSG_ENOMEM
);
2514 memset (p
, 0, size
);
2519 void myfree (void *ptr
)
2521 if (ptr
== NULL
) return;
2526 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2528 void *p
= realloc (ptr
, oldsz
+ add
);
2532 log_error ("ERROR: %s", MSG_ENOMEM
);
2537 memset ((char *) p
+ oldsz
, 0, add
);
2542 char *mystrdup (const char *s
)
2544 const size_t len
= strlen (s
);
2546 char *b
= (char *) mymalloc (len
+ 1);
2553 FILE *logfile_open (char *logfile
)
2555 FILE *fp
= fopen (logfile
, "ab");
2565 void logfile_close (FILE *fp
)
2567 if (fp
== stdout
) return;
2572 void logfile_append (const char *fmt
, ...)
2574 if (data
.logfile_disable
== 1) return;
2576 FILE *fp
= logfile_open (data
.logfile
);
2582 vfprintf (fp
, fmt
, ap
);
2593 int logfile_generate_id ()
2595 const int n
= rand ();
2604 char *logfile_generate_topid ()
2606 const int id
= logfile_generate_id ();
2608 char *topid
= (char *) mymalloc (1 + 16 + 1);
2610 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2615 char *logfile_generate_subid ()
2617 const int id
= logfile_generate_id ();
2619 char *subid
= (char *) mymalloc (1 + 16 + 1);
2621 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2631 void lock_file (FILE *fp
)
2635 memset (&lock
, 0, sizeof (struct flock
));
2637 lock
.l_type
= F_WRLCK
;
2638 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2642 log_error ("ERROR: failed acquiring write lock: %s", strerror (errno
));
2649 void unlock_file (FILE *fp
)
2653 memset (&lock
, 0, sizeof (struct flock
));
2655 lock
.l_type
= F_UNLCK
;
2656 fcntl(fileno(fp
), F_SETLK
, &lock
);
2663 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2665 FlushFileBuffers (h
);
2675 int get_adapters_num_adl (void *adl
, int *iNumberAdapters
)
2677 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2679 if (iNumberAdapters
== 0)
2681 log_info ("WARN: No ADL adapters found.");
2690 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2692 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2693 ADLODParameters lpOdParameters;
2695 lpOdParameters.iSize = sizeof (ADLODParameters);
2696 size_t plevels_size = 0;
2698 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2700 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2701 __func__, iAdapterIndex,
2702 lpOdParameters.iNumberOfPerformanceLevels,
2703 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2704 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2706 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2708 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2710 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2712 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2714 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2715 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2716 __func__, iAdapterIndex, j,
2717 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2719 myfree (lpOdPerformanceLevels);
2725 LPAdapterInfo
hm_get_adapter_info_adl (void *adl
, int iNumberAdapters
)
2727 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2729 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2731 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2733 return lpAdapterInfo
;
2736 int hm_get_adapter_index_nvapi (HM_ADAPTER_NVAPI nvapiGPUHandle
[DEVICES_MAX
])
2740 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nvapi
, nvapiGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2744 log_info ("WARN: No NvAPI adapters found");
2752 int hm_get_adapter_index_nvml (HM_ADAPTER_NVML nvmlGPUHandle
[DEVICES_MAX
])
2756 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2758 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nvml
, 1, i
, &nvmlGPUHandle
[i
]) != NVML_SUCCESS
) break;
2760 // can be used to determine if the device by index matches the cuda device by index
2761 // char name[100]; memset (name, 0, sizeof (name));
2762 // hm_NVML_nvmlDeviceGetName (data.hm_nvml, nvGPUHandle[i], name, sizeof (name) - 1);
2769 log_info ("WARN: No NVML adapters found");
2779 // does not help at all, since ADL does not assign different bus id, device id when we have multi GPU setups
2782 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2786 for (uint i = 0; i < num_adl_adapters; i++)
2788 int opencl_bus_num = hm_device[i].busid;
2789 int opencl_dev_num = hm_device[i].devid;
2791 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2799 if (idx >= DEVICES_MAX) return -1;
2804 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2806 for (uint i = 0; i < opencl_num_devices; i++)
2808 cl_device_topology_amd device_topology;
2810 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2812 hm_device[i].busid = device_topology.pcie.bus;
2813 hm_device[i].devid = device_topology.pcie.device;
2818 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2820 // basically bubble sort
2822 for (int i
= 0; i
< num_adl_adapters
; i
++)
2824 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2826 // get info of adapter [x]
2828 u32 adapter_index_x
= valid_adl_device_list
[j
];
2829 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2831 u32 bus_num_x
= info_x
.iBusNumber
;
2832 u32 dev_num_x
= info_x
.iDeviceNumber
;
2834 // get info of adapter [y]
2836 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2837 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2839 u32 bus_num_y
= info_y
.iBusNumber
;
2840 u32 dev_num_y
= info_y
.iDeviceNumber
;
2844 if (bus_num_y
< bus_num_x
)
2848 else if (bus_num_y
== bus_num_x
)
2850 if (dev_num_y
< dev_num_x
)
2858 u32 temp
= valid_adl_device_list
[j
+ 1];
2860 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2861 valid_adl_device_list
[j
+ 0] = temp
;
2867 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2869 *num_adl_adapters
= 0;
2871 u32
*adl_adapters
= NULL
;
2873 int *bus_numbers
= NULL
;
2874 int *device_numbers
= NULL
;
2876 for (int i
= 0; i
< iNumberAdapters
; i
++)
2878 AdapterInfo info
= lpAdapterInfo
[i
];
2880 if (strlen (info
.strUDID
) < 1) continue;
2883 if (info
.iVendorID
!= 1002) continue;
2885 if (info
.iVendorID
!= 0x1002) continue;
2888 if (info
.iBusNumber
< 0) continue;
2889 if (info
.iDeviceNumber
< 0) continue;
2893 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2895 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2902 if (found
) continue;
2904 // add it to the list
2906 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2908 adl_adapters
[*num_adl_adapters
] = i
;
2910 // rest is just bookkeeping
2912 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2913 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2915 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2916 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2918 (*num_adl_adapters
)++;
2921 myfree (bus_numbers
);
2922 myfree (device_numbers
);
2924 // sort the list by increasing bus id, device id number
2926 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2928 return adl_adapters
;
2931 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2933 // loop through all valid devices
2935 for (int i
= 0; i
< num_adl_adapters
; i
++)
2937 u32 adapter_index
= valid_adl_device_list
[i
];
2941 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2943 // unfortunately this doesn't work since bus id and dev id are not unique
2944 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2945 // if (opencl_device_index == -1) continue;
2947 int opencl_device_index
= i
;
2949 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2951 // get fanspeed info
2953 if (hm_device
[opencl_device_index
].od_version
== 5)
2955 ADLFanSpeedInfo FanSpeedInfo
;
2957 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2959 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2961 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2963 // check read and write capability in fanspeedinfo
2965 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2966 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2968 hm_device
[opencl_device_index
].fan_get_supported
= 1;
2972 hm_device
[opencl_device_index
].fan_get_supported
= 0;
2975 else // od_version == 6
2977 ADLOD6FanSpeedInfo faninfo
;
2979 memset (&faninfo
, 0, sizeof (faninfo
));
2981 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2983 // check read capability in fanspeedinfo
2985 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2987 hm_device
[opencl_device_index
].fan_get_supported
= 1;
2991 hm_device
[opencl_device_index
].fan_get_supported
= 0;
2999 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3001 for (int i
= 0; i
< num_adl_adapters
; i
++)
3003 u32 adapter_index
= valid_adl_device_list
[i
];
3007 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3009 // get overdrive version
3011 int od_supported
= 0;
3015 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3017 // store the overdrive version in hm_device
3019 // unfortunately this doesn't work since bus id and dev id are not unique
3020 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3021 // if (opencl_device_index == -1) continue;
3023 int opencl_device_index
= i
;
3025 hm_device
[opencl_device_index
].od_version
= od_version
;
3031 int hm_get_adapter_index_adl (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3033 for (int i
= 0; i
< num_adl_adapters
; i
++)
3035 u32 adapter_index
= valid_adl_device_list
[i
];
3039 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3041 // store the iAdapterIndex in hm_device
3043 // unfortunately this doesn't work since bus id and dev id are not unique
3044 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3045 // if (opencl_device_index == -1) continue;
3047 int opencl_device_index
= i
;
3049 hm_device
[opencl_device_index
].adl
= info
.iAdapterIndex
;
3052 return num_adl_adapters
;
3055 int hm_get_threshold_slowdown_with_device_id (const uint device_id
)
3057 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3059 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3063 if (data
.hm_device
[device_id
].od_version
== 5)
3067 else if (data
.hm_device
[device_id
].od_version
== 6)
3069 int CurrentValue
= 0;
3070 int DefaultValue
= 0;
3072 if (hm_ADL_Overdrive6_TargetTemperatureData_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &CurrentValue
, &DefaultValue
) != ADL_OK
) return -1;
3074 // the return value has never been tested since hm_ADL_Overdrive6_TargetTemperatureData_Get() never worked on any system. expect problems.
3076 return DefaultValue
;
3081 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3085 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;
3093 int hm_get_threshold_shutdown_with_device_id (const uint device_id
)
3095 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3097 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3101 if (data
.hm_device
[device_id
].od_version
== 5)
3105 else if (data
.hm_device
[device_id
].od_version
== 6)
3112 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3116 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;
3124 int hm_get_temperature_with_device_id (const uint device_id
)
3126 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3128 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3132 if (data
.hm_device
[device_id
].od_version
== 5)
3134 ADLTemperature Temperature
;
3136 Temperature
.iSize
= sizeof (ADLTemperature
);
3138 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &Temperature
) != ADL_OK
) return -1;
3140 return Temperature
.iTemperature
/ 1000;
3142 else if (data
.hm_device
[device_id
].od_version
== 6)
3144 int Temperature
= 0;
3146 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &Temperature
) != ADL_OK
) return -1;
3148 return Temperature
/ 1000;
3153 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3155 int temperature
= 0;
3157 if (hm_NVML_nvmlDeviceGetTemperature (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
) != NVML_SUCCESS
) return -1;
3165 int hm_get_fanpolicy_with_device_id (const uint device_id
)
3167 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3169 if (data
.hm_device
[device_id
].fan_get_supported
== 1)
3171 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3175 if (data
.hm_device
[device_id
].od_version
== 5)
3177 ADLFanSpeedValue lpFanSpeedValue
;
3179 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3181 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3182 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3184 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3186 return (lpFanSpeedValue
.iFanSpeed
& ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
) ? 0 : 1;
3188 else // od_version == 6
3195 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3204 int hm_get_fanspeed_with_device_id (const uint device_id
)
3206 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3208 if (data
.hm_device
[device_id
].fan_get_supported
== 1)
3210 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3214 if (data
.hm_device
[device_id
].od_version
== 5)
3216 ADLFanSpeedValue lpFanSpeedValue
;
3218 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3220 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3221 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3222 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3224 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3226 return lpFanSpeedValue
.iFanSpeed
;
3228 else // od_version == 6
3230 ADLOD6FanSpeedInfo faninfo
;
3232 memset (&faninfo
, 0, sizeof (faninfo
));
3234 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &faninfo
) != ADL_OK
) return -1;
3236 return faninfo
.iFanSpeedPercent
;
3241 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3245 if (hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nvml
, 0, data
.hm_device
[device_id
].nvml
, (uint
*) &speed
) != NVML_SUCCESS
) return -1;
3254 int hm_get_buslanes_with_device_id (const uint device_id
)
3256 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3258 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3262 ADLPMActivity PMActivity
;
3264 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3266 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3268 return PMActivity
.iCurrentBusLanes
;
3272 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3274 unsigned int currLinkWidth
;
3276 if (hm_NVML_nvmlDeviceGetCurrPcieLinkWidth (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &currLinkWidth
) != NVML_SUCCESS
) return -1;
3278 return currLinkWidth
;
3284 int hm_get_utilization_with_device_id (const uint device_id
)
3286 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3288 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3292 ADLPMActivity PMActivity
;
3294 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3296 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3298 return PMActivity
.iActivityPercent
;
3302 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3304 nvmlUtilization_t utilization
;
3306 if (hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &utilization
) != NVML_SUCCESS
) return -1;
3308 return utilization
.gpu
;
3314 int hm_get_memoryspeed_with_device_id (const uint device_id
)
3316 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3318 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3322 ADLPMActivity PMActivity
;
3324 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3326 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3328 return PMActivity
.iMemoryClock
/ 100;
3332 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3336 if (hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_CLOCK_MEM
, &clock
) != NVML_SUCCESS
) return -1;
3344 int hm_get_corespeed_with_device_id (const uint device_id
)
3346 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3348 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3352 ADLPMActivity PMActivity
;
3354 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3356 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3358 return PMActivity
.iEngineClock
/ 100;
3362 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3366 if (hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_CLOCK_SM
, &clock
) != NVML_SUCCESS
) return -1;
3374 int hm_get_throttle_with_device_id (const uint device_id
)
3376 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3378 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3383 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3385 unsigned long long clocksThrottleReasons
= 0;
3386 unsigned long long supportedThrottleReasons
= 0;
3388 if (hm_NVML_nvmlDeviceGetCurrentClocksThrottleReasons (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &clocksThrottleReasons
) != NVML_SUCCESS
) return -1;
3389 if (hm_NVML_nvmlDeviceGetSupportedClocksThrottleReasons (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &supportedThrottleReasons
) != NVML_SUCCESS
) return -1;
3391 clocksThrottleReasons
&= supportedThrottleReasons
;
3393 clocksThrottleReasons
&= ~nvmlClocksThrottleReasonUnknown
;
3395 return (clocksThrottleReasons
> 0);
3401 int hm_set_fanspeed_with_device_id_adl (const uint device_id
, const int fanspeed
, const int fanpolicy
)
3403 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3407 if (data
.hm_device
[device_id
].od_version
== 5)
3409 ADLFanSpeedValue lpFanSpeedValue
;
3411 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3413 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3414 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3415 lpFanSpeedValue
.iFlags
= (fanpolicy
== 1) ? ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
: 0;
3416 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3418 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3422 else // od_version == 6
3424 ADLOD6FanSpeedValue fan_speed_value
;
3426 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3428 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3429 fan_speed_value
.iFanSpeed
= fanspeed
;
3431 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &fan_speed_value
) != ADL_OK
) return -1;
3441 int hm_set_fanspeed_with_device_id_nvapi (const uint device_id
, const int fanspeed
, const int fanpolicy
)
3443 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3447 NV_GPU_COOLER_LEVELS CoolerLevels
= { 0 };
3449 CoolerLevels
.Version
= GPU_COOLER_LEVELS_VER
| sizeof (NV_GPU_COOLER_LEVELS
);
3451 CoolerLevels
.Levels
[0].Level
= fanspeed
;
3452 CoolerLevels
.Levels
[0].Policy
= fanpolicy
;
3454 if (hm_NvAPI_GPU_SetCoolerLevels (data
.hm_nvapi
, data
.hm_device
[device_id
].nvapi
, 0, &CoolerLevels
) != NVAPI_OK
) return -1;
3463 int hm_set_fanspeed_with_device_id_xnvctrl (const uint device_id
, const int fanspeed
)
3465 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3467 if (data
.hm_xnvctrl
)
3469 if (set_fan_speed_target (data
.hm_xnvctrl
, data
.hm_device
[device_id
].xnvctrl
, fanspeed
) != 0) return -1;
3478 #endif // HAVE_HWMON
3484 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3486 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3488 if (css_cnt
> SP_PW_MAX
)
3490 log_error ("ERROR: mask length is too long");
3495 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3497 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3499 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3500 uint cs_len
= css
[css_pos
].cs_len
;
3502 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3504 uint c
= cs_buf
[cs_pos
] & 0xff;
3511 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3513 cs_t
*cs
= &css
[css_cnt
];
3515 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3517 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3521 for (i
= 0; i
< cs
->cs_len
; i
++)
3523 const uint u
= cs
->cs_buf
[i
];
3528 for (i
= 0; i
< in_len
; i
++)
3530 uint u
= in_buf
[i
] & 0xff;
3532 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3534 if (css_uniq
[u
] == 1) continue;
3538 cs
->cs_buf
[cs
->cs_len
] = u
;
3546 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3550 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3552 uint p0
= in_buf
[in_pos
] & 0xff;
3554 if (interpret
== 1 && p0
== '?')
3558 if (in_pos
== in_len
) break;
3560 uint p1
= in_buf
[in_pos
] & 0xff;
3564 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3566 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3568 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3570 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3572 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3574 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3576 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3577 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3579 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3580 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3582 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3583 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3585 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3586 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3588 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3590 default: log_error ("Syntax error: %s", in_buf
);
3596 if (data
.hex_charset
)
3600 if (in_pos
== in_len
)
3602 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3607 uint p1
= in_buf
[in_pos
] & 0xff;
3609 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3611 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3618 chr
= hex_convert (p1
) << 0;
3619 chr
|= hex_convert (p0
) << 4;
3621 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3627 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3633 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3637 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3639 sum
*= css
[css_pos
].cs_len
;
3645 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3647 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3652 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3654 char p0
= mask_buf
[mask_pos
];
3660 if (mask_pos
== mask_len
) break;
3662 char p1
= mask_buf
[mask_pos
];
3668 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3670 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3672 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3674 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3676 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3678 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3680 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3681 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3683 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3684 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3686 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3687 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3689 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3690 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3692 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3694 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3700 if (data
.hex_charset
)
3704 // if there is no 2nd hex character, show an error:
3706 if (mask_pos
== mask_len
)
3708 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3713 char p1
= mask_buf
[mask_pos
];
3715 // if they are not valid hex character, show an error:
3717 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3719 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3726 chr
|= hex_convert (p1
) << 0;
3727 chr
|= hex_convert (p0
) << 4;
3729 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3735 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3742 log_error ("ERROR: invalid mask length (0)");
3752 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3754 for (int i
= 0; i
< css_cnt
; i
++)
3756 uint len
= css
[i
].cs_len
;
3757 u64 next
= val
/ len
;
3758 uint pos
= val
% len
;
3759 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3764 void mp_cut_at (char *mask
, uint max
)
3768 uint mask_len
= strlen (mask
);
3770 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3772 if (mask
[i
] == '?') i
++;
3778 void mp_setup_sys (cs_t
*mp_sys
)
3782 uint donec
[CHARSIZ
] = { 0 };
3784 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3785 mp_sys
[0].cs_buf
[pos
++] = chr
;
3786 mp_sys
[0].cs_len
= pos
; }
3788 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3789 mp_sys
[1].cs_buf
[pos
++] = chr
;
3790 mp_sys
[1].cs_len
= pos
; }
3792 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3793 mp_sys
[2].cs_buf
[pos
++] = chr
;
3794 mp_sys
[2].cs_len
= pos
; }
3796 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3797 mp_sys
[3].cs_buf
[pos
++] = chr
;
3798 mp_sys
[3].cs_len
= pos
; }
3800 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3801 mp_sys
[4].cs_len
= pos
; }
3803 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3804 mp_sys
[5].cs_len
= pos
; }
3807 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3809 FILE *fp
= fopen (buf
, "rb");
3811 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3813 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3817 char mp_file
[1024] = { 0 };
3819 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3823 len
= in_superchop (mp_file
);
3827 log_info ("WARNING: charset file corrupted");
3829 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3833 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3838 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3840 mp_usr
[index
].cs_len
= 0;
3842 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3845 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3847 char *new_mask_buf
= (char *) mymalloc (256);
3853 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3855 if (css_pos
== len
) break;
3857 char p0
= mask_buf
[mask_pos
];
3859 new_mask_buf
[mask_pos
] = p0
;
3865 if (mask_pos
== mask_len
) break;
3867 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3871 if (data
.hex_charset
)
3875 if (mask_pos
== mask_len
)
3877 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3882 char p1
= mask_buf
[mask_pos
];
3884 // if they are not valid hex character, show an error:
3886 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3888 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3893 new_mask_buf
[mask_pos
] = p1
;
3898 if (css_pos
== len
) return (new_mask_buf
);
3900 myfree (new_mask_buf
);
3909 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3915 for (i
= start
; i
< stop
; i
++)
3917 sum
*= root_css_buf
[i
].cs_len
;
3923 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3927 cs_t
*cs
= &root_css_buf
[start
];
3931 for (i
= start
; i
< stop
; i
++)
3933 const u64 m
= v
% cs
->cs_len
;
3934 const u64 d
= v
/ cs
->cs_len
;
3938 const uint k
= cs
->cs_buf
[m
];
3940 pw_buf
[i
- start
] = (char) k
;
3942 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3946 int sp_comp_val (const void *p1
, const void *p2
)
3948 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3949 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3951 return b2
->val
- b1
->val
;
3954 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
)
3961 * Initialize hcstats
3964 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3966 u64
*root_stats_ptr
= root_stats_buf
;
3968 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3970 for (i
= 0; i
< SP_PW_MAX
; i
++)
3972 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3974 root_stats_ptr
+= CHARSIZ
;
3977 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3979 u64
*markov_stats_ptr
= markov_stats_buf
;
3981 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3983 for (i
= 0; i
< SP_PW_MAX
; i
++)
3985 for (j
= 0; j
< CHARSIZ
; j
++)
3987 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3989 markov_stats_ptr
+= CHARSIZ
;
3999 char hcstat_tmp
[256] = { 0 };
4001 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
4003 hcstat
= hcstat_tmp
;
4006 FILE *fd
= fopen (hcstat
, "rb");
4010 log_error ("%s: %s", hcstat
, strerror (errno
));
4015 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
4017 log_error ("%s: Could not load data", hcstat
);
4024 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
4026 log_error ("%s: Could not load data", hcstat
);
4036 * Markov modifier of hcstat_table on user request
4041 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
4042 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
4047 /* Add all stats to first position */
4049 for (i
= 1; i
< SP_PW_MAX
; i
++)
4051 u64
*out
= root_stats_buf_by_pos
[0];
4052 u64
*in
= root_stats_buf_by_pos
[i
];
4054 for (j
= 0; j
< CHARSIZ
; j
++)
4060 for (i
= 1; i
< SP_PW_MAX
; i
++)
4062 u64
*out
= markov_stats_buf_by_key
[0][0];
4063 u64
*in
= markov_stats_buf_by_key
[i
][0];
4065 for (j
= 0; j
< CHARSIZ
; j
++)
4067 for (k
= 0; k
< CHARSIZ
; k
++)
4074 /* copy them to all pw_positions */
4076 for (i
= 1; i
< SP_PW_MAX
; i
++)
4078 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
4081 for (i
= 1; i
< SP_PW_MAX
; i
++)
4083 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
4091 hcstat_table_t
*root_table_ptr
= root_table_buf
;
4093 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
4095 for (i
= 0; i
< SP_PW_MAX
; i
++)
4097 root_table_buf_by_pos
[i
] = root_table_ptr
;
4099 root_table_ptr
+= CHARSIZ
;
4102 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
4104 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4106 for (i
= 0; i
< SP_PW_MAX
; i
++)
4108 for (j
= 0; j
< CHARSIZ
; j
++)
4110 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
4112 markov_table_ptr
+= CHARSIZ
;
4117 * Convert hcstat to tables
4120 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
4122 uint key
= i
% CHARSIZ
;
4124 root_table_buf
[i
].key
= key
;
4125 root_table_buf
[i
].val
= root_stats_buf
[i
];
4128 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
4130 uint key
= i
% CHARSIZ
;
4132 markov_table_buf
[i
].key
= key
;
4133 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
4136 myfree (root_stats_buf
);
4137 myfree (markov_stats_buf
);
4143 for (i
= 0; i
< SP_PW_MAX
; i
++)
4145 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4148 for (i
= 0; i
< SP_PW_MAX
; i
++)
4150 for (j
= 0; j
< CHARSIZ
; j
++)
4152 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4157 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
])
4160 * Convert tables to css
4163 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
4165 uint pw_pos
= i
/ CHARSIZ
;
4167 cs_t
*cs
= &root_css_buf
[pw_pos
];
4169 if (cs
->cs_len
== threshold
) continue;
4171 uint key
= root_table_buf
[i
].key
;
4173 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
4175 cs
->cs_buf
[cs
->cs_len
] = key
;
4181 * Convert table to css
4184 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4186 uint c
= i
/ CHARSIZ
;
4188 cs_t
*cs
= &markov_css_buf
[c
];
4190 if (cs
->cs_len
== threshold
) continue;
4192 uint pw_pos
= c
/ CHARSIZ
;
4194 uint key
= markov_table_buf
[i
].key
;
4196 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4198 cs
->cs_buf
[cs
->cs_len
] = key
;
4204 for (uint i = 0; i < 8; i++)
4206 for (uint j = 0x20; j < 0x80; j++)
4208 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4210 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4212 for (uint k = 0; k < 10; k++)
4214 printf (" %u\n", ptr->cs_buf[k]);
4221 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4223 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4225 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4235 for (uint j
= 1; j
< CHARSIZ
; j
++)
4245 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4247 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4249 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4251 out
+= CHARSIZ
* CHARSIZ
;
4252 in
+= CHARSIZ
* CHARSIZ
;
4254 for (uint j
= 0; j
< CHARSIZ
; j
++)
4261 for (uint k
= 1; k
< CHARSIZ
; k
++)
4273 * mixed shared functions
4276 void dump_hex (const u8
*s
, const int sz
)
4278 for (int i
= 0; i
< sz
; i
++)
4280 log_info_nn ("%02x ", s
[i
]);
4286 void usage_mini_print (const char *progname
)
4288 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4291 void usage_big_print (const char *progname
)
4293 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4296 char *get_exec_path ()
4298 int exec_path_len
= 1024;
4300 char *exec_path
= (char *) mymalloc (exec_path_len
);
4304 char tmp
[32] = { 0 };
4306 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4308 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4312 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4316 uint size
= exec_path_len
;
4318 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4320 log_error("! executable path buffer too small\n");
4325 const int len
= strlen (exec_path
);
4328 #error Your Operating System is not supported or detected
4336 char *get_install_dir (const char *progname
)
4338 char *install_dir
= mystrdup (progname
);
4339 char *last_slash
= NULL
;
4341 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4345 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4351 install_dir
[0] = '.';
4355 return (install_dir
);
4358 char *get_profile_dir (const char *homedir
)
4360 #define DOT_HASHCAT ".hashcat"
4362 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4364 char *profile_dir
= (char *) mymalloc (len
+ 1);
4366 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4371 char *get_session_dir (const char *profile_dir
)
4373 #define SESSIONS_FOLDER "sessions"
4375 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4377 char *session_dir
= (char *) mymalloc (len
+ 1);
4379 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4384 uint
count_lines (FILE *fd
)
4388 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4394 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4396 if (nread
< 1) continue;
4400 for (i
= 0; i
< nread
; i
++)
4402 if (prev
== '\n') cnt
++;
4413 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4417 FILE *fd
= fopen (filename
, "rb");
4421 log_error ("%s: %s", filename
, strerror (errno
));
4426 #define MAX_KEY_SIZE (1024 * 1024)
4428 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4430 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4436 for (int fpos
= 0; fpos
< nread
; fpos
++)
4438 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4440 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4441 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4442 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4443 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4445 if (kpos
>= 64) kpos
= 0;
4452 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4456 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4457 if (CPU_ISSET(core
, cpu_set
)) break;
4459 thread_affinity_policy_data_t policy
= { core
};
4461 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4463 if (data
.quiet
== 0)
4465 if (rc
!= KERN_SUCCESS
)
4467 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4475 void set_cpu_affinity (char *cpu_affinity
)
4478 DWORD_PTR aff_mask
= 0;
4486 char *devices
= strdup (cpu_affinity
);
4488 char *next
= strtok (devices
, ",");
4492 uint cpu_id
= atoi (next
);
4507 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4513 aff_mask
|= 1 << (cpu_id
- 1);
4515 CPU_SET ((cpu_id
- 1), &cpuset
);
4518 } while ((next
= strtok (NULL
, ",")) != NULL
);
4524 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4525 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4527 pthread_t thread
= pthread_self ();
4528 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4532 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4534 char *element
, *end
;
4536 end
= (char *) base
+ nmemb
* size
;
4538 for (element
= (char *) base
; element
< end
; element
+= size
)
4539 if (!compar (element
, key
))
4545 int sort_by_u32 (const void *v1
, const void *v2
)
4547 const u32
*s1
= (const u32
*) v1
;
4548 const u32
*s2
= (const u32
*) v2
;
4553 int sort_by_salt (const void *v1
, const void *v2
)
4555 const salt_t
*s1
= (const salt_t
*) v1
;
4556 const salt_t
*s2
= (const salt_t
*) v2
;
4558 const int res1
= s1
->salt_len
- s2
->salt_len
;
4560 if (res1
!= 0) return (res1
);
4562 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4564 if (res2
!= 0) return (res2
);
4572 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4573 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4580 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4581 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4587 int sort_by_salt_buf (const void *v1
, const void *v2
)
4589 const pot_t
*p1
= (const pot_t
*) v1
;
4590 const pot_t
*p2
= (const pot_t
*) v2
;
4592 const hash_t
*h1
= &p1
->hash
;
4593 const hash_t
*h2
= &p2
->hash
;
4595 const salt_t
*s1
= h1
->salt
;
4596 const salt_t
*s2
= h2
->salt
;
4602 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4603 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4609 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4611 const hash_t
*h1
= (const hash_t
*) v1
;
4612 const hash_t
*h2
= (const hash_t
*) v2
;
4614 const salt_t
*s1
= h1
->salt
;
4615 const salt_t
*s2
= h2
->salt
;
4617 // testphase: this should work
4622 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4623 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4626 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4627 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4628 if (s1->salt_len > s2->salt_len) return ( 1);
4629 if (s1->salt_len < s2->salt_len) return (-1);
4631 uint n = s1->salt_len;
4635 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4636 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4643 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4645 const hash_t
*h1
= (const hash_t
*) v1
;
4646 const hash_t
*h2
= (const hash_t
*) v2
;
4648 const salt_t
*s1
= h1
->salt
;
4649 const salt_t
*s2
= h2
->salt
;
4651 // 16 - 2 (since last 2 uints contain the digest)
4656 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4657 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4663 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4665 const hash_t
*h1
= (const hash_t
*) v1
;
4666 const hash_t
*h2
= (const hash_t
*) v2
;
4668 const void *d1
= h1
->digest
;
4669 const void *d2
= h2
->digest
;
4671 return data
.sort_by_digest (d1
, d2
);
4674 int sort_by_hash (const void *v1
, const void *v2
)
4676 const hash_t
*h1
= (const hash_t
*) v1
;
4677 const hash_t
*h2
= (const hash_t
*) v2
;
4681 const salt_t
*s1
= h1
->salt
;
4682 const salt_t
*s2
= h2
->salt
;
4684 int res
= sort_by_salt (s1
, s2
);
4686 if (res
!= 0) return (res
);
4689 const void *d1
= h1
->digest
;
4690 const void *d2
= h2
->digest
;
4692 return data
.sort_by_digest (d1
, d2
);
4695 int sort_by_pot (const void *v1
, const void *v2
)
4697 const pot_t
*p1
= (const pot_t
*) v1
;
4698 const pot_t
*p2
= (const pot_t
*) v2
;
4700 const hash_t
*h1
= &p1
->hash
;
4701 const hash_t
*h2
= &p2
->hash
;
4703 return sort_by_hash (h1
, h2
);
4706 int sort_by_mtime (const void *p1
, const void *p2
)
4708 const char **f1
= (const char **) p1
;
4709 const char **f2
= (const char **) p2
;
4711 struct stat s1
; stat (*f1
, &s1
);
4712 struct stat s2
; stat (*f2
, &s2
);
4714 return s2
.st_mtime
- s1
.st_mtime
;
4717 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4719 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4720 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4722 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4725 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4727 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4728 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4730 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4733 int sort_by_stringptr (const void *p1
, const void *p2
)
4735 const char **s1
= (const char **) p1
;
4736 const char **s2
= (const char **) p2
;
4738 return strcmp (*s1
, *s2
);
4741 int sort_by_dictstat (const void *s1
, const void *s2
)
4743 dictstat_t
*d1
= (dictstat_t
*) s1
;
4744 dictstat_t
*d2
= (dictstat_t
*) s2
;
4747 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4749 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4752 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4755 int sort_by_bitmap (const void *p1
, const void *p2
)
4757 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4758 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4760 return b1
->collisions
- b2
->collisions
;
4763 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4765 const u32
*d1
= (const u32
*) v1
;
4766 const u32
*d2
= (const u32
*) v2
;
4772 if (d1
[n
] > d2
[n
]) return ( 1);
4773 if (d1
[n
] < d2
[n
]) return (-1);
4779 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4781 const u32
*d1
= (const u32
*) v1
;
4782 const u32
*d2
= (const u32
*) v2
;
4788 if (d1
[n
] > d2
[n
]) return ( 1);
4789 if (d1
[n
] < d2
[n
]) return (-1);
4795 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4797 const u32
*d1
= (const u32
*) v1
;
4798 const u32
*d2
= (const u32
*) v2
;
4804 if (d1
[n
] > d2
[n
]) return ( 1);
4805 if (d1
[n
] < d2
[n
]) return (-1);
4811 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4813 const u32
*d1
= (const u32
*) v1
;
4814 const u32
*d2
= (const u32
*) v2
;
4820 if (d1
[n
] > d2
[n
]) return ( 1);
4821 if (d1
[n
] < d2
[n
]) return (-1);
4827 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4829 const u32
*d1
= (const u32
*) v1
;
4830 const u32
*d2
= (const u32
*) v2
;
4836 if (d1
[n
] > d2
[n
]) return ( 1);
4837 if (d1
[n
] < d2
[n
]) return (-1);
4843 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4845 const u32
*d1
= (const u32
*) v1
;
4846 const u32
*d2
= (const u32
*) v2
;
4852 if (d1
[n
] > d2
[n
]) return ( 1);
4853 if (d1
[n
] < d2
[n
]) return (-1);
4859 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4861 const u32
*d1
= (const u32
*) v1
;
4862 const u32
*d2
= (const u32
*) v2
;
4868 if (d1
[n
] > d2
[n
]) return ( 1);
4869 if (d1
[n
] < d2
[n
]) return (-1);
4875 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4877 const u32
*d1
= (const u32
*) v1
;
4878 const u32
*d2
= (const u32
*) v2
;
4884 if (d1
[n
] > d2
[n
]) return ( 1);
4885 if (d1
[n
] < d2
[n
]) return (-1);
4891 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4893 const u64
*d1
= (const u64
*) v1
;
4894 const u64
*d2
= (const u64
*) v2
;
4900 if (d1
[n
] > d2
[n
]) return ( 1);
4901 if (d1
[n
] < d2
[n
]) return (-1);
4907 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4909 const u64
*d1
= (const u64
*) v1
;
4910 const u64
*d2
= (const u64
*) v2
;
4916 if (d1
[n
] > d2
[n
]) return ( 1);
4917 if (d1
[n
] < d2
[n
]) return (-1);
4923 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4925 const u64
*d1
= (const u64
*) v1
;
4926 const u64
*d2
= (const u64
*) v2
;
4932 if (d1
[n
] > d2
[n
]) return ( 1);
4933 if (d1
[n
] < d2
[n
]) return (-1);
4939 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4941 const u32
*d1
= (const u32
*) v1
;
4942 const u32
*d2
= (const u32
*) v2
;
4944 const uint dgst_pos0
= data
.dgst_pos0
;
4945 const uint dgst_pos1
= data
.dgst_pos1
;
4946 const uint dgst_pos2
= data
.dgst_pos2
;
4947 const uint dgst_pos3
= data
.dgst_pos3
;
4949 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4950 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4951 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4952 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4953 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4954 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4955 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4956 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4961 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4963 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4964 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4966 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4968 if (res1
!= 0) return (res1
);
4973 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4975 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4976 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4978 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4980 if (res1
!= 0) return (res1
);
4982 const int res2
= t1
->attack_mode
4985 if (res2
!= 0) return (res2
);
4987 const int res3
= t1
->hash_type
4990 if (res3
!= 0) return (res3
);
4995 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
)
4997 uint outfile_autohex
= data
.outfile_autohex
;
4999 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
5001 FILE *debug_fp
= NULL
;
5003 if (debug_file
!= NULL
)
5005 debug_fp
= fopen (debug_file
, "ab");
5007 lock_file (debug_fp
);
5014 if (debug_fp
== NULL
)
5016 log_info ("WARNING: Could not open debug-file for writing");
5020 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
5022 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
5024 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
5027 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
5029 if (debug_mode
== 4)
5031 fputc (':', debug_fp
);
5033 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
5036 fputc ('\n', debug_fp
);
5038 if (debug_file
!= NULL
) fclose (debug_fp
);
5042 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
5044 int needs_hexify
= 0;
5046 if (outfile_autohex
== 1)
5048 for (uint i
= 0; i
< plain_len
; i
++)
5050 if (plain_ptr
[i
] < 0x20)
5057 if (plain_ptr
[i
] > 0x7f)
5066 if (needs_hexify
== 1)
5068 fprintf (fp
, "$HEX[");
5070 for (uint i
= 0; i
< plain_len
; i
++)
5072 fprintf (fp
, "%02x", plain_ptr
[i
]);
5079 fwrite (plain_ptr
, plain_len
, 1, fp
);
5083 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
)
5085 uint outfile_format
= data
.outfile_format
;
5087 char separator
= data
.separator
;
5089 if (outfile_format
& OUTFILE_FMT_HASH
)
5091 fprintf (out_fp
, "%s", out_buf
);
5093 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5095 fputc (separator
, out_fp
);
5098 else if (data
.username
)
5100 if (username
!= NULL
)
5102 for (uint i
= 0; i
< user_len
; i
++)
5104 fprintf (out_fp
, "%c", username
[i
]);
5107 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5109 fputc (separator
, out_fp
);
5114 if (outfile_format
& OUTFILE_FMT_PLAIN
)
5116 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
5118 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5120 fputc (separator
, out_fp
);
5124 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
5126 for (uint i
= 0; i
< plain_len
; i
++)
5128 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
5131 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
5133 fputc (separator
, out_fp
);
5137 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
5140 __mingw_fprintf (out_fp
, "%llu", crackpos
);
5145 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
5147 fprintf (out_fp
, "%llu", crackpos
);
5152 fputc ('\n', out_fp
);
5155 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
)
5159 pot_key
.hash
.salt
= hashes_buf
->salt
;
5160 pot_key
.hash
.digest
= hashes_buf
->digest
;
5162 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5168 input_buf
[input_len
] = 0;
5171 unsigned char *username
= NULL
;
5176 user_t
*user
= hashes_buf
->hash_info
->user
;
5180 username
= (unsigned char *) (user
->user_name
);
5182 user_len
= user
->user_len
;
5186 // do output the line
5187 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5191 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5192 #define LM_MASKED_PLAIN "[notfound]"
5194 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
)
5200 pot_left_key
.hash
.salt
= hash_left
->salt
;
5201 pot_left_key
.hash
.digest
= hash_left
->digest
;
5203 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5207 uint weak_hash_found
= 0;
5209 pot_t pot_right_key
;
5211 pot_right_key
.hash
.salt
= hash_right
->salt
;
5212 pot_right_key
.hash
.digest
= hash_right
->digest
;
5214 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5216 if (pot_right_ptr
== NULL
)
5218 // special case, if "weak hash"
5220 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5222 weak_hash_found
= 1;
5224 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5226 // in theory this is not needed, but we are paranoia:
5228 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5229 pot_right_ptr
->plain_len
= 0;
5233 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5235 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
5240 // at least one half was found:
5244 input_buf
[input_len
] = 0;
5248 unsigned char *username
= NULL
;
5253 user_t
*user
= hash_left
->hash_info
->user
;
5257 username
= (unsigned char *) (user
->user_name
);
5259 user_len
= user
->user_len
;
5263 // mask the part which was not found
5265 uint left_part_masked
= 0;
5266 uint right_part_masked
= 0;
5268 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5270 if (pot_left_ptr
== NULL
)
5272 left_part_masked
= 1;
5274 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5276 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5278 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5279 pot_left_ptr
->plain_len
= mask_plain_len
;
5282 if (pot_right_ptr
== NULL
)
5284 right_part_masked
= 1;
5286 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5288 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5290 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5291 pot_right_ptr
->plain_len
= mask_plain_len
;
5294 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5298 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5300 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5302 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5304 // do output the line
5306 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5308 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5310 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5311 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5314 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
)
5318 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5320 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5322 if (pot_ptr
== NULL
)
5326 input_buf
[input_len
] = 0;
5328 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5332 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
)
5338 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5340 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5344 pot_t pot_right_key
;
5346 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5348 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5350 uint weak_hash_found
= 0;
5352 if (pot_right_ptr
== NULL
)
5354 // special case, if "weak hash"
5356 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5358 weak_hash_found
= 1;
5360 // we just need that pot_right_ptr is not a NULL pointer
5362 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5366 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5368 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5373 // ... at least one part was not cracked
5377 input_buf
[input_len
] = 0;
5379 // only show the hash part which is still not cracked
5381 uint user_len
= input_len
- 32;
5383 char *hash_output
= (char *) mymalloc (33);
5385 memcpy (hash_output
, input_buf
, input_len
);
5387 if (pot_left_ptr
!= NULL
)
5389 // only show right part (because left part was already found)
5391 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5393 hash_output
[user_len
+ 16] = 0;
5396 if (pot_right_ptr
!= NULL
)
5398 // only show left part (because right part was already found)
5400 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5402 hash_output
[user_len
+ 16] = 0;
5405 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5407 myfree (hash_output
);
5409 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5412 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5414 uint opencl_platforms_filter
= 0;
5416 if (opencl_platforms
)
5418 char *platforms
= strdup (opencl_platforms
);
5420 char *next
= strtok (platforms
, ",");
5424 int platform
= atoi (next
);
5426 if (platform
< 1 || platform
> 32)
5428 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5433 opencl_platforms_filter
|= 1 << (platform
- 1);
5435 } while ((next
= strtok (NULL
, ",")) != NULL
);
5441 opencl_platforms_filter
= -1;
5444 return opencl_platforms_filter
;
5447 u32
setup_devices_filter (char *opencl_devices
)
5449 u32 devices_filter
= 0;
5453 char *devices
= strdup (opencl_devices
);
5455 char *next
= strtok (devices
, ",");
5459 int device_id
= atoi (next
);
5461 if (device_id
< 1 || device_id
> 32)
5463 log_error ("ERROR: invalid device_id %u specified", device_id
);
5468 devices_filter
|= 1 << (device_id
- 1);
5470 } while ((next
= strtok (NULL
, ",")) != NULL
);
5476 devices_filter
= -1;
5479 return devices_filter
;
5482 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5484 cl_device_type device_types_filter
= 0;
5486 if (opencl_device_types
)
5488 char *device_types
= strdup (opencl_device_types
);
5490 char *next
= strtok (device_types
, ",");
5494 int device_type
= atoi (next
);
5496 if (device_type
< 1 || device_type
> 3)
5498 log_error ("ERROR: invalid device_type %u specified", device_type
);
5503 device_types_filter
|= 1 << device_type
;
5505 } while ((next
= strtok (NULL
, ",")) != NULL
);
5507 free (device_types
);
5511 // Do not use CPU by default, this often reduces GPU performance because
5512 // the CPU is too busy to handle GPU synchronization
5514 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5517 return device_types_filter
;
5520 u32
get_random_num (const u32 min
, const u32 max
)
5522 if (min
== max
) return (min
);
5524 return ((rand () % (max
- min
)) + min
);
5527 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5529 u32 quotient
= dividend
/ divisor
;
5531 if (dividend
% divisor
) quotient
++;
5536 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5538 u64 quotient
= dividend
/ divisor
;
5540 if (dividend
% divisor
) quotient
++;
5545 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5547 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5548 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5550 if (tm
->tm_year
- 70)
5552 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5553 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5555 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5557 else if (tm
->tm_yday
)
5559 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5560 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5562 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5564 else if (tm
->tm_hour
)
5566 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5567 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5569 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5571 else if (tm
->tm_min
)
5573 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5574 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5576 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5580 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5582 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5586 void format_speed_display (float val
, char *buf
, size_t len
)
5597 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5608 /* generate output */
5612 snprintf (buf
, len
- 1, "%.0f ", val
);
5616 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5620 void lowercase (u8
*buf
, int len
)
5622 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5625 void uppercase (u8
*buf
, int len
)
5627 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5630 int fgetl (FILE *fp
, char *line_buf
)
5636 const int c
= fgetc (fp
);
5638 if (c
== EOF
) break;
5640 line_buf
[line_len
] = (char) c
;
5644 if (line_len
== HCBUFSIZ
) line_len
--;
5646 if (c
== '\n') break;
5649 if (line_len
== 0) return 0;
5651 if (line_buf
[line_len
- 1] == '\n')
5655 line_buf
[line_len
] = 0;
5658 if (line_len
== 0) return 0;
5660 if (line_buf
[line_len
- 1] == '\r')
5664 line_buf
[line_len
] = 0;
5670 int in_superchop (char *buf
)
5672 int len
= strlen (buf
);
5676 if (buf
[len
- 1] == '\n')
5683 if (buf
[len
- 1] == '\r')
5698 char **scan_directory (const char *path
)
5700 char *tmp_path
= mystrdup (path
);
5702 size_t tmp_path_len
= strlen (tmp_path
);
5704 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5706 tmp_path
[tmp_path_len
- 1] = 0;
5708 tmp_path_len
= strlen (tmp_path
);
5711 char **files
= NULL
;
5717 if ((d
= opendir (tmp_path
)) != NULL
)
5723 memset (&e
, 0, sizeof (e
));
5724 struct dirent
*de
= NULL
;
5726 if (readdir_r (d
, &e
, &de
) != 0)
5728 log_error ("ERROR: readdir_r() failed");
5733 if (de
== NULL
) break;
5737 while ((de
= readdir (d
)) != NULL
)
5740 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5742 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5744 char *path_file
= (char *) mymalloc (path_size
+ 1);
5746 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5748 path_file
[path_size
] = 0;
5752 if ((d_test
= opendir (path_file
)) != NULL
)
5760 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5764 files
[num_files
- 1] = path_file
;
5770 else if (errno
== ENOTDIR
)
5772 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5776 files
[num_files
- 1] = mystrdup (path
);
5779 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5783 files
[num_files
- 1] = NULL
;
5790 int count_dictionaries (char **dictionary_files
)
5792 if (dictionary_files
== NULL
) return 0;
5796 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5804 char *stroptitype (const uint opti_type
)
5808 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5809 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5810 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5811 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5812 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5813 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5814 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5815 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5816 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5817 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5818 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5819 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5820 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5821 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5822 case OPTI_TYPE_SLOW_HASH_SIMD
: return ((char *) OPTI_STR_SLOW_HASH_SIMD
); break;
5823 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5824 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5825 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5826 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5832 char *strparser (const uint parser_status
)
5834 switch (parser_status
)
5836 case PARSER_OK
: return ((char *) PA_000
); break;
5837 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5838 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5839 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5840 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5841 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5842 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5843 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5844 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5845 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5846 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5847 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5848 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5849 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5850 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5851 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5852 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5855 return ((char *) PA_255
);
5858 char *strhashtype (const uint hash_mode
)
5862 case 0: return ((char *) HT_00000
); break;
5863 case 10: return ((char *) HT_00010
); break;
5864 case 11: return ((char *) HT_00011
); break;
5865 case 12: return ((char *) HT_00012
); break;
5866 case 20: return ((char *) HT_00020
); break;
5867 case 21: return ((char *) HT_00021
); break;
5868 case 22: return ((char *) HT_00022
); break;
5869 case 23: return ((char *) HT_00023
); break;
5870 case 30: return ((char *) HT_00030
); break;
5871 case 40: return ((char *) HT_00040
); break;
5872 case 50: return ((char *) HT_00050
); break;
5873 case 60: return ((char *) HT_00060
); break;
5874 case 100: return ((char *) HT_00100
); break;
5875 case 101: return ((char *) HT_00101
); break;
5876 case 110: return ((char *) HT_00110
); break;
5877 case 111: return ((char *) HT_00111
); break;
5878 case 112: return ((char *) HT_00112
); break;
5879 case 120: return ((char *) HT_00120
); break;
5880 case 121: return ((char *) HT_00121
); break;
5881 case 122: return ((char *) HT_00122
); break;
5882 case 124: return ((char *) HT_00124
); break;
5883 case 125: return ((char *) HT_00125
); break;
5884 case 130: return ((char *) HT_00130
); break;
5885 case 131: return ((char *) HT_00131
); break;
5886 case 132: return ((char *) HT_00132
); break;
5887 case 133: return ((char *) HT_00133
); break;
5888 case 140: return ((char *) HT_00140
); break;
5889 case 141: return ((char *) HT_00141
); break;
5890 case 150: return ((char *) HT_00150
); break;
5891 case 160: return ((char *) HT_00160
); break;
5892 case 190: return ((char *) HT_00190
); break;
5893 case 200: return ((char *) HT_00200
); break;
5894 case 300: return ((char *) HT_00300
); break;
5895 case 400: return ((char *) HT_00400
); break;
5896 case 500: return ((char *) HT_00500
); break;
5897 case 501: return ((char *) HT_00501
); break;
5898 case 900: return ((char *) HT_00900
); break;
5899 case 910: return ((char *) HT_00910
); break;
5900 case 1000: return ((char *) HT_01000
); break;
5901 case 1100: return ((char *) HT_01100
); break;
5902 case 1400: return ((char *) HT_01400
); break;
5903 case 1410: return ((char *) HT_01410
); break;
5904 case 1420: return ((char *) HT_01420
); break;
5905 case 1421: return ((char *) HT_01421
); break;
5906 case 1430: return ((char *) HT_01430
); break;
5907 case 1440: return ((char *) HT_01440
); break;
5908 case 1441: return ((char *) HT_01441
); break;
5909 case 1450: return ((char *) HT_01450
); break;
5910 case 1460: return ((char *) HT_01460
); break;
5911 case 1500: return ((char *) HT_01500
); break;
5912 case 1600: return ((char *) HT_01600
); break;
5913 case 1700: return ((char *) HT_01700
); break;
5914 case 1710: return ((char *) HT_01710
); break;
5915 case 1711: return ((char *) HT_01711
); break;
5916 case 1720: return ((char *) HT_01720
); break;
5917 case 1722: return ((char *) HT_01722
); break;
5918 case 1730: return ((char *) HT_01730
); break;
5919 case 1731: return ((char *) HT_01731
); break;
5920 case 1740: return ((char *) HT_01740
); break;
5921 case 1750: return ((char *) HT_01750
); break;
5922 case 1760: return ((char *) HT_01760
); break;
5923 case 1800: return ((char *) HT_01800
); break;
5924 case 2100: return ((char *) HT_02100
); break;
5925 case 2400: return ((char *) HT_02400
); break;
5926 case 2410: return ((char *) HT_02410
); break;
5927 case 2500: return ((char *) HT_02500
); break;
5928 case 2600: return ((char *) HT_02600
); break;
5929 case 2611: return ((char *) HT_02611
); break;
5930 case 2612: return ((char *) HT_02612
); break;
5931 case 2711: return ((char *) HT_02711
); break;
5932 case 2811: return ((char *) HT_02811
); break;
5933 case 3000: return ((char *) HT_03000
); break;
5934 case 3100: return ((char *) HT_03100
); break;
5935 case 3200: return ((char *) HT_03200
); break;
5936 case 3710: return ((char *) HT_03710
); break;
5937 case 3711: return ((char *) HT_03711
); break;
5938 case 3800: return ((char *) HT_03800
); break;
5939 case 4300: return ((char *) HT_04300
); break;
5940 case 4400: return ((char *) HT_04400
); break;
5941 case 4500: return ((char *) HT_04500
); break;
5942 case 4700: return ((char *) HT_04700
); break;
5943 case 4800: return ((char *) HT_04800
); break;
5944 case 4900: return ((char *) HT_04900
); break;
5945 case 5000: return ((char *) HT_05000
); break;
5946 case 5100: return ((char *) HT_05100
); break;
5947 case 5200: return ((char *) HT_05200
); break;
5948 case 5300: return ((char *) HT_05300
); break;
5949 case 5400: return ((char *) HT_05400
); break;
5950 case 5500: return ((char *) HT_05500
); break;
5951 case 5600: return ((char *) HT_05600
); break;
5952 case 5700: return ((char *) HT_05700
); break;
5953 case 5800: return ((char *) HT_05800
); break;
5954 case 6000: return ((char *) HT_06000
); break;
5955 case 6100: return ((char *) HT_06100
); break;
5956 case 6211: return ((char *) HT_06211
); break;
5957 case 6212: return ((char *) HT_06212
); break;
5958 case 6213: return ((char *) HT_06213
); break;
5959 case 6221: return ((char *) HT_06221
); break;
5960 case 6222: return ((char *) HT_06222
); break;
5961 case 6223: return ((char *) HT_06223
); break;
5962 case 6231: return ((char *) HT_06231
); break;
5963 case 6232: return ((char *) HT_06232
); break;
5964 case 6233: return ((char *) HT_06233
); break;
5965 case 6241: return ((char *) HT_06241
); break;
5966 case 6242: return ((char *) HT_06242
); break;
5967 case 6243: return ((char *) HT_06243
); break;
5968 case 6300: return ((char *) HT_06300
); break;
5969 case 6400: return ((char *) HT_06400
); break;
5970 case 6500: return ((char *) HT_06500
); break;
5971 case 6600: return ((char *) HT_06600
); break;
5972 case 6700: return ((char *) HT_06700
); break;
5973 case 6800: return ((char *) HT_06800
); break;
5974 case 6900: return ((char *) HT_06900
); break;
5975 case 7100: return ((char *) HT_07100
); break;
5976 case 7200: return ((char *) HT_07200
); break;
5977 case 7300: return ((char *) HT_07300
); break;
5978 case 7400: return ((char *) HT_07400
); break;
5979 case 7500: return ((char *) HT_07500
); break;
5980 case 7600: return ((char *) HT_07600
); break;
5981 case 7700: return ((char *) HT_07700
); break;
5982 case 7800: return ((char *) HT_07800
); break;
5983 case 7900: return ((char *) HT_07900
); break;
5984 case 8000: return ((char *) HT_08000
); break;
5985 case 8100: return ((char *) HT_08100
); break;
5986 case 8200: return ((char *) HT_08200
); break;
5987 case 8300: return ((char *) HT_08300
); break;
5988 case 8400: return ((char *) HT_08400
); break;
5989 case 8500: return ((char *) HT_08500
); break;
5990 case 8600: return ((char *) HT_08600
); break;
5991 case 8700: return ((char *) HT_08700
); break;
5992 case 8800: return ((char *) HT_08800
); break;
5993 case 8900: return ((char *) HT_08900
); break;
5994 case 9000: return ((char *) HT_09000
); break;
5995 case 9100: return ((char *) HT_09100
); break;
5996 case 9200: return ((char *) HT_09200
); break;
5997 case 9300: return ((char *) HT_09300
); break;
5998 case 9400: return ((char *) HT_09400
); break;
5999 case 9500: return ((char *) HT_09500
); break;
6000 case 9600: return ((char *) HT_09600
); break;
6001 case 9700: return ((char *) HT_09700
); break;
6002 case 9710: return ((char *) HT_09710
); break;
6003 case 9720: return ((char *) HT_09720
); break;
6004 case 9800: return ((char *) HT_09800
); break;
6005 case 9810: return ((char *) HT_09810
); break;
6006 case 9820: return ((char *) HT_09820
); break;
6007 case 9900: return ((char *) HT_09900
); break;
6008 case 10000: return ((char *) HT_10000
); break;
6009 case 10100: return ((char *) HT_10100
); break;
6010 case 10200: return ((char *) HT_10200
); break;
6011 case 10300: return ((char *) HT_10300
); break;
6012 case 10400: return ((char *) HT_10400
); break;
6013 case 10410: return ((char *) HT_10410
); break;
6014 case 10420: return ((char *) HT_10420
); break;
6015 case 10500: return ((char *) HT_10500
); break;
6016 case 10600: return ((char *) HT_10600
); break;
6017 case 10700: return ((char *) HT_10700
); break;
6018 case 10800: return ((char *) HT_10800
); break;
6019 case 10900: return ((char *) HT_10900
); break;
6020 case 11000: return ((char *) HT_11000
); break;
6021 case 11100: return ((char *) HT_11100
); break;
6022 case 11200: return ((char *) HT_11200
); break;
6023 case 11300: return ((char *) HT_11300
); break;
6024 case 11400: return ((char *) HT_11400
); break;
6025 case 11500: return ((char *) HT_11500
); break;
6026 case 11600: return ((char *) HT_11600
); break;
6027 case 11700: return ((char *) HT_11700
); break;
6028 case 11800: return ((char *) HT_11800
); break;
6029 case 11900: return ((char *) HT_11900
); break;
6030 case 12000: return ((char *) HT_12000
); break;
6031 case 12100: return ((char *) HT_12100
); break;
6032 case 12200: return ((char *) HT_12200
); break;
6033 case 12300: return ((char *) HT_12300
); break;
6034 case 12400: return ((char *) HT_12400
); break;
6035 case 12500: return ((char *) HT_12500
); break;
6036 case 12600: return ((char *) HT_12600
); break;
6037 case 12700: return ((char *) HT_12700
); break;
6038 case 12800: return ((char *) HT_12800
); break;
6039 case 12900: return ((char *) HT_12900
); break;
6040 case 13000: return ((char *) HT_13000
); break;
6041 case 13100: return ((char *) HT_13100
); break;
6042 case 13200: return ((char *) HT_13200
); break;
6043 case 13300: return ((char *) HT_13300
); break;
6044 case 13400: return ((char *) HT_13400
); break;
6045 case 13500: return ((char *) HT_13500
); break;
6046 case 13600: return ((char *) HT_13600
); break;
6047 case 13711: return ((char *) HT_13711
); break;
6048 case 13712: return ((char *) HT_13712
); break;
6049 case 13713: return ((char *) HT_13713
); break;
6050 case 13721: return ((char *) HT_13721
); break;
6051 case 13722: return ((char *) HT_13722
); break;
6052 case 13723: return ((char *) HT_13723
); break;
6053 case 13731: return ((char *) HT_13731
); break;
6054 case 13732: return ((char *) HT_13732
); break;
6055 case 13733: return ((char *) HT_13733
); break;
6056 case 13741: return ((char *) HT_13741
); break;
6057 case 13742: return ((char *) HT_13742
); break;
6058 case 13743: return ((char *) HT_13743
); break;
6059 case 13751: return ((char *) HT_13751
); break;
6060 case 13752: return ((char *) HT_13752
); break;
6061 case 13753: return ((char *) HT_13753
); break;
6062 case 13761: return ((char *) HT_13761
); break;
6063 case 13762: return ((char *) HT_13762
); break;
6064 case 13763: return ((char *) HT_13763
); break;
6065 case 13800: return ((char *) HT_13800
); break;
6068 return ((char *) "Unknown");
6071 char *strstatus (const uint devices_status
)
6073 switch (devices_status
)
6075 case STATUS_INIT
: return ((char *) ST_0000
); break;
6076 case STATUS_STARTING
: return ((char *) ST_0001
); break;
6077 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
6078 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
6079 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
6080 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
6081 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
6082 case STATUS_QUIT
: return ((char *) ST_0007
); break;
6083 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
6084 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
6085 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
6088 return ((char *) "Unknown");
6091 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
6093 uint hash_type
= data
.hash_type
;
6094 uint hash_mode
= data
.hash_mode
;
6095 uint salt_type
= data
.salt_type
;
6096 uint opts_type
= data
.opts_type
;
6097 uint opti_type
= data
.opti_type
;
6098 uint dgst_size
= data
.dgst_size
;
6100 char *hashfile
= data
.hashfile
;
6104 uint digest_buf
[64] = { 0 };
6106 u64
*digest_buf64
= (u64
*) digest_buf
;
6108 char *digests_buf_ptr
= (char *) data
.digests_buf
;
6110 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
6112 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6118 case HASH_TYPE_DESCRYPT
:
6119 FP (digest_buf
[1], digest_buf
[0], tt
);
6122 case HASH_TYPE_DESRACF
:
6123 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6124 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6126 FP (digest_buf
[1], digest_buf
[0], tt
);
6130 FP (digest_buf
[1], digest_buf
[0], tt
);
6133 case HASH_TYPE_NETNTLM
:
6134 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6135 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6136 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
6137 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
6139 FP (digest_buf
[1], digest_buf
[0], tt
);
6140 FP (digest_buf
[3], digest_buf
[2], tt
);
6143 case HASH_TYPE_BSDICRYPT
:
6144 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
6145 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
6147 FP (digest_buf
[1], digest_buf
[0], tt
);
6152 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
6157 digest_buf
[0] += MD4M_A
;
6158 digest_buf
[1] += MD4M_B
;
6159 digest_buf
[2] += MD4M_C
;
6160 digest_buf
[3] += MD4M_D
;
6164 digest_buf
[0] += MD5M_A
;
6165 digest_buf
[1] += MD5M_B
;
6166 digest_buf
[2] += MD5M_C
;
6167 digest_buf
[3] += MD5M_D
;
6170 case HASH_TYPE_SHA1
:
6171 digest_buf
[0] += SHA1M_A
;
6172 digest_buf
[1] += SHA1M_B
;
6173 digest_buf
[2] += SHA1M_C
;
6174 digest_buf
[3] += SHA1M_D
;
6175 digest_buf
[4] += SHA1M_E
;
6178 case HASH_TYPE_SHA256
:
6179 digest_buf
[0] += SHA256M_A
;
6180 digest_buf
[1] += SHA256M_B
;
6181 digest_buf
[2] += SHA256M_C
;
6182 digest_buf
[3] += SHA256M_D
;
6183 digest_buf
[4] += SHA256M_E
;
6184 digest_buf
[5] += SHA256M_F
;
6185 digest_buf
[6] += SHA256M_G
;
6186 digest_buf
[7] += SHA256M_H
;
6189 case HASH_TYPE_SHA384
:
6190 digest_buf64
[0] += SHA384M_A
;
6191 digest_buf64
[1] += SHA384M_B
;
6192 digest_buf64
[2] += SHA384M_C
;
6193 digest_buf64
[3] += SHA384M_D
;
6194 digest_buf64
[4] += SHA384M_E
;
6195 digest_buf64
[5] += SHA384M_F
;
6196 digest_buf64
[6] += 0;
6197 digest_buf64
[7] += 0;
6200 case HASH_TYPE_SHA512
:
6201 digest_buf64
[0] += SHA512M_A
;
6202 digest_buf64
[1] += SHA512M_B
;
6203 digest_buf64
[2] += SHA512M_C
;
6204 digest_buf64
[3] += SHA512M_D
;
6205 digest_buf64
[4] += SHA512M_E
;
6206 digest_buf64
[5] += SHA512M_F
;
6207 digest_buf64
[6] += SHA512M_G
;
6208 digest_buf64
[7] += SHA512M_H
;
6213 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6215 if (dgst_size
== DGST_SIZE_4_2
)
6217 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6219 else if (dgst_size
== DGST_SIZE_4_4
)
6221 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6223 else if (dgst_size
== DGST_SIZE_4_5
)
6225 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6227 else if (dgst_size
== DGST_SIZE_4_6
)
6229 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6231 else if (dgst_size
== DGST_SIZE_4_8
)
6233 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6235 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6237 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6239 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6241 else if (hash_type
== HASH_TYPE_SHA384
)
6243 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6245 else if (hash_type
== HASH_TYPE_SHA512
)
6247 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6249 else if (hash_type
== HASH_TYPE_GOST
)
6251 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6254 else if (dgst_size
== DGST_SIZE_4_64
)
6256 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6258 else if (dgst_size
== DGST_SIZE_8_25
)
6260 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6264 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6265 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6266 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6272 memset (&salt
, 0, sizeof (salt_t
));
6274 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6276 char *ptr
= (char *) salt
.salt_buf
;
6278 uint len
= salt
.salt_len
;
6280 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6286 case HASH_TYPE_NETNTLM
:
6288 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6289 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6291 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6297 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6299 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6307 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6309 uint max
= salt
.salt_len
/ 4;
6313 for (uint i
= 0; i
< max
; i
++)
6315 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6319 if (opts_type
& OPTS_TYPE_ST_HEX
)
6321 char tmp
[64] = { 0 };
6323 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6325 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6330 memcpy (ptr
, tmp
, len
);
6333 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6335 memset (ptr
+ len
, 0, memset_size
);
6337 salt
.salt_len
= len
;
6341 // some modes require special encoding
6344 uint out_buf_plain
[256] = { 0 };
6345 uint out_buf_salt
[256] = { 0 };
6347 char tmp_buf
[1024] = { 0 };
6349 char *ptr_plain
= (char *) out_buf_plain
;
6350 char *ptr_salt
= (char *) out_buf_salt
;
6352 if (hash_mode
== 22)
6354 char username
[30] = { 0 };
6356 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6358 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6360 u16
*ptr
= (u16
*) digest_buf
;
6362 tmp_buf
[ 0] = sig
[0];
6363 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6364 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6365 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6366 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6367 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6368 tmp_buf
[ 6] = sig
[1];
6369 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6370 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6371 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6372 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6373 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6374 tmp_buf
[12] = sig
[2];
6375 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6376 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6377 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6378 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6379 tmp_buf
[17] = sig
[3];
6380 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6381 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6382 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6383 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6384 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6385 tmp_buf
[23] = sig
[4];
6386 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6387 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6388 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6389 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6390 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6391 tmp_buf
[29] = sig
[5];
6393 snprintf (out_buf
, len
-1, "%s:%s",
6397 else if (hash_mode
== 23)
6399 // do not show the skyper part in output
6401 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6403 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6405 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6412 else if (hash_mode
== 101)
6414 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6416 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6417 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6418 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6419 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6420 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6422 memcpy (tmp_buf
, digest_buf
, 20);
6424 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6426 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6428 else if (hash_mode
== 111)
6430 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6432 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6433 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6434 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6435 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6436 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6438 memcpy (tmp_buf
, digest_buf
, 20);
6439 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6441 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6443 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6445 else if ((hash_mode
== 122) || (hash_mode
== 125))
6447 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6448 (char *) salt
.salt_buf
,
6455 else if (hash_mode
== 124)
6457 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6458 (char *) salt
.salt_buf
,
6465 else if (hash_mode
== 131)
6467 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6468 (char *) salt
.salt_buf
,
6476 else if (hash_mode
== 132)
6478 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6479 (char *) salt
.salt_buf
,
6486 else if (hash_mode
== 133)
6488 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6490 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6491 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6492 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6493 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6494 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6496 memcpy (tmp_buf
, digest_buf
, 20);
6498 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6500 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6502 else if (hash_mode
== 141)
6504 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6506 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6508 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6510 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6512 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6513 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6514 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6515 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6516 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6518 memcpy (tmp_buf
, digest_buf
, 20);
6520 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6524 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6526 else if (hash_mode
== 400)
6528 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6530 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6531 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6532 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6533 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6535 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6537 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6539 else if (hash_mode
== 500)
6541 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6543 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6544 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6545 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6546 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6548 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6550 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6552 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6556 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6559 else if (hash_mode
== 501)
6561 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6563 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6564 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6566 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6568 else if (hash_mode
== 1421)
6570 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6572 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6588 else if (hash_mode
== 1441)
6590 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6592 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6594 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6596 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6598 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6599 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6600 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6601 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6602 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6603 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6604 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6605 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6607 memcpy (tmp_buf
, digest_buf
, 32);
6609 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6613 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6615 else if (hash_mode
== 1500)
6617 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6618 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6619 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6620 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6621 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6623 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6625 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6627 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6628 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6630 memcpy (tmp_buf
, digest_buf
, 8);
6632 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6634 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6638 else if (hash_mode
== 1600)
6640 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6642 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6643 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6644 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6645 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6647 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6649 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6651 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6655 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6658 else if (hash_mode
== 1711)
6660 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6662 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6663 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6664 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6665 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6666 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6667 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6668 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6669 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6671 memcpy (tmp_buf
, digest_buf
, 64);
6672 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6674 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6676 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6678 else if (hash_mode
== 1722)
6680 uint
*ptr
= digest_buf
;
6682 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6683 (unsigned char *) salt
.salt_buf
,
6693 else if (hash_mode
== 1731)
6695 uint
*ptr
= digest_buf
;
6697 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6698 (unsigned char *) salt
.salt_buf
,
6708 else if (hash_mode
== 1800)
6712 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6713 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6714 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6715 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6716 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6717 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6718 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6719 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6721 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6723 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6725 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6729 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6732 else if (hash_mode
== 2100)
6736 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6738 salt
.salt_iter
+ 1);
6740 uint signature_len
= strlen (out_buf
);
6742 pos
+= signature_len
;
6743 len
-= signature_len
;
6745 char *salt_ptr
= (char *) salt
.salt_buf
;
6747 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6749 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6750 byte_swap_32 (digest_buf
[0]),
6751 byte_swap_32 (digest_buf
[1]),
6752 byte_swap_32 (digest_buf
[2]),
6753 byte_swap_32 (digest_buf
[3]));
6755 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6757 memcpy (tmp_buf
, digest_buf
, 16);
6759 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6761 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6762 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6763 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6764 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6766 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6767 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6768 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6769 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6771 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6772 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6773 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6774 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6776 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6777 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6778 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6779 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6781 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6782 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6783 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6784 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6788 else if (hash_mode
== 2500)
6790 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6792 wpa_t
*wpa
= &wpas
[salt_pos
];
6794 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6795 (char *) salt
.salt_buf
,
6809 else if (hash_mode
== 4400)
6811 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6812 byte_swap_32 (digest_buf
[0]),
6813 byte_swap_32 (digest_buf
[1]),
6814 byte_swap_32 (digest_buf
[2]),
6815 byte_swap_32 (digest_buf
[3]));
6817 else if (hash_mode
== 4700)
6819 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6820 byte_swap_32 (digest_buf
[0]),
6821 byte_swap_32 (digest_buf
[1]),
6822 byte_swap_32 (digest_buf
[2]),
6823 byte_swap_32 (digest_buf
[3]),
6824 byte_swap_32 (digest_buf
[4]));
6826 else if (hash_mode
== 4800)
6828 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6830 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6835 byte_swap_32 (salt
.salt_buf
[0]),
6836 byte_swap_32 (salt
.salt_buf
[1]),
6837 byte_swap_32 (salt
.salt_buf
[2]),
6838 byte_swap_32 (salt
.salt_buf
[3]),
6841 else if (hash_mode
== 4900)
6843 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6844 byte_swap_32 (digest_buf
[0]),
6845 byte_swap_32 (digest_buf
[1]),
6846 byte_swap_32 (digest_buf
[2]),
6847 byte_swap_32 (digest_buf
[3]),
6848 byte_swap_32 (digest_buf
[4]));
6850 else if (hash_mode
== 5100)
6852 snprintf (out_buf
, len
-1, "%08x%08x",
6856 else if (hash_mode
== 5200)
6858 snprintf (out_buf
, len
-1, "%s", hashfile
);
6860 else if (hash_mode
== 5300)
6862 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6864 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6866 int buf_len
= len
-1;
6870 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6872 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6874 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6876 snprintf (out_buf
, buf_len
, ":");
6882 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6890 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6892 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6894 if ((i
== 0) || (i
== 5))
6896 snprintf (out_buf
, buf_len
, ":");
6902 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6910 for (uint i
= 0; i
< 4; i
++)
6914 snprintf (out_buf
, buf_len
, ":");
6920 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6926 else if (hash_mode
== 5400)
6928 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6930 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6932 int buf_len
= len
-1;
6936 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6938 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6940 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6942 snprintf (out_buf
, buf_len
, ":");
6948 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6956 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6958 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6960 if ((i
== 0) || (i
== 5))
6962 snprintf (out_buf
, buf_len
, ":");
6968 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6976 for (uint i
= 0; i
< 5; i
++)
6980 snprintf (out_buf
, buf_len
, ":");
6986 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6992 else if (hash_mode
== 5500)
6994 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6996 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6998 char user_buf
[64] = { 0 };
6999 char domain_buf
[64] = { 0 };
7000 char srvchall_buf
[1024] = { 0 };
7001 char clichall_buf
[1024] = { 0 };
7003 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7005 char *ptr
= (char *) netntlm
->userdomain_buf
;
7007 user_buf
[i
] = ptr
[j
];
7010 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7012 char *ptr
= (char *) netntlm
->userdomain_buf
;
7014 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7017 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7019 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7021 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7024 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7026 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7028 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7031 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
7039 byte_swap_32 (salt
.salt_buf_pc
[0]),
7040 byte_swap_32 (salt
.salt_buf_pc
[1]),
7043 else if (hash_mode
== 5600)
7045 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7047 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7049 char user_buf
[64] = { 0 };
7050 char domain_buf
[64] = { 0 };
7051 char srvchall_buf
[1024] = { 0 };
7052 char clichall_buf
[1024] = { 0 };
7054 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7056 char *ptr
= (char *) netntlm
->userdomain_buf
;
7058 user_buf
[i
] = ptr
[j
];
7061 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7063 char *ptr
= (char *) netntlm
->userdomain_buf
;
7065 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7068 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7070 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7072 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7075 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7077 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7079 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7082 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
7092 else if (hash_mode
== 5700)
7094 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7096 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7097 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7098 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7099 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7100 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7101 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7102 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7103 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7105 memcpy (tmp_buf
, digest_buf
, 32);
7107 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
7111 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
7113 else if (hash_mode
== 5800)
7115 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7116 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7117 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7118 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7119 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7121 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
7128 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
7130 snprintf (out_buf
, len
-1, "%s", hashfile
);
7132 else if (hash_mode
== 6300)
7134 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7136 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7137 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7138 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7139 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7141 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7143 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7145 else if (hash_mode
== 6400)
7147 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7149 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7151 else if (hash_mode
== 6500)
7153 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7155 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7157 else if (hash_mode
== 6600)
7159 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
7161 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
7163 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7164 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7166 uint buf_len
= len
- 1;
7168 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
7171 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
7173 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
7178 else if (hash_mode
== 6700)
7180 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7182 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7184 else if (hash_mode
== 6800)
7186 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
7188 else if (hash_mode
== 7100)
7190 uint
*ptr
= digest_buf
;
7192 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7194 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7196 uint esalt
[8] = { 0 };
7198 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7199 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7200 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7201 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7202 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7203 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7204 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7205 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7207 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",
7208 SIGNATURE_SHA512OSX
,
7210 esalt
[ 0], esalt
[ 1],
7211 esalt
[ 2], esalt
[ 3],
7212 esalt
[ 4], esalt
[ 5],
7213 esalt
[ 6], esalt
[ 7],
7221 ptr
[15], ptr
[14]);
7223 else if (hash_mode
== 7200)
7225 uint
*ptr
= digest_buf
;
7227 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7229 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7233 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7235 len_used
= strlen (out_buf
);
7237 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7239 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7241 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7244 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",
7252 ptr
[15], ptr
[14]);
7254 else if (hash_mode
== 7300)
7256 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7258 rakp_t
*rakp
= &rakps
[salt_pos
];
7260 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7262 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7265 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7272 else if (hash_mode
== 7400)
7274 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7276 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7277 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7278 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7279 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7280 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7281 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7282 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7283 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7285 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7287 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7289 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7293 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7296 else if (hash_mode
== 7500)
7298 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7300 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7302 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7303 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7305 char data
[128] = { 0 };
7307 char *ptr_data
= data
;
7309 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7311 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7314 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7316 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7321 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7323 (char *) krb5pa
->user
,
7324 (char *) krb5pa
->realm
,
7325 (char *) krb5pa
->salt
,
7328 else if (hash_mode
== 7700)
7330 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7331 (char *) salt
.salt_buf
,
7335 else if (hash_mode
== 7800)
7337 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7338 (char *) salt
.salt_buf
,
7345 else if (hash_mode
== 7900)
7347 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7351 char *tmp
= (char *) salt
.salt_buf_pc
;
7353 ptr_plain
[42] = tmp
[0];
7359 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7361 else if (hash_mode
== 8000)
7363 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7364 (unsigned char *) salt
.salt_buf
,
7374 else if (hash_mode
== 8100)
7376 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7377 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7379 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7380 (unsigned char *) salt
.salt_buf
,
7387 else if (hash_mode
== 8200)
7389 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7391 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7393 char data_buf
[4096] = { 0 };
7395 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7397 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7400 data_buf
[cloudkey
->data_len
* 2] = 0;
7402 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7403 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7404 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7405 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7406 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7407 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7408 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7409 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7411 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7412 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7413 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7414 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7416 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7432 else if (hash_mode
== 8300)
7434 char digest_buf_c
[34] = { 0 };
7436 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7437 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7438 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7439 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7440 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7442 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7444 digest_buf_c
[32] = 0;
7448 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7450 char domain_buf_c
[33] = { 0 };
7452 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7454 for (uint i
= 0; i
< salt_pc_len
; i
++)
7456 const char next
= domain_buf_c
[i
];
7458 domain_buf_c
[i
] = '.';
7463 domain_buf_c
[salt_pc_len
] = 0;
7467 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7469 else if (hash_mode
== 8500)
7471 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7473 else if (hash_mode
== 2612)
7475 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7477 (char *) salt
.salt_buf
,
7483 else if (hash_mode
== 3711)
7485 char *salt_ptr
= (char *) salt
.salt_buf
;
7487 salt_ptr
[salt
.salt_len
- 1] = 0;
7489 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7490 SIGNATURE_MEDIAWIKI_B
,
7497 else if (hash_mode
== 8800)
7499 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7501 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7503 char tmp
[3073] = { 0 };
7505 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7507 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7512 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7513 SIGNATURE_ANDROIDFDE
,
7514 byte_swap_32 (salt
.salt_buf
[0]),
7515 byte_swap_32 (salt
.salt_buf
[1]),
7516 byte_swap_32 (salt
.salt_buf
[2]),
7517 byte_swap_32 (salt
.salt_buf
[3]),
7518 byte_swap_32 (digest_buf
[0]),
7519 byte_swap_32 (digest_buf
[1]),
7520 byte_swap_32 (digest_buf
[2]),
7521 byte_swap_32 (digest_buf
[3]),
7524 else if (hash_mode
== 8900)
7526 uint N
= salt
.scrypt_N
;
7527 uint r
= salt
.scrypt_r
;
7528 uint p
= salt
.scrypt_p
;
7530 char base64_salt
[32] = { 0 };
7532 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7534 memset (tmp_buf
, 0, 46);
7536 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7537 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7538 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7539 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7540 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7541 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7542 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7543 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7544 digest_buf
[8] = 0; // needed for base64_encode ()
7546 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7548 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7556 else if (hash_mode
== 9000)
7558 snprintf (out_buf
, len
-1, "%s", hashfile
);
7560 else if (hash_mode
== 9200)
7564 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7566 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7568 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7572 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7573 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7574 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7575 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7576 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7577 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7578 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7579 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7580 digest_buf
[8] = 0; // needed for base64_encode ()
7582 char tmp_buf
[64] = { 0 };
7584 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7585 tmp_buf
[43] = 0; // cut it here
7589 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7591 else if (hash_mode
== 9300)
7593 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7594 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7595 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7596 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7597 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7598 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7599 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7600 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7601 digest_buf
[8] = 0; // needed for base64_encode ()
7603 char tmp_buf
[64] = { 0 };
7605 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7606 tmp_buf
[43] = 0; // cut it here
7608 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7610 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7612 else if (hash_mode
== 9400)
7614 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7616 office2007_t
*office2007
= &office2007s
[salt_pos
];
7618 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7619 SIGNATURE_OFFICE2007
,
7622 office2007
->keySize
,
7628 office2007
->encryptedVerifier
[0],
7629 office2007
->encryptedVerifier
[1],
7630 office2007
->encryptedVerifier
[2],
7631 office2007
->encryptedVerifier
[3],
7632 office2007
->encryptedVerifierHash
[0],
7633 office2007
->encryptedVerifierHash
[1],
7634 office2007
->encryptedVerifierHash
[2],
7635 office2007
->encryptedVerifierHash
[3],
7636 office2007
->encryptedVerifierHash
[4]);
7638 else if (hash_mode
== 9500)
7640 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7642 office2010_t
*office2010
= &office2010s
[salt_pos
];
7644 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,
7650 office2010
->encryptedVerifier
[0],
7651 office2010
->encryptedVerifier
[1],
7652 office2010
->encryptedVerifier
[2],
7653 office2010
->encryptedVerifier
[3],
7654 office2010
->encryptedVerifierHash
[0],
7655 office2010
->encryptedVerifierHash
[1],
7656 office2010
->encryptedVerifierHash
[2],
7657 office2010
->encryptedVerifierHash
[3],
7658 office2010
->encryptedVerifierHash
[4],
7659 office2010
->encryptedVerifierHash
[5],
7660 office2010
->encryptedVerifierHash
[6],
7661 office2010
->encryptedVerifierHash
[7]);
7663 else if (hash_mode
== 9600)
7665 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7667 office2013_t
*office2013
= &office2013s
[salt_pos
];
7669 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,
7675 office2013
->encryptedVerifier
[0],
7676 office2013
->encryptedVerifier
[1],
7677 office2013
->encryptedVerifier
[2],
7678 office2013
->encryptedVerifier
[3],
7679 office2013
->encryptedVerifierHash
[0],
7680 office2013
->encryptedVerifierHash
[1],
7681 office2013
->encryptedVerifierHash
[2],
7682 office2013
->encryptedVerifierHash
[3],
7683 office2013
->encryptedVerifierHash
[4],
7684 office2013
->encryptedVerifierHash
[5],
7685 office2013
->encryptedVerifierHash
[6],
7686 office2013
->encryptedVerifierHash
[7]);
7688 else if (hash_mode
== 9700)
7690 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7692 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7694 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7695 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7696 byte_swap_32 (salt
.salt_buf
[0]),
7697 byte_swap_32 (salt
.salt_buf
[1]),
7698 byte_swap_32 (salt
.salt_buf
[2]),
7699 byte_swap_32 (salt
.salt_buf
[3]),
7700 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7701 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7702 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7703 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7704 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7705 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7706 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7707 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7709 else if (hash_mode
== 9710)
7711 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7713 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7715 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7716 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7717 byte_swap_32 (salt
.salt_buf
[0]),
7718 byte_swap_32 (salt
.salt_buf
[1]),
7719 byte_swap_32 (salt
.salt_buf
[2]),
7720 byte_swap_32 (salt
.salt_buf
[3]),
7721 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7722 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7723 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7724 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7725 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7726 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7727 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7728 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7730 else if (hash_mode
== 9720)
7732 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7734 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7736 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7738 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7739 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7740 byte_swap_32 (salt
.salt_buf
[0]),
7741 byte_swap_32 (salt
.salt_buf
[1]),
7742 byte_swap_32 (salt
.salt_buf
[2]),
7743 byte_swap_32 (salt
.salt_buf
[3]),
7744 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7745 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7746 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7747 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7748 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7749 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7750 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7751 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7758 else if (hash_mode
== 9800)
7760 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7762 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7764 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7765 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7770 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7771 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7772 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7773 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7774 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7775 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7776 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7777 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7778 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7780 else if (hash_mode
== 9810)
7782 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7784 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7786 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7787 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7792 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7793 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7794 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7795 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7796 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7797 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7798 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7799 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7800 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7802 else if (hash_mode
== 9820)
7804 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7806 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7808 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7810 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
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]),
7831 else if (hash_mode
== 10000)
7835 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7837 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7839 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7843 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7844 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7845 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7846 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7847 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7848 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7849 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7850 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7851 digest_buf
[8] = 0; // needed for base64_encode ()
7853 char tmp_buf
[64] = { 0 };
7855 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7859 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7861 else if (hash_mode
== 10100)
7863 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7868 byte_swap_32 (salt
.salt_buf
[0]),
7869 byte_swap_32 (salt
.salt_buf
[1]),
7870 byte_swap_32 (salt
.salt_buf
[2]),
7871 byte_swap_32 (salt
.salt_buf
[3]));
7873 else if (hash_mode
== 10200)
7875 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7877 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7881 char challenge
[100] = { 0 };
7883 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7887 char tmp_buf
[100] = { 0 };
7889 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7890 (char *) cram_md5
->user
,
7896 char response
[100] = { 0 };
7898 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7900 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7902 else if (hash_mode
== 10300)
7904 char tmp_buf
[100] = { 0 };
7906 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7907 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7909 uint tmp_len
= 20 + salt
.salt_len
;
7913 char base64_encoded
[100] = { 0 };
7915 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7917 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7919 else if (hash_mode
== 10400)
7921 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7923 pdf_t
*pdf
= &pdfs
[salt_pos
];
7925 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",
7933 byte_swap_32 (pdf
->id_buf
[0]),
7934 byte_swap_32 (pdf
->id_buf
[1]),
7935 byte_swap_32 (pdf
->id_buf
[2]),
7936 byte_swap_32 (pdf
->id_buf
[3]),
7938 byte_swap_32 (pdf
->u_buf
[0]),
7939 byte_swap_32 (pdf
->u_buf
[1]),
7940 byte_swap_32 (pdf
->u_buf
[2]),
7941 byte_swap_32 (pdf
->u_buf
[3]),
7942 byte_swap_32 (pdf
->u_buf
[4]),
7943 byte_swap_32 (pdf
->u_buf
[5]),
7944 byte_swap_32 (pdf
->u_buf
[6]),
7945 byte_swap_32 (pdf
->u_buf
[7]),
7947 byte_swap_32 (pdf
->o_buf
[0]),
7948 byte_swap_32 (pdf
->o_buf
[1]),
7949 byte_swap_32 (pdf
->o_buf
[2]),
7950 byte_swap_32 (pdf
->o_buf
[3]),
7951 byte_swap_32 (pdf
->o_buf
[4]),
7952 byte_swap_32 (pdf
->o_buf
[5]),
7953 byte_swap_32 (pdf
->o_buf
[6]),
7954 byte_swap_32 (pdf
->o_buf
[7])
7957 else if (hash_mode
== 10410)
7959 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7961 pdf_t
*pdf
= &pdfs
[salt_pos
];
7963 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",
7971 byte_swap_32 (pdf
->id_buf
[0]),
7972 byte_swap_32 (pdf
->id_buf
[1]),
7973 byte_swap_32 (pdf
->id_buf
[2]),
7974 byte_swap_32 (pdf
->id_buf
[3]),
7976 byte_swap_32 (pdf
->u_buf
[0]),
7977 byte_swap_32 (pdf
->u_buf
[1]),
7978 byte_swap_32 (pdf
->u_buf
[2]),
7979 byte_swap_32 (pdf
->u_buf
[3]),
7980 byte_swap_32 (pdf
->u_buf
[4]),
7981 byte_swap_32 (pdf
->u_buf
[5]),
7982 byte_swap_32 (pdf
->u_buf
[6]),
7983 byte_swap_32 (pdf
->u_buf
[7]),
7985 byte_swap_32 (pdf
->o_buf
[0]),
7986 byte_swap_32 (pdf
->o_buf
[1]),
7987 byte_swap_32 (pdf
->o_buf
[2]),
7988 byte_swap_32 (pdf
->o_buf
[3]),
7989 byte_swap_32 (pdf
->o_buf
[4]),
7990 byte_swap_32 (pdf
->o_buf
[5]),
7991 byte_swap_32 (pdf
->o_buf
[6]),
7992 byte_swap_32 (pdf
->o_buf
[7])
7995 else if (hash_mode
== 10420)
7997 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7999 pdf_t
*pdf
= &pdfs
[salt_pos
];
8001 u8
*rc4key
= (u8
*) pdf
->rc4key
;
8003 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",
8011 byte_swap_32 (pdf
->id_buf
[0]),
8012 byte_swap_32 (pdf
->id_buf
[1]),
8013 byte_swap_32 (pdf
->id_buf
[2]),
8014 byte_swap_32 (pdf
->id_buf
[3]),
8016 byte_swap_32 (pdf
->u_buf
[0]),
8017 byte_swap_32 (pdf
->u_buf
[1]),
8018 byte_swap_32 (pdf
->u_buf
[2]),
8019 byte_swap_32 (pdf
->u_buf
[3]),
8020 byte_swap_32 (pdf
->u_buf
[4]),
8021 byte_swap_32 (pdf
->u_buf
[5]),
8022 byte_swap_32 (pdf
->u_buf
[6]),
8023 byte_swap_32 (pdf
->u_buf
[7]),
8025 byte_swap_32 (pdf
->o_buf
[0]),
8026 byte_swap_32 (pdf
->o_buf
[1]),
8027 byte_swap_32 (pdf
->o_buf
[2]),
8028 byte_swap_32 (pdf
->o_buf
[3]),
8029 byte_swap_32 (pdf
->o_buf
[4]),
8030 byte_swap_32 (pdf
->o_buf
[5]),
8031 byte_swap_32 (pdf
->o_buf
[6]),
8032 byte_swap_32 (pdf
->o_buf
[7]),
8040 else if (hash_mode
== 10500)
8042 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8044 pdf_t
*pdf
= &pdfs
[salt_pos
];
8046 if (pdf
->id_len
== 32)
8048 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",
8056 byte_swap_32 (pdf
->id_buf
[0]),
8057 byte_swap_32 (pdf
->id_buf
[1]),
8058 byte_swap_32 (pdf
->id_buf
[2]),
8059 byte_swap_32 (pdf
->id_buf
[3]),
8060 byte_swap_32 (pdf
->id_buf
[4]),
8061 byte_swap_32 (pdf
->id_buf
[5]),
8062 byte_swap_32 (pdf
->id_buf
[6]),
8063 byte_swap_32 (pdf
->id_buf
[7]),
8065 byte_swap_32 (pdf
->u_buf
[0]),
8066 byte_swap_32 (pdf
->u_buf
[1]),
8067 byte_swap_32 (pdf
->u_buf
[2]),
8068 byte_swap_32 (pdf
->u_buf
[3]),
8069 byte_swap_32 (pdf
->u_buf
[4]),
8070 byte_swap_32 (pdf
->u_buf
[5]),
8071 byte_swap_32 (pdf
->u_buf
[6]),
8072 byte_swap_32 (pdf
->u_buf
[7]),
8074 byte_swap_32 (pdf
->o_buf
[0]),
8075 byte_swap_32 (pdf
->o_buf
[1]),
8076 byte_swap_32 (pdf
->o_buf
[2]),
8077 byte_swap_32 (pdf
->o_buf
[3]),
8078 byte_swap_32 (pdf
->o_buf
[4]),
8079 byte_swap_32 (pdf
->o_buf
[5]),
8080 byte_swap_32 (pdf
->o_buf
[6]),
8081 byte_swap_32 (pdf
->o_buf
[7])
8086 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",
8094 byte_swap_32 (pdf
->id_buf
[0]),
8095 byte_swap_32 (pdf
->id_buf
[1]),
8096 byte_swap_32 (pdf
->id_buf
[2]),
8097 byte_swap_32 (pdf
->id_buf
[3]),
8099 byte_swap_32 (pdf
->u_buf
[0]),
8100 byte_swap_32 (pdf
->u_buf
[1]),
8101 byte_swap_32 (pdf
->u_buf
[2]),
8102 byte_swap_32 (pdf
->u_buf
[3]),
8103 byte_swap_32 (pdf
->u_buf
[4]),
8104 byte_swap_32 (pdf
->u_buf
[5]),
8105 byte_swap_32 (pdf
->u_buf
[6]),
8106 byte_swap_32 (pdf
->u_buf
[7]),
8108 byte_swap_32 (pdf
->o_buf
[0]),
8109 byte_swap_32 (pdf
->o_buf
[1]),
8110 byte_swap_32 (pdf
->o_buf
[2]),
8111 byte_swap_32 (pdf
->o_buf
[3]),
8112 byte_swap_32 (pdf
->o_buf
[4]),
8113 byte_swap_32 (pdf
->o_buf
[5]),
8114 byte_swap_32 (pdf
->o_buf
[6]),
8115 byte_swap_32 (pdf
->o_buf
[7])
8119 else if (hash_mode
== 10600)
8121 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8123 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8124 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8126 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8128 else if (hash_mode
== 10700)
8130 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8132 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8133 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8135 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8137 else if (hash_mode
== 10900)
8139 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8141 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8142 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8144 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8146 else if (hash_mode
== 11100)
8148 u32 salt_challenge
= salt
.salt_buf
[0];
8150 salt_challenge
= byte_swap_32 (salt_challenge
);
8152 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
8154 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
8155 SIGNATURE_POSTGRESQL_AUTH
,
8163 else if (hash_mode
== 11200)
8165 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
8166 SIGNATURE_MYSQL_AUTH
,
8167 (unsigned char *) salt
.salt_buf
,
8174 else if (hash_mode
== 11300)
8176 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
8178 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
8180 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
8181 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
8182 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
8184 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
8185 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
8186 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
8188 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
8190 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
8192 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
8195 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
8197 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
8199 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8202 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8204 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8206 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8209 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8210 SIGNATURE_BITCOIN_WALLET
,
8214 (unsigned char *) salt
.salt_buf
,
8222 free (cry_master_buf
);
8224 free (public_key_buf
);
8226 else if (hash_mode
== 11400)
8228 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8230 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8231 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8233 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8235 else if (hash_mode
== 11600)
8237 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8239 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8241 const uint data_len
= seven_zip
->data_len
;
8243 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8245 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8247 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8249 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8252 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8253 SIGNATURE_SEVEN_ZIP
,
8257 (char *) seven_zip
->salt_buf
,
8259 seven_zip
->iv_buf
[0],
8260 seven_zip
->iv_buf
[1],
8261 seven_zip
->iv_buf
[2],
8262 seven_zip
->iv_buf
[3],
8264 seven_zip
->data_len
,
8265 seven_zip
->unpack_size
,
8270 else if (hash_mode
== 11700)
8272 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8282 else if (hash_mode
== 11800)
8284 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8302 else if (hash_mode
== 11900)
8304 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8306 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8307 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8309 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8311 else if (hash_mode
== 12000)
8313 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8315 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8316 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8318 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8320 else if (hash_mode
== 12100)
8322 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8324 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8325 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8327 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8329 else if (hash_mode
== 12200)
8331 uint
*ptr_digest
= digest_buf
;
8332 uint
*ptr_salt
= salt
.salt_buf
;
8334 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8341 else if (hash_mode
== 12300)
8343 uint
*ptr_digest
= digest_buf
;
8344 uint
*ptr_salt
= salt
.salt_buf
;
8346 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",
8347 ptr_digest
[ 0], ptr_digest
[ 1],
8348 ptr_digest
[ 2], ptr_digest
[ 3],
8349 ptr_digest
[ 4], ptr_digest
[ 5],
8350 ptr_digest
[ 6], ptr_digest
[ 7],
8351 ptr_digest
[ 8], ptr_digest
[ 9],
8352 ptr_digest
[10], ptr_digest
[11],
8353 ptr_digest
[12], ptr_digest
[13],
8354 ptr_digest
[14], ptr_digest
[15],
8360 else if (hash_mode
== 12400)
8362 // encode iteration count
8364 char salt_iter
[5] = { 0 };
8366 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8367 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8368 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8369 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8374 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8375 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8376 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8377 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8382 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8384 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8385 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8387 memcpy (tmp_buf
, digest_buf
, 8);
8389 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8393 // fill the resulting buffer
8395 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8397 else if (hash_mode
== 12500)
8399 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8401 byte_swap_32 (salt
.salt_buf
[0]),
8402 byte_swap_32 (salt
.salt_buf
[1]),
8408 else if (hash_mode
== 12600)
8410 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8411 digest_buf
[0] + salt
.salt_buf_pc
[0],
8412 digest_buf
[1] + salt
.salt_buf_pc
[1],
8413 digest_buf
[2] + salt
.salt_buf_pc
[2],
8414 digest_buf
[3] + salt
.salt_buf_pc
[3],
8415 digest_buf
[4] + salt
.salt_buf_pc
[4],
8416 digest_buf
[5] + salt
.salt_buf_pc
[5],
8417 digest_buf
[6] + salt
.salt_buf_pc
[6],
8418 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8420 else if (hash_mode
== 12700)
8422 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8424 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8425 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8427 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8429 else if (hash_mode
== 12800)
8431 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8433 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",
8446 byte_swap_32 (digest_buf
[0]),
8447 byte_swap_32 (digest_buf
[1]),
8448 byte_swap_32 (digest_buf
[2]),
8449 byte_swap_32 (digest_buf
[3]),
8450 byte_swap_32 (digest_buf
[4]),
8451 byte_swap_32 (digest_buf
[5]),
8452 byte_swap_32 (digest_buf
[6]),
8453 byte_swap_32 (digest_buf
[7])
8456 else if (hash_mode
== 12900)
8458 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",
8467 byte_swap_32 (digest_buf
[0]),
8468 byte_swap_32 (digest_buf
[1]),
8469 byte_swap_32 (digest_buf
[2]),
8470 byte_swap_32 (digest_buf
[3]),
8471 byte_swap_32 (digest_buf
[4]),
8472 byte_swap_32 (digest_buf
[5]),
8473 byte_swap_32 (digest_buf
[6]),
8474 byte_swap_32 (digest_buf
[7]),
8481 else if (hash_mode
== 13000)
8483 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8485 rar5_t
*rar5
= &rar5s
[salt_pos
];
8487 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8497 byte_swap_32 (digest_buf
[0]),
8498 byte_swap_32 (digest_buf
[1])
8501 else if (hash_mode
== 13100)
8503 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8505 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8507 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8508 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8510 char data
[2560 * 4 * 2] = { 0 };
8512 char *ptr_data
= data
;
8514 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8515 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8520 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8521 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8523 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8525 (char *) krb5tgs
->account_info
,
8529 else if (hash_mode
== 13200)
8531 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8545 else if (hash_mode
== 13300)
8547 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8548 SIGNATURE_AXCRYPT_SHA1
,
8554 else if (hash_mode
== 13400)
8556 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8558 keepass_t
*keepass
= &keepasss
[salt_pos
];
8560 u32 version
= (u32
) keepass
->version
;
8561 u32 rounds
= salt
.salt_iter
;
8562 u32 algorithm
= (u32
) keepass
->algorithm
;
8563 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8565 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8566 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8567 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8568 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8569 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8571 /* specific to version 1 */
8575 /* specific to version 2 */
8576 u32 expected_bytes_len
;
8577 u32
*ptr_expected_bytes
;
8579 u32 final_random_seed_len
;
8580 u32 transf_random_seed_len
;
8582 u32 contents_hash_len
;
8584 transf_random_seed_len
= 8;
8586 contents_hash_len
= 8;
8587 final_random_seed_len
= 8;
8590 final_random_seed_len
= 4;
8592 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8598 char *ptr_data
= out_buf
;
8600 ptr_data
+= strlen(out_buf
);
8605 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8606 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8611 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8612 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8617 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8618 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8625 contents_len
= (u32
) keepass
->contents_len
;
8626 ptr_contents
= (u32
*) keepass
->contents
;
8628 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8629 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8641 char ptr_contents_len
[10] = { 0 };
8643 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8645 sprintf (ptr_data
, "%d", contents_len
);
8647 ptr_data
+= strlen(ptr_contents_len
);
8652 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8653 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8655 else if (version
== 2)
8657 expected_bytes_len
= 8;
8658 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8660 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8661 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8666 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8667 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8681 sprintf (ptr_data
, "%d", keyfile_len
);
8688 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8689 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8692 else if (hash_mode
== 13500)
8694 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8696 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8698 const u32 salt_len
= (pstoken
->salt_len
> 512) ? 512 : pstoken
->salt_len
;
8700 char pstoken_tmp
[1024 + 1] = { 0 };
8702 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8704 const u8
*ptr
= (const u8
*) pstoken
->salt_buf
;
8706 sprintf (pstoken_tmp
+ j
, "%02x", ptr
[i
]);
8709 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8717 else if (hash_mode
== 13600)
8719 zip2_t
*zip2s
= (zip2_t
*) data
.esalts_buf
;
8721 zip2_t
*zip2
= &zip2s
[salt_pos
];
8723 const u32 salt_len
= zip2
->salt_len
;
8725 char salt_tmp
[32 + 1] = { 0 };
8727 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8729 const u8
*ptr
= (const u8
*) zip2
->salt_buf
;
8731 sprintf (salt_tmp
+ j
, "%02x", ptr
[i
]);
8734 const u32 data_len
= zip2
->data_len
;
8736 char data_tmp
[8192 + 1] = { 0 };
8738 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8740 const u8
*ptr
= (const u8
*) zip2
->data_buf
;
8742 sprintf (data_tmp
+ j
, "%02x", ptr
[i
]);
8745 const u32 auth_len
= zip2
->auth_len
;
8747 char auth_tmp
[20 + 1] = { 0 };
8749 for (uint i
= 0, j
= 0; i
< auth_len
; i
+= 1, j
+= 2)
8751 const u8
*ptr
= (const u8
*) zip2
->auth_buf
;
8753 sprintf (auth_tmp
+ j
, "%02x", ptr
[i
]);
8756 snprintf (out_buf
, 255, "%s*%u*%u*%u*%s*%x*%u*%s*%s*%s",
8757 SIGNATURE_ZIP2_START
,
8763 zip2
->compress_length
,
8766 SIGNATURE_ZIP2_STOP
);
8768 else if ((hash_mode
>= 13700) && (hash_mode
<= 13799))
8770 snprintf (out_buf
, len
-1, "%s", hashfile
);
8772 else if (hash_mode
== 13800)
8774 win8phone_t
*esalts
= (win8phone_t
*) data
.esalts_buf
;
8776 win8phone_t
*esalt
= &esalts
[salt_pos
];
8778 char buf
[256 + 1] = { 0 };
8780 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
8782 sprintf (buf
+ j
, "%08x", esalt
->salt_buf
[i
]);
8785 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%s",
8798 if (hash_type
== HASH_TYPE_MD4
)
8800 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8806 else if (hash_type
== HASH_TYPE_MD5
)
8808 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8814 else if (hash_type
== HASH_TYPE_SHA1
)
8816 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8823 else if (hash_type
== HASH_TYPE_SHA256
)
8825 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8835 else if (hash_type
== HASH_TYPE_SHA384
)
8837 uint
*ptr
= digest_buf
;
8839 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8847 else if (hash_type
== HASH_TYPE_SHA512
)
8849 uint
*ptr
= digest_buf
;
8851 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8861 else if (hash_type
== HASH_TYPE_LM
)
8863 snprintf (out_buf
, len
-1, "%08x%08x",
8867 else if (hash_type
== HASH_TYPE_ORACLEH
)
8869 snprintf (out_buf
, len
-1, "%08X%08X",
8873 else if (hash_type
== HASH_TYPE_BCRYPT
)
8875 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8876 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8878 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8880 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8882 else if (hash_type
== HASH_TYPE_KECCAK
)
8884 uint
*ptr
= digest_buf
;
8886 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",
8914 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8916 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8918 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8925 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8927 digest_buf
[ 0] = digest_buf
[ 0];
8928 digest_buf
[ 1] = digest_buf
[ 1];
8929 digest_buf
[ 2] = digest_buf
[ 2];
8930 digest_buf
[ 3] = digest_buf
[ 3];
8931 digest_buf
[ 4] = digest_buf
[ 4];
8932 digest_buf
[ 5] = digest_buf
[ 5];
8933 digest_buf
[ 6] = digest_buf
[ 6];
8934 digest_buf
[ 7] = digest_buf
[ 7];
8935 digest_buf
[ 8] = digest_buf
[ 8];
8936 digest_buf
[ 9] = digest_buf
[ 9];
8937 digest_buf
[10] = digest_buf
[10];
8938 digest_buf
[11] = digest_buf
[11];
8939 digest_buf
[12] = digest_buf
[12];
8940 digest_buf
[13] = digest_buf
[13];
8941 digest_buf
[14] = digest_buf
[14];
8942 digest_buf
[15] = digest_buf
[15];
8944 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8962 else if (hash_type
== HASH_TYPE_GOST
)
8964 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8974 else if (hash_type
== HASH_TYPE_MYSQL
)
8976 snprintf (out_buf
, len
-1, "%08x%08x",
8980 else if (hash_type
== HASH_TYPE_LOTUS5
)
8982 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8988 else if (hash_type
== HASH_TYPE_LOTUS6
)
8990 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8991 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8992 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8993 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8995 char buf
[16] = { 0 };
8997 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8998 memcpy (buf
+ 5, digest_buf
, 9);
9002 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
9004 tmp_buf
[18] = salt
.salt_buf_pc
[7];
9007 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
9009 else if (hash_type
== HASH_TYPE_LOTUS8
)
9011 char buf
[52] = { 0 };
9015 memcpy (buf
+ 0, salt
.salt_buf
, 16);
9021 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
9025 buf
[26] = salt
.salt_buf_pc
[0];
9026 buf
[27] = salt
.salt_buf_pc
[1];
9030 memcpy (buf
+ 28, digest_buf
, 8);
9032 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
9036 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
9038 else if (hash_type
== HASH_TYPE_CRC32
)
9040 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
9044 if (salt_type
== SALT_TYPE_INTERN
)
9046 size_t pos
= strlen (out_buf
);
9048 out_buf
[pos
] = data
.separator
;
9050 char *ptr
= (char *) salt
.salt_buf
;
9052 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
9054 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
9058 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
9060 memset (hccap
, 0, sizeof (hccap_t
));
9062 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
9064 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
9066 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
9067 wpa_t
*wpa
= &wpas
[salt_pos
];
9069 hccap
->keyver
= wpa
->keyver
;
9071 hccap
->eapol_size
= wpa
->eapol_size
;
9073 if (wpa
->keyver
!= 1)
9075 uint eapol_tmp
[64] = { 0 };
9077 for (uint i
= 0; i
< 64; i
++)
9079 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9082 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
9086 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
9089 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
9090 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
9091 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
9092 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
9094 char *digests_buf_ptr
= (char *) data
.digests_buf
;
9096 uint dgst_size
= data
.dgst_size
;
9098 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
9100 if (wpa
->keyver
!= 1)
9102 uint digest_tmp
[4] = { 0 };
9104 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
9105 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
9106 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
9107 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
9109 memcpy (hccap
->keymic
, digest_tmp
, 16);
9113 memcpy (hccap
->keymic
, digest_ptr
, 16);
9117 void SuspendThreads ()
9119 if (data
.devices_status
== STATUS_RUNNING
)
9121 hc_timer_set (&data
.timer_paused
);
9123 data
.devices_status
= STATUS_PAUSED
;
9125 log_info ("Paused");
9129 void ResumeThreads ()
9131 if (data
.devices_status
== STATUS_PAUSED
)
9135 hc_timer_get (data
.timer_paused
, ms_paused
);
9137 data
.ms_paused
+= ms_paused
;
9139 data
.devices_status
= STATUS_RUNNING
;
9141 log_info ("Resumed");
9147 if (data
.devices_status
!= STATUS_RUNNING
) return;
9149 data
.devices_status
= STATUS_BYPASS
;
9151 log_info ("Next dictionary / mask in queue selected, bypassing current one");
9154 void stop_at_checkpoint ()
9156 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9158 if (data
.devices_status
!= STATUS_RUNNING
) return;
9161 // this feature only makes sense if --restore-disable was not specified
9163 if (data
.restore_disable
== 1)
9165 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
9170 // check if monitoring of Restore Point updates should be enabled or disabled
9172 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9174 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
9176 // save the current restore point value
9178 data
.checkpoint_cur_words
= get_lowest_words_done ();
9180 log_info ("Checkpoint enabled: will quit at next Restore Point update");
9184 data
.devices_status
= STATUS_RUNNING
;
9186 // reset the global value for checkpoint checks
9188 data
.checkpoint_cur_words
= 0;
9190 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
9196 if (data
.devices_status
== STATUS_INIT
) return;
9197 if (data
.devices_status
== STATUS_STARTING
) return;
9199 data
.devices_status
= STATUS_ABORTED
;
9204 if (data
.devices_status
== STATUS_INIT
) return;
9205 if (data
.devices_status
== STATUS_STARTING
) return;
9207 data
.devices_status
= STATUS_QUIT
;
9210 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
9212 FILE *fp
= fopen (kernel_file
, "rb");
9218 memset (&st
, 0, sizeof (st
));
9220 stat (kernel_file
, &st
);
9222 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
9224 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
9226 if (num_read
!= (size_t) st
.st_size
)
9228 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9235 buf
[st
.st_size
] = 0;
9237 for (int i
= 0; i
< num_devices
; i
++)
9239 kernel_lengths
[i
] = (size_t) st
.st_size
;
9241 kernel_sources
[i
] = buf
;
9246 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9254 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
9256 if (binary_size
> 0)
9258 FILE *fp
= fopen (dst
, "wb");
9261 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
9272 restore_data_t
*init_restore (int argc
, char **argv
)
9274 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
9276 if (data
.restore_disable
== 0)
9278 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
9282 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
9286 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
9295 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9297 int pidbin_len
= -1;
9300 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9302 FILE *fd
= fopen (pidbin
, "rb");
9306 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9308 pidbin
[pidbin_len
] = 0;
9312 char *argv0_r
= strrchr (argv
[0], '/');
9314 char *pidbin_r
= strrchr (pidbin
, '/');
9316 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9318 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9320 if (strcmp (argv0_r
, pidbin_r
) == 0)
9322 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
9329 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9331 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9333 int pidbin2_len
= -1;
9335 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9336 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9338 pidbin
[pidbin_len
] = 0;
9339 pidbin2
[pidbin2_len
] = 0;
9343 if (strcmp (pidbin
, pidbin2
) == 0)
9345 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9358 if (rd
->version_bin
< RESTORE_MIN
)
9360 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9367 memset (rd
, 0, sizeof (restore_data_t
));
9369 rd
->version_bin
= VERSION_BIN
;
9372 rd
->pid
= getpid ();
9374 rd
->pid
= GetCurrentProcessId ();
9377 if (getcwd (rd
->cwd
, 255) == NULL
)
9390 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9392 FILE *fp
= fopen (eff_restore_file
, "rb");
9396 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
9401 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9403 log_error ("ERROR: cannot read %s", eff_restore_file
);
9408 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9410 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9412 for (uint i
= 0; i
< rd
->argc
; i
++)
9414 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9416 log_error ("ERROR: cannot read %s", eff_restore_file
);
9421 size_t len
= strlen (buf
);
9423 if (len
) buf
[len
- 1] = 0;
9425 rd
->argv
[i
] = mystrdup (buf
);
9432 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9434 if (chdir (rd
->cwd
))
9436 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9437 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9438 " https://github.com/philsmd/analyze_hc_restore\n"
9439 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9445 u64
get_lowest_words_done ()
9449 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9451 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9453 if (device_param
->skipped
) continue;
9455 const u64 words_done
= device_param
->words_done
;
9457 if (words_done
< words_cur
) words_cur
= words_done
;
9460 // It's possible that a device's workload isn't finished right after a restore-case.
9461 // In that case, this function would return 0 and overwrite the real restore point
9462 // There's also data.words_cur which is set to rd->words_cur but it changes while
9463 // the attack is running therefore we should stick to rd->words_cur.
9464 // Note that -s influences rd->words_cur we should keep a close look on that.
9466 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9471 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9473 u64 words_cur
= get_lowest_words_done ();
9475 rd
->words_cur
= words_cur
;
9477 FILE *fp
= fopen (new_restore_file
, "wb");
9481 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9486 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9488 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9493 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9495 for (uint i
= 0; i
< rd
->argc
; i
++)
9497 fprintf (fp
, "%s", rd
->argv
[i
]);
9503 fsync (fileno (fp
));
9508 void cycle_restore ()
9510 const char *eff_restore_file
= data
.eff_restore_file
;
9511 const char *new_restore_file
= data
.new_restore_file
;
9513 restore_data_t
*rd
= data
.rd
;
9515 write_restore (new_restore_file
, rd
);
9519 memset (&st
, 0, sizeof(st
));
9521 if (stat (eff_restore_file
, &st
) == 0)
9523 if (unlink (eff_restore_file
))
9525 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9529 if (rename (new_restore_file
, eff_restore_file
))
9531 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9535 void check_checkpoint ()
9537 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9539 u64 words_cur
= get_lowest_words_done ();
9541 if (words_cur
!= data
.checkpoint_cur_words
)
9551 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9555 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9557 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9559 myfree (alias
->device_name
);
9560 myfree (alias
->alias_name
);
9563 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9565 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9567 myfree (entry
->device_name
);
9570 myfree (tuning_db
->alias_buf
);
9571 myfree (tuning_db
->entry_buf
);
9576 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9578 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9580 int num_lines
= count_lines (fp
);
9582 // a bit over-allocated
9584 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9585 tuning_db
->alias_cnt
= 0;
9587 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9588 tuning_db
->entry_cnt
= 0;
9593 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9595 FILE *fp
= fopen (tuning_db_file
, "rb");
9599 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9604 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9610 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9614 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9616 if (line_buf
== NULL
) break;
9620 const int line_len
= in_superchop (line_buf
);
9622 if (line_len
== 0) continue;
9624 if (line_buf
[0] == '#') continue;
9628 char *token_ptr
[7] = { NULL
};
9632 char *next
= strtok (line_buf
, "\t ");
9634 token_ptr
[token_cnt
] = next
;
9638 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9640 token_ptr
[token_cnt
] = next
;
9647 char *device_name
= token_ptr
[0];
9648 char *alias_name
= token_ptr
[1];
9650 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9652 alias
->device_name
= mystrdup (device_name
);
9653 alias
->alias_name
= mystrdup (alias_name
);
9655 tuning_db
->alias_cnt
++;
9657 else if (token_cnt
== 6)
9659 if ((token_ptr
[1][0] != '0') &&
9660 (token_ptr
[1][0] != '1') &&
9661 (token_ptr
[1][0] != '3') &&
9662 (token_ptr
[1][0] != '*'))
9664 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9669 if ((token_ptr
[3][0] != '1') &&
9670 (token_ptr
[3][0] != '2') &&
9671 (token_ptr
[3][0] != '4') &&
9672 (token_ptr
[3][0] != '8') &&
9673 (token_ptr
[3][0] != 'N'))
9675 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9680 char *device_name
= token_ptr
[0];
9682 int attack_mode
= -1;
9684 int vector_width
= -1;
9685 int kernel_accel
= -1;
9686 int kernel_loops
= -1;
9688 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9689 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9690 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9692 if (token_ptr
[4][0] != 'A')
9694 kernel_accel
= atoi (token_ptr
[4]);
9696 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9698 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9708 if (token_ptr
[5][0] != 'A')
9710 kernel_loops
= atoi (token_ptr
[5]);
9712 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9714 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9724 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9726 entry
->device_name
= mystrdup (device_name
);
9727 entry
->attack_mode
= attack_mode
;
9728 entry
->hash_type
= hash_type
;
9729 entry
->vector_width
= vector_width
;
9730 entry
->kernel_accel
= kernel_accel
;
9731 entry
->kernel_loops
= kernel_loops
;
9733 tuning_db
->entry_cnt
++;
9737 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9747 // todo: print loaded 'cnt' message
9749 // sort the database
9751 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9752 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9757 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9759 static tuning_db_entry_t s
;
9761 // first we need to convert all spaces in the device_name to underscore
9763 char *device_name_nospace
= strdup (device_param
->device_name
);
9765 int device_name_length
= strlen (device_name_nospace
);
9769 for (i
= 0; i
< device_name_length
; i
++)
9771 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9774 // find out if there's an alias configured
9776 tuning_db_alias_t a
;
9778 a
.device_name
= device_name_nospace
;
9780 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
);
9782 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9784 // attack-mode 6 and 7 are attack-mode 1 basically
9786 if (attack_mode
== 6) attack_mode
= 1;
9787 if (attack_mode
== 7) attack_mode
= 1;
9789 // bsearch is not ideal but fast enough
9791 s
.device_name
= device_name_nospace
;
9792 s
.attack_mode
= attack_mode
;
9793 s
.hash_type
= hash_type
;
9795 tuning_db_entry_t
*entry
= NULL
;
9797 // this will produce all 2^3 combinations required
9799 for (i
= 0; i
< 8; i
++)
9801 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9802 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9803 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9805 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9807 if (entry
!= NULL
) break;
9809 // in non-wildcard mode do some additional checks:
9813 // in case we have an alias-name
9815 if (alias_name
!= NULL
)
9817 s
.device_name
= alias_name
;
9819 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9821 if (entry
!= NULL
) break;
9824 // or by device type
9826 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9828 s
.device_name
= "DEVICE_TYPE_CPU";
9830 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9832 s
.device_name
= "DEVICE_TYPE_GPU";
9834 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9836 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9839 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9841 if (entry
!= NULL
) break;
9845 // free converted device_name
9847 myfree (device_name_nospace
);
9856 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9858 u8 tmp
[256] = { 0 };
9860 if (salt_len
> sizeof (tmp
))
9865 memcpy (tmp
, in
, salt_len
);
9867 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9869 if ((salt_len
% 2) == 0)
9871 u32 new_salt_len
= salt_len
/ 2;
9873 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9878 tmp
[i
] = hex_convert (p1
) << 0;
9879 tmp
[i
] |= hex_convert (p0
) << 4;
9882 salt_len
= new_salt_len
;
9889 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9891 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9894 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9896 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9900 u32
*tmp_uint
= (u32
*) tmp
;
9902 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9903 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9904 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9905 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9906 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9907 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9908 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9909 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9910 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9911 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9913 salt_len
= salt_len
* 2;
9921 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9923 lowercase (tmp
, salt_len
);
9926 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9928 uppercase (tmp
, salt_len
);
9933 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9938 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9943 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9945 u32
*tmp_uint
= (uint
*) tmp
;
9951 for (u32 i
= 0; i
< max
; i
++)
9953 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9956 // Important: we may need to increase the length of memcpy since
9957 // we don't want to "loose" some swapped bytes (could happen if
9958 // they do not perfectly fit in the 4-byte blocks)
9959 // Memcpy does always copy the bytes in the BE order, but since
9960 // we swapped them, some important bytes could be in positions
9961 // we normally skip with the original len
9963 if (len
% 4) len
+= 4 - (len
% 4);
9966 memcpy (out
, tmp
, len
);
9971 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9973 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9975 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9977 u32
*digest
= (u32
*) hash_buf
->digest
;
9979 salt_t
*salt
= hash_buf
->salt
;
9981 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9983 char *iter_pos
= input_buf
+ 4;
9985 salt
->salt_iter
= 1 << atoi (iter_pos
);
9987 char *salt_pos
= strchr (iter_pos
, '$');
9989 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9995 salt
->salt_len
= salt_len
;
9997 u8 tmp_buf
[100] = { 0 };
9999 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
10001 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10003 memcpy (salt_buf_ptr
, tmp_buf
, 16);
10005 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
10006 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
10007 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
10008 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
10010 char *hash_pos
= salt_pos
+ 22;
10012 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10014 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
10016 memcpy (digest
, tmp_buf
, 24);
10018 digest
[0] = byte_swap_32 (digest
[0]);
10019 digest
[1] = byte_swap_32 (digest
[1]);
10020 digest
[2] = byte_swap_32 (digest
[2]);
10021 digest
[3] = byte_swap_32 (digest
[3]);
10022 digest
[4] = byte_swap_32 (digest
[4]);
10023 digest
[5] = byte_swap_32 (digest
[5]);
10025 digest
[5] &= ~0xff; // its just 23 not 24 !
10027 return (PARSER_OK
);
10030 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10032 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
10034 u32
*digest
= (u32
*) hash_buf
->digest
;
10036 u8 tmp_buf
[100] = { 0 };
10038 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
10040 memcpy (digest
, tmp_buf
, 32);
10042 digest
[0] = byte_swap_32 (digest
[0]);
10043 digest
[1] = byte_swap_32 (digest
[1]);
10044 digest
[2] = byte_swap_32 (digest
[2]);
10045 digest
[3] = byte_swap_32 (digest
[3]);
10046 digest
[4] = byte_swap_32 (digest
[4]);
10047 digest
[5] = byte_swap_32 (digest
[5]);
10048 digest
[6] = byte_swap_32 (digest
[6]);
10049 digest
[7] = byte_swap_32 (digest
[7]);
10051 digest
[0] -= SHA256M_A
;
10052 digest
[1] -= SHA256M_B
;
10053 digest
[2] -= SHA256M_C
;
10054 digest
[3] -= SHA256M_D
;
10055 digest
[4] -= SHA256M_E
;
10056 digest
[5] -= SHA256M_F
;
10057 digest
[6] -= SHA256M_G
;
10058 digest
[7] -= SHA256M_H
;
10060 return (PARSER_OK
);
10063 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10065 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
10067 u32
*digest
= (u32
*) hash_buf
->digest
;
10069 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10070 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10072 digest
[0] = byte_swap_32 (digest
[0]);
10073 digest
[1] = byte_swap_32 (digest
[1]);
10077 IP (digest
[0], digest
[1], tt
);
10079 digest
[0] = digest
[0];
10080 digest
[1] = digest
[1];
10084 return (PARSER_OK
);
10087 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10089 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
10091 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
10093 u32
*digest
= (u32
*) hash_buf
->digest
;
10095 salt_t
*salt
= hash_buf
->salt
;
10097 char *hash_pos
= input_buf
+ 10;
10099 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10100 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10101 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10102 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10103 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10105 digest
[0] -= SHA1M_A
;
10106 digest
[1] -= SHA1M_B
;
10107 digest
[2] -= SHA1M_C
;
10108 digest
[3] -= SHA1M_D
;
10109 digest
[4] -= SHA1M_E
;
10111 uint salt_len
= 10;
10113 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10115 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10117 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10119 salt
->salt_len
= salt_len
;
10121 return (PARSER_OK
);
10124 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10126 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
10128 u32
*digest
= (u32
*) hash_buf
->digest
;
10130 salt_t
*salt
= hash_buf
->salt
;
10132 char *hash_pos
= input_buf
+ 8;
10134 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10135 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10136 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10137 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10138 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10140 digest
[0] -= SHA1M_A
;
10141 digest
[1] -= SHA1M_B
;
10142 digest
[2] -= SHA1M_C
;
10143 digest
[3] -= SHA1M_D
;
10144 digest
[4] -= SHA1M_E
;
10148 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10150 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10152 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10154 salt
->salt_len
= salt_len
;
10156 return (PARSER_OK
);
10159 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10161 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
10163 u64
*digest
= (u64
*) hash_buf
->digest
;
10165 salt_t
*salt
= hash_buf
->salt
;
10167 char *hash_pos
= input_buf
+ 8;
10169 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
10170 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
10171 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
10172 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
10173 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
10174 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
10175 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
10176 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
10178 digest
[0] -= SHA512M_A
;
10179 digest
[1] -= SHA512M_B
;
10180 digest
[2] -= SHA512M_C
;
10181 digest
[3] -= SHA512M_D
;
10182 digest
[4] -= SHA512M_E
;
10183 digest
[5] -= SHA512M_F
;
10184 digest
[6] -= SHA512M_G
;
10185 digest
[7] -= SHA512M_H
;
10189 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10191 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10193 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10195 salt
->salt_len
= salt_len
;
10197 return (PARSER_OK
);
10200 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10202 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10204 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
10208 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
10211 u32
*digest
= (u32
*) hash_buf
->digest
;
10213 salt_t
*salt
= hash_buf
->salt
;
10215 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10216 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10217 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10218 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10220 digest
[0] = byte_swap_32 (digest
[0]);
10221 digest
[1] = byte_swap_32 (digest
[1]);
10222 digest
[2] = byte_swap_32 (digest
[2]);
10223 digest
[3] = byte_swap_32 (digest
[3]);
10225 digest
[0] -= MD5M_A
;
10226 digest
[1] -= MD5M_B
;
10227 digest
[2] -= MD5M_C
;
10228 digest
[3] -= MD5M_D
;
10230 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10232 uint salt_len
= input_len
- 32 - 1;
10234 char *salt_buf
= input_buf
+ 32 + 1;
10236 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10238 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_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 netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10249 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10251 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
10255 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
10260 char clean_input_buf
[32] = { 0 };
10262 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
10263 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
10265 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
10269 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
10275 clean_input_buf
[k
] = input_buf
[i
];
10283 u32
*digest
= (u32
*) hash_buf
->digest
;
10285 salt_t
*salt
= hash_buf
->salt
;
10287 u32 a
, b
, c
, d
, e
, f
;
10289 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10290 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10291 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10292 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10293 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10294 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10296 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10297 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10299 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10300 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10301 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10302 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10303 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10304 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10306 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10307 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10309 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10310 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10311 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10312 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10313 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10314 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10316 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10317 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10319 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10320 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10321 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10322 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10323 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10324 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10326 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10327 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10329 digest
[0] = byte_swap_32 (digest
[0]);
10330 digest
[1] = byte_swap_32 (digest
[1]);
10331 digest
[2] = byte_swap_32 (digest
[2]);
10332 digest
[3] = byte_swap_32 (digest
[3]);
10334 digest
[0] -= MD5M_A
;
10335 digest
[1] -= MD5M_B
;
10336 digest
[2] -= MD5M_C
;
10337 digest
[3] -= MD5M_D
;
10339 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10341 uint salt_len
= input_len
- 30 - 1;
10343 char *salt_buf
= input_buf
+ 30 + 1;
10345 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10347 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10349 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10350 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10352 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10354 salt
->salt_len
= salt_len
;
10356 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10358 salt
->salt_len
+= 22;
10360 return (PARSER_OK
);
10363 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10365 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10367 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10371 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10374 u32
*digest
= (u32
*) hash_buf
->digest
;
10376 salt_t
*salt
= hash_buf
->salt
;
10378 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10379 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10380 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10381 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10382 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10384 digest
[0] -= SHA1M_A
;
10385 digest
[1] -= SHA1M_B
;
10386 digest
[2] -= SHA1M_C
;
10387 digest
[3] -= SHA1M_D
;
10388 digest
[4] -= SHA1M_E
;
10390 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10392 uint salt_len
= input_len
- 40 - 1;
10394 char *salt_buf
= input_buf
+ 40 + 1;
10396 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10398 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10400 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10402 salt
->salt_len
= salt_len
;
10404 return (PARSER_OK
);
10407 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10409 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10411 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10415 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10418 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10420 char *iter_pos
= input_buf
+ 6;
10422 salt_t
*salt
= hash_buf
->salt
;
10424 uint iter
= atoi (iter_pos
);
10428 iter
= ROUNDS_DCC2
;
10431 salt
->salt_iter
= iter
- 1;
10433 char *salt_pos
= strchr (iter_pos
, '#');
10435 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10439 char *digest_pos
= strchr (salt_pos
, '#');
10441 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10445 uint salt_len
= digest_pos
- salt_pos
- 1;
10447 u32
*digest
= (u32
*) hash_buf
->digest
;
10449 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10450 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10451 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10452 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10454 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10456 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10458 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10460 salt
->salt_len
= salt_len
;
10462 return (PARSER_OK
);
10465 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10467 u32
*digest
= (u32
*) hash_buf
->digest
;
10469 salt_t
*salt
= hash_buf
->salt
;
10471 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10475 memcpy (&in
, input_buf
, input_len
);
10477 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10479 memcpy (digest
, in
.keymic
, 16);
10482 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10483 The phrase "Pairwise key expansion"
10484 Access Point Address (referred to as Authenticator Address AA)
10485 Supplicant Address (referred to as Supplicant Address SA)
10486 Access Point Nonce (referred to as Authenticator Anonce)
10487 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10490 uint salt_len
= strlen (in
.essid
);
10494 log_info ("WARNING: the length of the ESSID is too long. The hccap file may be invalid or corrupted");
10496 return (PARSER_SALT_LENGTH
);
10499 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10501 salt
->salt_len
= salt_len
;
10503 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10505 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10507 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10509 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10511 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10512 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10516 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10517 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10520 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10522 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10523 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10527 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10528 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10531 for (int i
= 0; i
< 25; i
++)
10533 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10536 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10537 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10538 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10539 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10541 wpa
->keyver
= in
.keyver
;
10543 if (wpa
->keyver
> 255)
10545 log_info ("ATTENTION!");
10546 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10547 log_info (" This could be due to a recent aircrack-ng bug.");
10548 log_info (" The key version was automatically reset to a reasonable value.");
10551 wpa
->keyver
&= 0xff;
10554 wpa
->eapol_size
= in
.eapol_size
;
10556 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10558 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10560 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10562 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10564 if (wpa
->keyver
== 1)
10570 digest
[0] = byte_swap_32 (digest
[0]);
10571 digest
[1] = byte_swap_32 (digest
[1]);
10572 digest
[2] = byte_swap_32 (digest
[2]);
10573 digest
[3] = byte_swap_32 (digest
[3]);
10575 for (int i
= 0; i
< 64; i
++)
10577 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10581 uint32_t *p0
= (uint32_t *) in
.essid
;
10585 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10586 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10588 salt
->salt_buf
[10] = c0
;
10589 salt
->salt_buf
[11] = c1
;
10591 return (PARSER_OK
);
10594 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10596 u32
*digest
= (u32
*) hash_buf
->digest
;
10598 salt_t
*salt
= hash_buf
->salt
;
10600 if (input_len
== 0)
10602 log_error ("Password Safe v2 container not specified");
10607 FILE *fp
= fopen (input_buf
, "rb");
10611 log_error ("%s: %s", input_buf
, strerror (errno
));
10618 memset (&buf
, 0, sizeof (psafe2_hdr
));
10620 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10624 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10626 salt
->salt_buf
[0] = buf
.random
[0];
10627 salt
->salt_buf
[1] = buf
.random
[1];
10629 salt
->salt_len
= 8;
10630 salt
->salt_iter
= 1000;
10632 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10633 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10634 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10635 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10636 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10638 return (PARSER_OK
);
10641 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10643 u32
*digest
= (u32
*) hash_buf
->digest
;
10645 salt_t
*salt
= hash_buf
->salt
;
10647 if (input_len
== 0)
10649 log_error (".psafe3 not specified");
10654 FILE *fp
= fopen (input_buf
, "rb");
10658 log_error ("%s: %s", input_buf
, strerror (errno
));
10665 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10669 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10671 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10673 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10675 salt
->salt_iter
= in
.iterations
+ 1;
10677 salt
->salt_buf
[0] = in
.salt_buf
[0];
10678 salt
->salt_buf
[1] = in
.salt_buf
[1];
10679 salt
->salt_buf
[2] = in
.salt_buf
[2];
10680 salt
->salt_buf
[3] = in
.salt_buf
[3];
10681 salt
->salt_buf
[4] = in
.salt_buf
[4];
10682 salt
->salt_buf
[5] = in
.salt_buf
[5];
10683 salt
->salt_buf
[6] = in
.salt_buf
[6];
10684 salt
->salt_buf
[7] = in
.salt_buf
[7];
10686 salt
->salt_len
= 32;
10688 digest
[0] = in
.hash_buf
[0];
10689 digest
[1] = in
.hash_buf
[1];
10690 digest
[2] = in
.hash_buf
[2];
10691 digest
[3] = in
.hash_buf
[3];
10692 digest
[4] = in
.hash_buf
[4];
10693 digest
[5] = in
.hash_buf
[5];
10694 digest
[6] = in
.hash_buf
[6];
10695 digest
[7] = in
.hash_buf
[7];
10697 digest
[0] = byte_swap_32 (digest
[0]);
10698 digest
[1] = byte_swap_32 (digest
[1]);
10699 digest
[2] = byte_swap_32 (digest
[2]);
10700 digest
[3] = byte_swap_32 (digest
[3]);
10701 digest
[4] = byte_swap_32 (digest
[4]);
10702 digest
[5] = byte_swap_32 (digest
[5]);
10703 digest
[6] = byte_swap_32 (digest
[6]);
10704 digest
[7] = byte_swap_32 (digest
[7]);
10706 return (PARSER_OK
);
10709 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10711 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10713 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10715 u32
*digest
= (u32
*) hash_buf
->digest
;
10717 salt_t
*salt
= hash_buf
->salt
;
10719 char *iter_pos
= input_buf
+ 3;
10721 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10723 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10725 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10727 salt
->salt_iter
= salt_iter
;
10729 char *salt_pos
= iter_pos
+ 1;
10733 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10735 salt
->salt_len
= salt_len
;
10737 char *hash_pos
= salt_pos
+ salt_len
;
10739 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10741 return (PARSER_OK
);
10744 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10746 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10748 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10750 u32
*digest
= (u32
*) hash_buf
->digest
;
10752 salt_t
*salt
= hash_buf
->salt
;
10754 char *salt_pos
= input_buf
+ 3;
10756 uint iterations_len
= 0;
10758 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10762 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10764 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10765 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10769 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10773 iterations_len
+= 8;
10777 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10780 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10782 char *hash_pos
= strchr (salt_pos
, '$');
10784 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10786 uint salt_len
= hash_pos
- salt_pos
;
10788 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10790 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10792 salt
->salt_len
= salt_len
;
10796 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10798 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10800 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10802 return (PARSER_OK
);
10805 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10807 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10809 u32
*digest
= (u32
*) hash_buf
->digest
;
10811 salt_t
*salt
= hash_buf
->salt
;
10813 char *salt_pos
= input_buf
+ 6;
10815 uint iterations_len
= 0;
10817 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10821 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10823 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10824 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10828 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10832 iterations_len
+= 8;
10836 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10839 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10841 char *hash_pos
= strchr (salt_pos
, '$');
10843 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10845 uint salt_len
= hash_pos
- salt_pos
;
10847 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10849 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10851 salt
->salt_len
= salt_len
;
10855 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10857 return (PARSER_OK
);
10860 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10862 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10864 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10866 u32
*digest
= (u32
*) hash_buf
->digest
;
10868 salt_t
*salt
= hash_buf
->salt
;
10870 char *salt_pos
= input_buf
+ 14;
10872 char *hash_pos
= strchr (salt_pos
, '*');
10874 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10878 uint salt_len
= hash_pos
- salt_pos
- 1;
10880 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10882 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10884 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10886 salt
->salt_len
= salt_len
;
10888 u8 tmp_buf
[100] = { 0 };
10890 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10892 memcpy (digest
, tmp_buf
, 20);
10894 digest
[0] = byte_swap_32 (digest
[0]);
10895 digest
[1] = byte_swap_32 (digest
[1]);
10896 digest
[2] = byte_swap_32 (digest
[2]);
10897 digest
[3] = byte_swap_32 (digest
[3]);
10898 digest
[4] = byte_swap_32 (digest
[4]);
10900 digest
[0] -= SHA1M_A
;
10901 digest
[1] -= SHA1M_B
;
10902 digest
[2] -= SHA1M_C
;
10903 digest
[3] -= SHA1M_D
;
10904 digest
[4] -= SHA1M_E
;
10906 return (PARSER_OK
);
10909 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10911 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10913 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10915 if (c12
& 3) return (PARSER_HASH_VALUE
);
10917 u32
*digest
= (u32
*) hash_buf
->digest
;
10919 salt_t
*salt
= hash_buf
->salt
;
10921 // for ascii_digest
10922 salt
->salt_sign
[0] = input_buf
[0];
10923 salt
->salt_sign
[1] = input_buf
[1];
10925 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10926 | itoa64_to_int (input_buf
[1]) << 6;
10928 salt
->salt_len
= 2;
10930 u8 tmp_buf
[100] = { 0 };
10932 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10934 memcpy (digest
, tmp_buf
, 8);
10938 IP (digest
[0], digest
[1], tt
);
10943 return (PARSER_OK
);
10946 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10948 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10950 u32
*digest
= (u32
*) hash_buf
->digest
;
10952 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10953 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10954 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10955 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10957 digest
[0] = byte_swap_32 (digest
[0]);
10958 digest
[1] = byte_swap_32 (digest
[1]);
10959 digest
[2] = byte_swap_32 (digest
[2]);
10960 digest
[3] = byte_swap_32 (digest
[3]);
10962 digest
[0] -= MD4M_A
;
10963 digest
[1] -= MD4M_B
;
10964 digest
[2] -= MD4M_C
;
10965 digest
[3] -= MD4M_D
;
10967 return (PARSER_OK
);
10970 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10972 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10974 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10978 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10981 u32
*digest
= (u32
*) hash_buf
->digest
;
10983 salt_t
*salt
= hash_buf
->salt
;
10985 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10986 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10987 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10988 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10990 digest
[0] = byte_swap_32 (digest
[0]);
10991 digest
[1] = byte_swap_32 (digest
[1]);
10992 digest
[2] = byte_swap_32 (digest
[2]);
10993 digest
[3] = byte_swap_32 (digest
[3]);
10995 digest
[0] -= MD4M_A
;
10996 digest
[1] -= MD4M_B
;
10997 digest
[2] -= MD4M_C
;
10998 digest
[3] -= MD4M_D
;
11000 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11002 uint salt_len
= input_len
- 32 - 1;
11004 char *salt_buf
= input_buf
+ 32 + 1;
11006 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11008 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11010 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11012 salt
->salt_len
= salt_len
;
11014 return (PARSER_OK
);
11017 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11019 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
11021 u32
*digest
= (u32
*) hash_buf
->digest
;
11023 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11024 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11025 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11026 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11028 digest
[0] = byte_swap_32 (digest
[0]);
11029 digest
[1] = byte_swap_32 (digest
[1]);
11030 digest
[2] = byte_swap_32 (digest
[2]);
11031 digest
[3] = byte_swap_32 (digest
[3]);
11033 digest
[0] -= MD5M_A
;
11034 digest
[1] -= MD5M_B
;
11035 digest
[2] -= MD5M_C
;
11036 digest
[3] -= MD5M_D
;
11038 return (PARSER_OK
);
11041 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11043 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
11045 u32
*digest
= (u32
*) hash_buf
->digest
;
11047 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
11048 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
11052 digest
[0] = byte_swap_32 (digest
[0]);
11053 digest
[1] = byte_swap_32 (digest
[1]);
11055 return (PARSER_OK
);
11058 int md5s_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_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
11066 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) 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] -= MD5M_A
;
11084 digest
[1] -= MD5M_B
;
11085 digest
[2] -= MD5M_C
;
11086 digest
[3] -= MD5M_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 md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11107 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
11109 u32
*digest
= (u32
*) hash_buf
->digest
;
11111 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11112 | itoa64_to_int (input_buf
[ 1]) << 6
11113 | itoa64_to_int (input_buf
[ 2]) << 12
11114 | itoa64_to_int (input_buf
[ 3]) << 18;
11115 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11116 | itoa64_to_int (input_buf
[ 5]) << 6
11117 | itoa64_to_int (input_buf
[ 6]) << 12
11118 | itoa64_to_int (input_buf
[ 7]) << 18;
11119 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11120 | itoa64_to_int (input_buf
[ 9]) << 6
11121 | itoa64_to_int (input_buf
[10]) << 12
11122 | itoa64_to_int (input_buf
[11]) << 18;
11123 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11124 | itoa64_to_int (input_buf
[13]) << 6
11125 | itoa64_to_int (input_buf
[14]) << 12
11126 | itoa64_to_int (input_buf
[15]) << 18;
11128 digest
[0] -= MD5M_A
;
11129 digest
[1] -= MD5M_B
;
11130 digest
[2] -= MD5M_C
;
11131 digest
[3] -= MD5M_D
;
11133 digest
[0] &= 0x00ffffff;
11134 digest
[1] &= 0x00ffffff;
11135 digest
[2] &= 0x00ffffff;
11136 digest
[3] &= 0x00ffffff;
11138 return (PARSER_OK
);
11141 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11143 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11145 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
11149 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
11152 u32
*digest
= (u32
*) hash_buf
->digest
;
11154 salt_t
*salt
= hash_buf
->salt
;
11156 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11157 | itoa64_to_int (input_buf
[ 1]) << 6
11158 | itoa64_to_int (input_buf
[ 2]) << 12
11159 | itoa64_to_int (input_buf
[ 3]) << 18;
11160 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11161 | itoa64_to_int (input_buf
[ 5]) << 6
11162 | itoa64_to_int (input_buf
[ 6]) << 12
11163 | itoa64_to_int (input_buf
[ 7]) << 18;
11164 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11165 | itoa64_to_int (input_buf
[ 9]) << 6
11166 | itoa64_to_int (input_buf
[10]) << 12
11167 | itoa64_to_int (input_buf
[11]) << 18;
11168 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11169 | itoa64_to_int (input_buf
[13]) << 6
11170 | itoa64_to_int (input_buf
[14]) << 12
11171 | itoa64_to_int (input_buf
[15]) << 18;
11173 digest
[0] -= MD5M_A
;
11174 digest
[1] -= MD5M_B
;
11175 digest
[2] -= MD5M_C
;
11176 digest
[3] -= MD5M_D
;
11178 digest
[0] &= 0x00ffffff;
11179 digest
[1] &= 0x00ffffff;
11180 digest
[2] &= 0x00ffffff;
11181 digest
[3] &= 0x00ffffff;
11183 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11185 uint salt_len
= input_len
- 16 - 1;
11187 char *salt_buf
= input_buf
+ 16 + 1;
11189 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11191 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11193 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11195 salt
->salt_len
= salt_len
;
11197 return (PARSER_OK
);
11200 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
11202 key
[0] = (nthash
[0] >> 0);
11203 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
11204 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
11205 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
11206 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
11207 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
11208 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
11209 key
[7] = (nthash
[6] << 1);
11221 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11223 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
11225 u32
*digest
= (u32
*) hash_buf
->digest
;
11227 salt_t
*salt
= hash_buf
->salt
;
11229 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11235 char *user_pos
= input_buf
;
11237 char *unused_pos
= strchr (user_pos
, ':');
11239 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11241 uint user_len
= unused_pos
- user_pos
;
11243 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11247 char *domain_pos
= strchr (unused_pos
, ':');
11249 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11251 uint unused_len
= domain_pos
- unused_pos
;
11253 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11257 char *srvchall_pos
= strchr (domain_pos
, ':');
11259 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11261 uint domain_len
= srvchall_pos
- domain_pos
;
11263 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11267 char *hash_pos
= strchr (srvchall_pos
, ':');
11269 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11271 uint srvchall_len
= hash_pos
- srvchall_pos
;
11273 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
11277 char *clichall_pos
= strchr (hash_pos
, ':');
11279 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11281 uint hash_len
= clichall_pos
- hash_pos
;
11283 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11287 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11289 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11292 * store some data for later use
11295 netntlm
->user_len
= user_len
* 2;
11296 netntlm
->domain_len
= domain_len
* 2;
11297 netntlm
->srvchall_len
= srvchall_len
/ 2;
11298 netntlm
->clichall_len
= clichall_len
/ 2;
11300 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11301 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11304 * handle username and domainname
11307 for (uint i
= 0; i
< user_len
; i
++)
11309 *userdomain_ptr
++ = user_pos
[i
];
11310 *userdomain_ptr
++ = 0;
11313 for (uint i
= 0; i
< domain_len
; i
++)
11315 *userdomain_ptr
++ = domain_pos
[i
];
11316 *userdomain_ptr
++ = 0;
11320 * handle server challenge encoding
11323 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11325 const char p0
= srvchall_pos
[i
+ 0];
11326 const char p1
= srvchall_pos
[i
+ 1];
11328 *chall_ptr
++ = hex_convert (p1
) << 0
11329 | hex_convert (p0
) << 4;
11333 * handle client challenge encoding
11336 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11338 const char p0
= clichall_pos
[i
+ 0];
11339 const char p1
= clichall_pos
[i
+ 1];
11341 *chall_ptr
++ = hex_convert (p1
) << 0
11342 | hex_convert (p0
) << 4;
11349 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11351 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11353 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11355 salt
->salt_len
= salt_len
;
11357 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11358 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11359 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11360 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11362 digest
[0] = byte_swap_32 (digest
[0]);
11363 digest
[1] = byte_swap_32 (digest
[1]);
11364 digest
[2] = byte_swap_32 (digest
[2]);
11365 digest
[3] = byte_swap_32 (digest
[3]);
11367 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11369 uint digest_tmp
[2] = { 0 };
11371 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11372 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11374 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11375 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11377 /* special case 2: ESS */
11379 if (srvchall_len
== 48)
11381 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11383 uint w
[16] = { 0 };
11385 w
[ 0] = netntlm
->chall_buf
[6];
11386 w
[ 1] = netntlm
->chall_buf
[7];
11387 w
[ 2] = netntlm
->chall_buf
[0];
11388 w
[ 3] = netntlm
->chall_buf
[1];
11392 uint dgst
[4] = { 0 };
11401 salt
->salt_buf
[0] = dgst
[0];
11402 salt
->salt_buf
[1] = dgst
[1];
11406 /* precompute netntlmv1 exploit start */
11408 for (uint i
= 0; i
< 0x10000; i
++)
11410 uint key_md4
[2] = { i
, 0 };
11411 uint key_des
[2] = { 0, 0 };
11413 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11415 uint Kc
[16] = { 0 };
11416 uint Kd
[16] = { 0 };
11418 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11420 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11422 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11424 if (data3
[0] != digest_tmp
[0]) continue;
11425 if (data3
[1] != digest_tmp
[1]) continue;
11427 salt
->salt_buf
[2] = i
;
11429 salt
->salt_len
= 24;
11434 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11435 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11437 /* precompute netntlmv1 exploit stop */
11441 IP (digest
[0], digest
[1], tt
);
11442 IP (digest
[2], digest
[3], tt
);
11444 digest
[0] = rotr32 (digest
[0], 29);
11445 digest
[1] = rotr32 (digest
[1], 29);
11446 digest
[2] = rotr32 (digest
[2], 29);
11447 digest
[3] = rotr32 (digest
[3], 29);
11449 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11451 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11452 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11454 return (PARSER_OK
);
11457 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11459 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11461 u32
*digest
= (u32
*) hash_buf
->digest
;
11463 salt_t
*salt
= hash_buf
->salt
;
11465 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11471 char *user_pos
= input_buf
;
11473 char *unused_pos
= strchr (user_pos
, ':');
11475 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11477 uint user_len
= unused_pos
- user_pos
;
11479 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11483 char *domain_pos
= strchr (unused_pos
, ':');
11485 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11487 uint unused_len
= domain_pos
- unused_pos
;
11489 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11493 char *srvchall_pos
= strchr (domain_pos
, ':');
11495 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11497 uint domain_len
= srvchall_pos
- domain_pos
;
11499 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11503 char *hash_pos
= strchr (srvchall_pos
, ':');
11505 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11507 uint srvchall_len
= hash_pos
- srvchall_pos
;
11509 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11513 char *clichall_pos
= strchr (hash_pos
, ':');
11515 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11517 uint hash_len
= clichall_pos
- hash_pos
;
11519 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11523 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11525 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11527 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11530 * store some data for later use
11533 netntlm
->user_len
= user_len
* 2;
11534 netntlm
->domain_len
= domain_len
* 2;
11535 netntlm
->srvchall_len
= srvchall_len
/ 2;
11536 netntlm
->clichall_len
= clichall_len
/ 2;
11538 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11539 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11542 * handle username and domainname
11545 for (uint i
= 0; i
< user_len
; i
++)
11547 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11548 *userdomain_ptr
++ = 0;
11551 for (uint i
= 0; i
< domain_len
; i
++)
11553 *userdomain_ptr
++ = domain_pos
[i
];
11554 *userdomain_ptr
++ = 0;
11557 *userdomain_ptr
++ = 0x80;
11560 * handle server challenge encoding
11563 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11565 const char p0
= srvchall_pos
[i
+ 0];
11566 const char p1
= srvchall_pos
[i
+ 1];
11568 *chall_ptr
++ = hex_convert (p1
) << 0
11569 | hex_convert (p0
) << 4;
11573 * handle client challenge encoding
11576 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11578 const char p0
= clichall_pos
[i
+ 0];
11579 const char p1
= clichall_pos
[i
+ 1];
11581 *chall_ptr
++ = hex_convert (p1
) << 0
11582 | hex_convert (p0
) << 4;
11585 *chall_ptr
++ = 0x80;
11588 * handle hash itself
11591 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11592 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11593 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11594 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11596 digest
[0] = byte_swap_32 (digest
[0]);
11597 digest
[1] = byte_swap_32 (digest
[1]);
11598 digest
[2] = byte_swap_32 (digest
[2]);
11599 digest
[3] = byte_swap_32 (digest
[3]);
11602 * reuse challange data as salt_buf, its the buffer that is most likely unique
11605 salt
->salt_buf
[0] = 0;
11606 salt
->salt_buf
[1] = 0;
11607 salt
->salt_buf
[2] = 0;
11608 salt
->salt_buf
[3] = 0;
11609 salt
->salt_buf
[4] = 0;
11610 salt
->salt_buf
[5] = 0;
11611 salt
->salt_buf
[6] = 0;
11612 salt
->salt_buf
[7] = 0;
11616 uptr
= (uint
*) netntlm
->userdomain_buf
;
11618 for (uint i
= 0; i
< 16; i
+= 16)
11620 md5_64 (uptr
, salt
->salt_buf
);
11623 uptr
= (uint
*) netntlm
->chall_buf
;
11625 for (uint i
= 0; i
< 256; i
+= 16)
11627 md5_64 (uptr
, salt
->salt_buf
);
11630 salt
->salt_len
= 16;
11632 return (PARSER_OK
);
11635 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11637 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11639 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11643 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11646 u32
*digest
= (u32
*) hash_buf
->digest
;
11648 salt_t
*salt
= hash_buf
->salt
;
11650 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11651 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11652 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11653 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11655 digest
[0] = byte_swap_32 (digest
[0]);
11656 digest
[1] = byte_swap_32 (digest
[1]);
11657 digest
[2] = byte_swap_32 (digest
[2]);
11658 digest
[3] = byte_swap_32 (digest
[3]);
11660 digest
[0] -= MD5M_A
;
11661 digest
[1] -= MD5M_B
;
11662 digest
[2] -= MD5M_C
;
11663 digest
[3] -= MD5M_D
;
11665 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11667 uint salt_len
= input_len
- 32 - 1;
11669 char *salt_buf
= input_buf
+ 32 + 1;
11671 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11673 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11675 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11677 salt
->salt_len
= salt_len
;
11679 return (PARSER_OK
);
11682 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11684 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11686 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11690 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11693 u32
*digest
= (u32
*) hash_buf
->digest
;
11695 salt_t
*salt
= hash_buf
->salt
;
11697 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11698 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11699 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11700 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11702 digest
[0] = byte_swap_32 (digest
[0]);
11703 digest
[1] = byte_swap_32 (digest
[1]);
11704 digest
[2] = byte_swap_32 (digest
[2]);
11705 digest
[3] = byte_swap_32 (digest
[3]);
11707 digest
[0] -= MD5M_A
;
11708 digest
[1] -= MD5M_B
;
11709 digest
[2] -= MD5M_C
;
11710 digest
[3] -= MD5M_D
;
11712 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11714 uint salt_len
= input_len
- 32 - 1;
11716 char *salt_buf
= input_buf
+ 32 + 1;
11718 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11720 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11722 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11724 salt
->salt_len
= salt_len
;
11726 return (PARSER_OK
);
11729 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11731 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11733 u32
*digest
= (u32
*) hash_buf
->digest
;
11735 salt_t
*salt
= hash_buf
->salt
;
11737 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11738 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11739 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11740 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11742 digest
[0] = byte_swap_32 (digest
[0]);
11743 digest
[1] = byte_swap_32 (digest
[1]);
11744 digest
[2] = byte_swap_32 (digest
[2]);
11745 digest
[3] = byte_swap_32 (digest
[3]);
11747 digest
[0] -= MD5M_A
;
11748 digest
[1] -= MD5M_B
;
11749 digest
[2] -= MD5M_C
;
11750 digest
[3] -= MD5M_D
;
11753 * This is a virtual salt. While the algorithm is basically not salted
11754 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11755 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11758 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11760 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11762 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11764 salt
->salt_len
= salt_len
;
11766 return (PARSER_OK
);
11769 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11771 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11773 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11777 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11780 u32
*digest
= (u32
*) hash_buf
->digest
;
11782 salt_t
*salt
= hash_buf
->salt
;
11784 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11785 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11786 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11787 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11789 digest
[0] = byte_swap_32 (digest
[0]);
11790 digest
[1] = byte_swap_32 (digest
[1]);
11791 digest
[2] = byte_swap_32 (digest
[2]);
11792 digest
[3] = byte_swap_32 (digest
[3]);
11794 digest
[0] -= MD5M_A
;
11795 digest
[1] -= MD5M_B
;
11796 digest
[2] -= MD5M_C
;
11797 digest
[3] -= MD5M_D
;
11799 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11801 uint salt_len
= input_len
- 32 - 1;
11803 char *salt_buf
= input_buf
+ 32 + 1;
11805 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11807 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11809 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11811 salt
->salt_len
= salt_len
;
11813 return (PARSER_OK
);
11816 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11818 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11820 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11824 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11827 u32
*digest
= (u32
*) hash_buf
->digest
;
11829 salt_t
*salt
= hash_buf
->salt
;
11831 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11832 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11833 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11834 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11836 digest
[0] = byte_swap_32 (digest
[0]);
11837 digest
[1] = byte_swap_32 (digest
[1]);
11838 digest
[2] = byte_swap_32 (digest
[2]);
11839 digest
[3] = byte_swap_32 (digest
[3]);
11841 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11843 uint salt_len
= input_len
- 32 - 1;
11845 char *salt_buf
= input_buf
+ 32 + 1;
11847 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11849 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11851 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11853 salt
->salt_len
= salt_len
;
11855 return (PARSER_OK
);
11858 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11860 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11862 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11866 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11869 u32
*digest
= (u32
*) hash_buf
->digest
;
11871 salt_t
*salt
= hash_buf
->salt
;
11873 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11874 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11875 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11876 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11878 digest
[0] = byte_swap_32 (digest
[0]);
11879 digest
[1] = byte_swap_32 (digest
[1]);
11880 digest
[2] = byte_swap_32 (digest
[2]);
11881 digest
[3] = byte_swap_32 (digest
[3]);
11883 digest
[0] -= MD4M_A
;
11884 digest
[1] -= MD4M_B
;
11885 digest
[2] -= MD4M_C
;
11886 digest
[3] -= MD4M_D
;
11888 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11890 uint salt_len
= input_len
- 32 - 1;
11892 char *salt_buf
= input_buf
+ 32 + 1;
11894 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11896 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11898 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11900 salt
->salt_len
= salt_len
;
11902 return (PARSER_OK
);
11905 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11907 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11909 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11913 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11916 u32
*digest
= (u32
*) hash_buf
->digest
;
11918 salt_t
*salt
= hash_buf
->salt
;
11920 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11921 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11922 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11923 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11925 digest
[0] = byte_swap_32 (digest
[0]);
11926 digest
[1] = byte_swap_32 (digest
[1]);
11927 digest
[2] = byte_swap_32 (digest
[2]);
11928 digest
[3] = byte_swap_32 (digest
[3]);
11930 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11932 uint salt_len
= input_len
- 32 - 1;
11934 char *salt_buf
= input_buf
+ 32 + 1;
11936 uint salt_pc_block
[16] = { 0 };
11938 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11940 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11942 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11944 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11946 salt_pc_block
[14] = salt_len
* 8;
11948 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11950 md5_64 (salt_pc_block
, salt_pc_digest
);
11952 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11953 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11954 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11955 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11957 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11959 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11961 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11963 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11964 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11965 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11966 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11968 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11970 return (PARSER_OK
);
11973 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11975 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11977 u32
*digest
= (u32
*) hash_buf
->digest
;
11979 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11980 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11981 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11982 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11983 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11985 digest
[0] -= SHA1M_A
;
11986 digest
[1] -= SHA1M_B
;
11987 digest
[2] -= SHA1M_C
;
11988 digest
[3] -= SHA1M_D
;
11989 digest
[4] -= SHA1M_E
;
11991 return (PARSER_OK
);
11994 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11996 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11998 u32
*digest
= (u32
*) hash_buf
->digest
;
12000 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12001 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12002 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12003 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12004 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12006 return (PARSER_OK
);
12009 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12011 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
12013 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
12015 u32
*digest
= (u32
*) hash_buf
->digest
;
12019 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12020 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12021 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12022 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12025 return (PARSER_OK
);
12028 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12030 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12032 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
12036 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
12039 u32
*digest
= (u32
*) hash_buf
->digest
;
12041 salt_t
*salt
= hash_buf
->salt
;
12043 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12044 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12045 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12046 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12047 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12049 digest
[0] -= SHA1M_A
;
12050 digest
[1] -= SHA1M_B
;
12051 digest
[2] -= SHA1M_C
;
12052 digest
[3] -= SHA1M_D
;
12053 digest
[4] -= SHA1M_E
;
12055 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12057 uint salt_len
= input_len
- 40 - 1;
12059 char *salt_buf
= input_buf
+ 40 + 1;
12061 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12063 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12065 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12067 salt
->salt_len
= salt_len
;
12069 return (PARSER_OK
);
12072 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12074 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
12076 u32
*digest
= (u32
*) hash_buf
->digest
;
12078 salt_t
*salt
= hash_buf
->salt
;
12080 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
12082 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12083 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12084 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12085 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12086 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12088 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12090 uint salt_len
= input_len
- 40 - 1;
12092 char *salt_buf
= input_buf
+ 40 + 1;
12094 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
12096 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
12098 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
12100 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
12103 pstoken
->salt_len
= salt_len
/ 2;
12105 /* some fake salt for the sorting mechanisms */
12107 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
12108 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
12109 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
12110 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
12111 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
12112 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
12113 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
12114 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
12116 salt
->salt_len
= 32;
12118 /* we need to check if we can precompute some of the data --
12119 this is possible since the scheme is badly designed */
12121 pstoken
->pc_digest
[0] = SHA1M_A
;
12122 pstoken
->pc_digest
[1] = SHA1M_B
;
12123 pstoken
->pc_digest
[2] = SHA1M_C
;
12124 pstoken
->pc_digest
[3] = SHA1M_D
;
12125 pstoken
->pc_digest
[4] = SHA1M_E
;
12127 pstoken
->pc_offset
= 0;
12129 for (int i
= 0; i
< (int) pstoken
->salt_len
- 63; i
+= 64)
12133 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
12134 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
12135 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
12136 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
12137 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
12138 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
12139 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
12140 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
12141 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
12142 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
12143 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
12144 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
12145 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
12146 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
12147 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
12148 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
12150 sha1_64 (w
, pstoken
->pc_digest
);
12152 pstoken
->pc_offset
+= 16;
12155 return (PARSER_OK
);
12158 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12160 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
12162 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
12164 u32
*digest
= (u32
*) hash_buf
->digest
;
12166 u8 tmp_buf
[100] = { 0 };
12168 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
12170 memcpy (digest
, tmp_buf
, 20);
12172 digest
[0] = byte_swap_32 (digest
[0]);
12173 digest
[1] = byte_swap_32 (digest
[1]);
12174 digest
[2] = byte_swap_32 (digest
[2]);
12175 digest
[3] = byte_swap_32 (digest
[3]);
12176 digest
[4] = byte_swap_32 (digest
[4]);
12178 digest
[0] -= SHA1M_A
;
12179 digest
[1] -= SHA1M_B
;
12180 digest
[2] -= SHA1M_C
;
12181 digest
[3] -= SHA1M_D
;
12182 digest
[4] -= SHA1M_E
;
12184 return (PARSER_OK
);
12187 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12189 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
12191 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12193 u32
*digest
= (u32
*) hash_buf
->digest
;
12195 salt_t
*salt
= hash_buf
->salt
;
12197 u8 tmp_buf
[100] = { 0 };
12199 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
12201 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
12203 memcpy (digest
, tmp_buf
, 20);
12205 int salt_len
= tmp_len
- 20;
12207 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
12209 salt
->salt_len
= salt_len
;
12211 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
12213 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12215 char *ptr
= (char *) salt
->salt_buf
;
12217 ptr
[salt
->salt_len
] = 0x80;
12220 digest
[0] = byte_swap_32 (digest
[0]);
12221 digest
[1] = byte_swap_32 (digest
[1]);
12222 digest
[2] = byte_swap_32 (digest
[2]);
12223 digest
[3] = byte_swap_32 (digest
[3]);
12224 digest
[4] = byte_swap_32 (digest
[4]);
12226 digest
[0] -= SHA1M_A
;
12227 digest
[1] -= SHA1M_B
;
12228 digest
[2] -= SHA1M_C
;
12229 digest
[3] -= SHA1M_D
;
12230 digest
[4] -= SHA1M_E
;
12232 return (PARSER_OK
);
12235 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12237 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
12239 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12241 u32
*digest
= (u32
*) hash_buf
->digest
;
12243 salt_t
*salt
= hash_buf
->salt
;
12245 char *salt_buf
= input_buf
+ 6;
12249 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12251 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12253 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12255 salt
->salt_len
= salt_len
;
12257 char *hash_pos
= input_buf
+ 6 + 8 + 40;
12259 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12260 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12261 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12262 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12263 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12265 digest
[0] -= SHA1M_A
;
12266 digest
[1] -= SHA1M_B
;
12267 digest
[2] -= SHA1M_C
;
12268 digest
[3] -= SHA1M_D
;
12269 digest
[4] -= SHA1M_E
;
12271 return (PARSER_OK
);
12274 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12276 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
12278 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12280 u32
*digest
= (u32
*) hash_buf
->digest
;
12282 salt_t
*salt
= hash_buf
->salt
;
12284 char *salt_buf
= input_buf
+ 6;
12288 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12290 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12292 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12294 salt
->salt_len
= salt_len
;
12296 char *hash_pos
= input_buf
+ 6 + 8;
12298 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12299 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12300 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12301 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12302 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12304 digest
[0] -= SHA1M_A
;
12305 digest
[1] -= SHA1M_B
;
12306 digest
[2] -= SHA1M_C
;
12307 digest
[3] -= SHA1M_D
;
12308 digest
[4] -= SHA1M_E
;
12310 return (PARSER_OK
);
12313 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12315 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12317 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12319 u64
*digest
= (u64
*) hash_buf
->digest
;
12321 salt_t
*salt
= hash_buf
->salt
;
12323 char *salt_buf
= input_buf
+ 6;
12327 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12329 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12331 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12333 salt
->salt_len
= salt_len
;
12335 char *hash_pos
= input_buf
+ 6 + 8;
12337 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12338 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12339 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12340 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12341 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12342 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12343 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12344 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12346 digest
[0] -= SHA512M_A
;
12347 digest
[1] -= SHA512M_B
;
12348 digest
[2] -= SHA512M_C
;
12349 digest
[3] -= SHA512M_D
;
12350 digest
[4] -= SHA512M_E
;
12351 digest
[5] -= SHA512M_F
;
12352 digest
[6] -= SHA512M_G
;
12353 digest
[7] -= SHA512M_H
;
12355 return (PARSER_OK
);
12358 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12360 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12362 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12366 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12369 u32
*digest
= (u32
*) hash_buf
->digest
;
12371 salt_t
*salt
= hash_buf
->salt
;
12373 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12374 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12378 digest
[0] = byte_swap_32 (digest
[0]);
12379 digest
[1] = byte_swap_32 (digest
[1]);
12381 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12383 uint salt_len
= input_len
- 16 - 1;
12385 char *salt_buf
= input_buf
+ 16 + 1;
12387 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12389 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12391 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12393 salt
->salt_len
= salt_len
;
12395 return (PARSER_OK
);
12398 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12400 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12402 u32
*digest
= (u32
*) hash_buf
->digest
;
12404 salt_t
*salt
= hash_buf
->salt
;
12406 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12407 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12408 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12409 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12410 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12412 digest
[0] -= SHA1M_A
;
12413 digest
[1] -= SHA1M_B
;
12414 digest
[2] -= SHA1M_C
;
12415 digest
[3] -= SHA1M_D
;
12416 digest
[4] -= SHA1M_E
;
12418 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12420 uint salt_len
= input_len
- 40 - 1;
12422 char *salt_buf
= input_buf
+ 40 + 1;
12424 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12426 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12428 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12430 salt
->salt_len
= salt_len
;
12432 return (PARSER_OK
);
12435 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12437 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12439 u32
*digest
= (u32
*) hash_buf
->digest
;
12441 salt_t
*salt
= hash_buf
->salt
;
12443 char *hash_pos
= input_buf
;
12445 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12446 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12447 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12448 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12449 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12450 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12451 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12452 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12453 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12454 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12455 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12456 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12457 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12458 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12459 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12460 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12462 char *salt_pos
= input_buf
+ 128;
12464 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12465 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12466 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12467 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12469 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12470 salt
->salt_len
= 16;
12472 return (PARSER_OK
);
12475 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12477 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12479 u32
*digest
= (u32
*) hash_buf
->digest
;
12481 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12482 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12483 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12484 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12485 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12486 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12487 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12488 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12490 digest
[0] -= SHA256M_A
;
12491 digest
[1] -= SHA256M_B
;
12492 digest
[2] -= SHA256M_C
;
12493 digest
[3] -= SHA256M_D
;
12494 digest
[4] -= SHA256M_E
;
12495 digest
[5] -= SHA256M_F
;
12496 digest
[6] -= SHA256M_G
;
12497 digest
[7] -= SHA256M_H
;
12499 return (PARSER_OK
);
12502 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12504 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12506 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12510 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12513 u32
*digest
= (u32
*) hash_buf
->digest
;
12515 salt_t
*salt
= hash_buf
->salt
;
12517 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12518 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12519 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12520 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12521 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12522 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12523 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12524 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12526 digest
[0] -= SHA256M_A
;
12527 digest
[1] -= SHA256M_B
;
12528 digest
[2] -= SHA256M_C
;
12529 digest
[3] -= SHA256M_D
;
12530 digest
[4] -= SHA256M_E
;
12531 digest
[5] -= SHA256M_F
;
12532 digest
[6] -= SHA256M_G
;
12533 digest
[7] -= SHA256M_H
;
12535 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12537 uint salt_len
= input_len
- 64 - 1;
12539 char *salt_buf
= input_buf
+ 64 + 1;
12541 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12543 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12545 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12547 salt
->salt_len
= salt_len
;
12549 return (PARSER_OK
);
12552 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12554 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12556 u64
*digest
= (u64
*) hash_buf
->digest
;
12558 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12559 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12560 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12561 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12562 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12563 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12567 digest
[0] -= SHA384M_A
;
12568 digest
[1] -= SHA384M_B
;
12569 digest
[2] -= SHA384M_C
;
12570 digest
[3] -= SHA384M_D
;
12571 digest
[4] -= SHA384M_E
;
12572 digest
[5] -= SHA384M_F
;
12576 return (PARSER_OK
);
12579 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12581 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12583 u64
*digest
= (u64
*) hash_buf
->digest
;
12585 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12586 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12587 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12588 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12589 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12590 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12591 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12592 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12594 digest
[0] -= SHA512M_A
;
12595 digest
[1] -= SHA512M_B
;
12596 digest
[2] -= SHA512M_C
;
12597 digest
[3] -= SHA512M_D
;
12598 digest
[4] -= SHA512M_E
;
12599 digest
[5] -= SHA512M_F
;
12600 digest
[6] -= SHA512M_G
;
12601 digest
[7] -= SHA512M_H
;
12603 return (PARSER_OK
);
12606 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12608 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12610 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12614 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12617 u64
*digest
= (u64
*) hash_buf
->digest
;
12619 salt_t
*salt
= hash_buf
->salt
;
12621 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12622 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12623 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12624 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12625 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12626 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12627 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12628 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12630 digest
[0] -= SHA512M_A
;
12631 digest
[1] -= SHA512M_B
;
12632 digest
[2] -= SHA512M_C
;
12633 digest
[3] -= SHA512M_D
;
12634 digest
[4] -= SHA512M_E
;
12635 digest
[5] -= SHA512M_F
;
12636 digest
[6] -= SHA512M_G
;
12637 digest
[7] -= SHA512M_H
;
12639 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12641 uint salt_len
= input_len
- 128 - 1;
12643 char *salt_buf
= input_buf
+ 128 + 1;
12645 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12647 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12649 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12651 salt
->salt_len
= salt_len
;
12653 return (PARSER_OK
);
12656 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12658 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12660 u64
*digest
= (u64
*) hash_buf
->digest
;
12662 salt_t
*salt
= hash_buf
->salt
;
12664 char *salt_pos
= input_buf
+ 3;
12666 uint iterations_len
= 0;
12668 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12672 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12674 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12675 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12679 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12683 iterations_len
+= 8;
12687 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12690 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12692 char *hash_pos
= strchr (salt_pos
, '$');
12694 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12696 uint salt_len
= hash_pos
- salt_pos
;
12698 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12700 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12702 salt
->salt_len
= salt_len
;
12706 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12708 return (PARSER_OK
);
12711 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12713 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12715 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12717 u64
*digest
= (u64
*) hash_buf
->digest
;
12719 salt_t
*salt
= hash_buf
->salt
;
12721 uint keccak_mdlen
= input_len
/ 2;
12723 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12725 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12727 digest
[i
] = byte_swap_64 (digest
[i
]);
12730 salt
->keccak_mdlen
= keccak_mdlen
;
12732 return (PARSER_OK
);
12735 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12737 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12739 u32
*digest
= (u32
*) hash_buf
->digest
;
12741 salt_t
*salt
= hash_buf
->salt
;
12743 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12746 * Parse that strange long line
12751 size_t in_len
[9] = { 0 };
12753 in_off
[0] = strtok (input_buf
, ":");
12755 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12757 in_len
[0] = strlen (in_off
[0]);
12761 for (i
= 1; i
< 9; i
++)
12763 in_off
[i
] = strtok (NULL
, ":");
12765 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12767 in_len
[i
] = strlen (in_off
[i
]);
12770 char *ptr
= (char *) ikepsk
->msg_buf
;
12772 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12773 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12774 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12775 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12776 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12777 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12781 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12783 ptr
= (char *) ikepsk
->nr_buf
;
12785 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12786 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12790 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12793 * Store to database
12798 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12799 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12800 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12801 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12803 digest
[0] = byte_swap_32 (digest
[0]);
12804 digest
[1] = byte_swap_32 (digest
[1]);
12805 digest
[2] = byte_swap_32 (digest
[2]);
12806 digest
[3] = byte_swap_32 (digest
[3]);
12808 salt
->salt_len
= 32;
12810 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12811 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12812 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12813 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12814 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12815 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12816 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12817 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12819 return (PARSER_OK
);
12822 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12824 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12826 u32
*digest
= (u32
*) hash_buf
->digest
;
12828 salt_t
*salt
= hash_buf
->salt
;
12830 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12833 * Parse that strange long line
12838 size_t in_len
[9] = { 0 };
12840 in_off
[0] = strtok (input_buf
, ":");
12842 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12844 in_len
[0] = strlen (in_off
[0]);
12848 for (i
= 1; i
< 9; i
++)
12850 in_off
[i
] = strtok (NULL
, ":");
12852 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12854 in_len
[i
] = strlen (in_off
[i
]);
12857 char *ptr
= (char *) ikepsk
->msg_buf
;
12859 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12860 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12861 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12862 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12863 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12864 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12868 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12870 ptr
= (char *) ikepsk
->nr_buf
;
12872 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12873 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12877 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12880 * Store to database
12885 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12886 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12887 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12888 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12889 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12891 salt
->salt_len
= 32;
12893 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12894 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12895 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12896 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12897 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12898 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12899 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12900 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12902 return (PARSER_OK
);
12905 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12907 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12909 u32
*digest
= (u32
*) hash_buf
->digest
;
12911 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12912 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12913 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12914 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12915 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12917 digest
[0] = byte_swap_32 (digest
[0]);
12918 digest
[1] = byte_swap_32 (digest
[1]);
12919 digest
[2] = byte_swap_32 (digest
[2]);
12920 digest
[3] = byte_swap_32 (digest
[3]);
12921 digest
[4] = byte_swap_32 (digest
[4]);
12923 return (PARSER_OK
);
12926 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12928 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12930 u32
*digest
= (u32
*) hash_buf
->digest
;
12932 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12933 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12934 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12935 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12936 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12937 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12938 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12939 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12940 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12941 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12942 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12943 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12944 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12945 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12946 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12947 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12949 return (PARSER_OK
);
12952 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12954 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12956 u32
*digest
= (u32
*) hash_buf
->digest
;
12958 salt_t
*salt
= hash_buf
->salt
;
12960 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12961 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12962 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12963 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12964 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12966 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12968 uint salt_len
= input_len
- 40 - 1;
12970 char *salt_buf
= input_buf
+ 40 + 1;
12972 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12974 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12976 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12978 salt
->salt_len
= salt_len
;
12980 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12982 return (PARSER_OK
);
12985 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12987 u32
*digest
= (u32
*) hash_buf
->digest
;
12989 salt_t
*salt
= hash_buf
->salt
;
12991 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12993 if (input_len
== 0)
12995 log_error ("TrueCrypt container not specified");
13000 FILE *fp
= fopen (input_buf
, "rb");
13004 log_error ("%s: %s", input_buf
, strerror (errno
));
13009 char buf
[512] = { 0 };
13011 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13015 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13017 memcpy (tc
->salt_buf
, buf
, 64);
13019 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13021 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13023 salt
->salt_len
= 4;
13025 salt
->salt_iter
= ROUNDS_TRUECRYPT_1K
- 1;
13027 tc
->signature
= 0x45555254; // "TRUE"
13029 digest
[0] = tc
->data_buf
[0];
13031 return (PARSER_OK
);
13034 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13036 u32
*digest
= (u32
*) hash_buf
->digest
;
13038 salt_t
*salt
= hash_buf
->salt
;
13040 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13042 if (input_len
== 0)
13044 log_error ("TrueCrypt container not specified");
13049 FILE *fp
= fopen (input_buf
, "rb");
13053 log_error ("%s: %s", input_buf
, strerror (errno
));
13058 char buf
[512] = { 0 };
13060 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13064 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13066 memcpy (tc
->salt_buf
, buf
, 64);
13068 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13070 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13072 salt
->salt_len
= 4;
13074 salt
->salt_iter
= ROUNDS_TRUECRYPT_2K
- 1;
13076 tc
->signature
= 0x45555254; // "TRUE"
13078 digest
[0] = tc
->data_buf
[0];
13080 return (PARSER_OK
);
13083 int veracrypt_parse_hash_200000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13085 u32
*digest
= (u32
*) hash_buf
->digest
;
13087 salt_t
*salt
= hash_buf
->salt
;
13089 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13091 if (input_len
== 0)
13093 log_error ("VeraCrypt container not specified");
13098 FILE *fp
= fopen (input_buf
, "rb");
13102 log_error ("%s: %s", input_buf
, strerror (errno
));
13107 char buf
[512] = { 0 };
13109 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13113 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13115 memcpy (tc
->salt_buf
, buf
, 64);
13117 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13119 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13121 salt
->salt_len
= 4;
13123 salt
->salt_iter
= ROUNDS_VERACRYPT_200000
- 1;
13125 tc
->signature
= 0x41524556; // "VERA"
13127 digest
[0] = tc
->data_buf
[0];
13129 return (PARSER_OK
);
13132 int veracrypt_parse_hash_500000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13134 u32
*digest
= (u32
*) hash_buf
->digest
;
13136 salt_t
*salt
= hash_buf
->salt
;
13138 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13140 if (input_len
== 0)
13142 log_error ("VeraCrypt container not specified");
13147 FILE *fp
= fopen (input_buf
, "rb");
13151 log_error ("%s: %s", input_buf
, strerror (errno
));
13156 char buf
[512] = { 0 };
13158 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13162 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13164 memcpy (tc
->salt_buf
, buf
, 64);
13166 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13168 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13170 salt
->salt_len
= 4;
13172 salt
->salt_iter
= ROUNDS_VERACRYPT_500000
- 1;
13174 tc
->signature
= 0x41524556; // "VERA"
13176 digest
[0] = tc
->data_buf
[0];
13178 return (PARSER_OK
);
13181 int veracrypt_parse_hash_327661 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13183 u32
*digest
= (u32
*) hash_buf
->digest
;
13185 salt_t
*salt
= hash_buf
->salt
;
13187 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13189 if (input_len
== 0)
13191 log_error ("VeraCrypt container not specified");
13196 FILE *fp
= fopen (input_buf
, "rb");
13200 log_error ("%s: %s", input_buf
, strerror (errno
));
13205 char buf
[512] = { 0 };
13207 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13211 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13213 memcpy (tc
->salt_buf
, buf
, 64);
13215 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13217 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13219 salt
->salt_len
= 4;
13221 salt
->salt_iter
= ROUNDS_VERACRYPT_327661
- 1;
13223 tc
->signature
= 0x41524556; // "VERA"
13225 digest
[0] = tc
->data_buf
[0];
13227 return (PARSER_OK
);
13230 int veracrypt_parse_hash_655331 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13232 u32
*digest
= (u32
*) hash_buf
->digest
;
13234 salt_t
*salt
= hash_buf
->salt
;
13236 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13238 if (input_len
== 0)
13240 log_error ("VeraCrypt container not specified");
13245 FILE *fp
= fopen (input_buf
, "rb");
13249 log_error ("%s: %s", input_buf
, strerror (errno
));
13254 char buf
[512] = { 0 };
13256 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13260 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13262 memcpy (tc
->salt_buf
, buf
, 64);
13264 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13266 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13268 salt
->salt_len
= 4;
13270 salt
->salt_iter
= ROUNDS_VERACRYPT_655331
- 1;
13272 tc
->signature
= 0x41524556; // "VERA"
13274 digest
[0] = tc
->data_buf
[0];
13276 return (PARSER_OK
);
13279 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13281 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
13283 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13285 u32
*digest
= (u32
*) hash_buf
->digest
;
13287 salt_t
*salt
= hash_buf
->salt
;
13289 char *salt_pos
= input_buf
+ 6;
13291 char *hash_pos
= strchr (salt_pos
, '$');
13293 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13295 uint salt_len
= hash_pos
- salt_pos
;
13297 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
13299 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13301 salt
->salt_len
= salt_len
;
13303 salt
->salt_iter
= 1000;
13307 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13309 return (PARSER_OK
);
13312 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13314 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
13316 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
13318 u32
*digest
= (u32
*) hash_buf
->digest
;
13320 salt_t
*salt
= hash_buf
->salt
;
13322 char *iter_pos
= input_buf
+ 7;
13324 char *salt_pos
= strchr (iter_pos
, '$');
13326 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13330 char *hash_pos
= strchr (salt_pos
, '$');
13332 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13334 uint salt_len
= hash_pos
- salt_pos
;
13336 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13338 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13340 salt
->salt_len
= salt_len
;
13342 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13344 salt
->salt_sign
[0] = atoi (salt_iter
);
13346 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13350 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13352 digest
[0] = byte_swap_32 (digest
[0]);
13353 digest
[1] = byte_swap_32 (digest
[1]);
13354 digest
[2] = byte_swap_32 (digest
[2]);
13355 digest
[3] = byte_swap_32 (digest
[3]);
13356 digest
[4] = byte_swap_32 (digest
[4]);
13358 return (PARSER_OK
);
13361 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13363 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
13365 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13367 u32
*digest
= (u32
*) hash_buf
->digest
;
13369 salt_t
*salt
= hash_buf
->salt
;
13371 char *iter_pos
= input_buf
+ 9;
13373 char *salt_pos
= strchr (iter_pos
, '$');
13375 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13379 char *hash_pos
= strchr (salt_pos
, '$');
13381 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13383 uint salt_len
= hash_pos
- salt_pos
;
13385 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13387 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13389 salt
->salt_len
= salt_len
;
13391 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13393 salt
->salt_sign
[0] = atoi (salt_iter
);
13395 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13399 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13401 digest
[0] = byte_swap_32 (digest
[0]);
13402 digest
[1] = byte_swap_32 (digest
[1]);
13403 digest
[2] = byte_swap_32 (digest
[2]);
13404 digest
[3] = byte_swap_32 (digest
[3]);
13405 digest
[4] = byte_swap_32 (digest
[4]);
13406 digest
[5] = byte_swap_32 (digest
[5]);
13407 digest
[6] = byte_swap_32 (digest
[6]);
13408 digest
[7] = byte_swap_32 (digest
[7]);
13410 return (PARSER_OK
);
13413 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13415 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
13417 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13419 u64
*digest
= (u64
*) hash_buf
->digest
;
13421 salt_t
*salt
= hash_buf
->salt
;
13423 char *iter_pos
= input_buf
+ 9;
13425 char *salt_pos
= strchr (iter_pos
, '$');
13427 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13431 char *hash_pos
= strchr (salt_pos
, '$');
13433 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13435 uint salt_len
= hash_pos
- salt_pos
;
13437 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13439 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13441 salt
->salt_len
= salt_len
;
13443 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13445 salt
->salt_sign
[0] = atoi (salt_iter
);
13447 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13451 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13453 digest
[0] = byte_swap_64 (digest
[0]);
13454 digest
[1] = byte_swap_64 (digest
[1]);
13455 digest
[2] = byte_swap_64 (digest
[2]);
13456 digest
[3] = byte_swap_64 (digest
[3]);
13457 digest
[4] = byte_swap_64 (digest
[4]);
13458 digest
[5] = byte_swap_64 (digest
[5]);
13459 digest
[6] = byte_swap_64 (digest
[6]);
13460 digest
[7] = byte_swap_64 (digest
[7]);
13462 return (PARSER_OK
);
13465 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13467 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
13469 u32
*digest
= (u32
*) hash_buf
->digest
;
13471 salt_t
*salt
= hash_buf
->salt
;
13473 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
13479 char *iterations_pos
= input_buf
;
13481 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13483 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13485 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13487 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13491 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13493 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13495 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13497 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13499 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13501 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13506 * pbkdf2 iterations
13509 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13512 * handle salt encoding
13515 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13517 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13519 const char p0
= saltbuf_pos
[i
+ 0];
13520 const char p1
= saltbuf_pos
[i
+ 1];
13522 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13523 | hex_convert (p0
) << 4;
13526 salt
->salt_len
= saltbuf_len
/ 2;
13529 * handle cipher encoding
13532 uint
*tmp
= (uint
*) mymalloc (32);
13534 char *cipherbuf_ptr
= (char *) tmp
;
13536 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13538 const char p0
= cipherbuf_pos
[i
+ 0];
13539 const char p1
= cipherbuf_pos
[i
+ 1];
13541 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13542 | hex_convert (p0
) << 4;
13545 // iv is stored at salt_buf 4 (length 16)
13546 // data is stored at salt_buf 8 (length 16)
13548 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13549 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13550 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13551 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13553 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13554 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13555 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13556 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13560 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13562 const char p0
= cipherbuf_pos
[j
+ 0];
13563 const char p1
= cipherbuf_pos
[j
+ 1];
13565 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13566 | hex_convert (p0
) << 4;
13573 digest
[0] = 0x10101010;
13574 digest
[1] = 0x10101010;
13575 digest
[2] = 0x10101010;
13576 digest
[3] = 0x10101010;
13578 return (PARSER_OK
);
13581 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13583 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13585 u32
*digest
= (u32
*) hash_buf
->digest
;
13587 salt_t
*salt
= hash_buf
->salt
;
13589 char *hashbuf_pos
= input_buf
;
13591 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13593 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13595 uint hash_len
= iterations_pos
- hashbuf_pos
;
13597 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13601 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13603 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13605 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13609 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13611 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13613 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13615 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13617 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13619 salt
->salt_len
= salt_len
;
13621 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13623 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13624 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13625 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13626 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13628 return (PARSER_OK
);
13631 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13633 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13635 u32
*digest
= (u32
*) hash_buf
->digest
;
13637 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13638 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13639 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13640 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13641 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13642 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13643 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13644 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13646 digest
[0] = byte_swap_32 (digest
[0]);
13647 digest
[1] = byte_swap_32 (digest
[1]);
13648 digest
[2] = byte_swap_32 (digest
[2]);
13649 digest
[3] = byte_swap_32 (digest
[3]);
13650 digest
[4] = byte_swap_32 (digest
[4]);
13651 digest
[5] = byte_swap_32 (digest
[5]);
13652 digest
[6] = byte_swap_32 (digest
[6]);
13653 digest
[7] = byte_swap_32 (digest
[7]);
13655 return (PARSER_OK
);
13658 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13660 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13662 u32
*digest
= (u32
*) hash_buf
->digest
;
13664 salt_t
*salt
= hash_buf
->salt
;
13666 char *salt_pos
= input_buf
+ 3;
13668 uint iterations_len
= 0;
13670 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13674 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13676 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13677 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13681 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13685 iterations_len
+= 8;
13689 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13692 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13694 char *hash_pos
= strchr (salt_pos
, '$');
13696 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13698 uint salt_len
= hash_pos
- salt_pos
;
13700 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13702 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13704 salt
->salt_len
= salt_len
;
13708 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13710 return (PARSER_OK
);
13713 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13715 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13717 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13719 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13721 u64
*digest
= (u64
*) hash_buf
->digest
;
13723 salt_t
*salt
= hash_buf
->salt
;
13725 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13727 char *iter_pos
= input_buf
+ 4;
13729 char *salt_pos
= strchr (iter_pos
, '$');
13731 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13735 char *hash_pos
= strchr (salt_pos
, '$');
13737 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13739 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13743 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13744 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13745 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13746 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13747 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13748 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13749 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13750 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13752 uint salt_len
= hash_pos
- salt_pos
- 1;
13754 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13756 salt
->salt_len
= salt_len
/ 2;
13758 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13759 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13760 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13761 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13762 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13763 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13764 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13765 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13767 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13768 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13769 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13770 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13771 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13772 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13773 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13774 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13775 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13776 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13778 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13780 salt
->salt_iter
= atoi (iter_pos
) - 1;
13782 return (PARSER_OK
);
13785 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13787 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13789 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13791 u32
*digest
= (u32
*) hash_buf
->digest
;
13793 salt_t
*salt
= hash_buf
->salt
;
13795 char *salt_pos
= input_buf
+ 14;
13797 char *hash_pos
= strchr (salt_pos
, '*');
13799 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13803 uint salt_len
= hash_pos
- salt_pos
- 1;
13805 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13807 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13809 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13811 salt
->salt_len
= salt_len
;
13813 u8 tmp_buf
[100] = { 0 };
13815 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13817 memcpy (digest
, tmp_buf
, 32);
13819 digest
[0] = byte_swap_32 (digest
[0]);
13820 digest
[1] = byte_swap_32 (digest
[1]);
13821 digest
[2] = byte_swap_32 (digest
[2]);
13822 digest
[3] = byte_swap_32 (digest
[3]);
13823 digest
[4] = byte_swap_32 (digest
[4]);
13824 digest
[5] = byte_swap_32 (digest
[5]);
13825 digest
[6] = byte_swap_32 (digest
[6]);
13826 digest
[7] = byte_swap_32 (digest
[7]);
13828 digest
[0] -= SHA256M_A
;
13829 digest
[1] -= SHA256M_B
;
13830 digest
[2] -= SHA256M_C
;
13831 digest
[3] -= SHA256M_D
;
13832 digest
[4] -= SHA256M_E
;
13833 digest
[5] -= SHA256M_F
;
13834 digest
[6] -= SHA256M_G
;
13835 digest
[7] -= SHA256M_H
;
13837 return (PARSER_OK
);
13840 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13842 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13844 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13846 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13848 u64
*digest
= (u64
*) hash_buf
->digest
;
13850 salt_t
*salt
= hash_buf
->salt
;
13852 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13854 char *iter_pos
= input_buf
+ 19;
13856 char *salt_pos
= strchr (iter_pos
, '.');
13858 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13862 char *hash_pos
= strchr (salt_pos
, '.');
13864 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13866 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13870 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13871 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13872 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13873 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13874 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13875 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13876 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13877 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13879 uint salt_len
= hash_pos
- salt_pos
- 1;
13883 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13887 for (i
= 0; i
< salt_len
; i
++)
13889 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13892 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13893 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13895 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13897 salt
->salt_len
= salt_len
;
13899 salt
->salt_iter
= atoi (iter_pos
) - 1;
13901 return (PARSER_OK
);
13904 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13906 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13908 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13910 u64
*digest
= (u64
*) hash_buf
->digest
;
13912 salt_t
*salt
= hash_buf
->salt
;
13914 u8 tmp_buf
[120] = { 0 };
13916 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13918 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13920 memcpy (digest
, tmp_buf
, 64);
13922 digest
[0] = byte_swap_64 (digest
[0]);
13923 digest
[1] = byte_swap_64 (digest
[1]);
13924 digest
[2] = byte_swap_64 (digest
[2]);
13925 digest
[3] = byte_swap_64 (digest
[3]);
13926 digest
[4] = byte_swap_64 (digest
[4]);
13927 digest
[5] = byte_swap_64 (digest
[5]);
13928 digest
[6] = byte_swap_64 (digest
[6]);
13929 digest
[7] = byte_swap_64 (digest
[7]);
13931 digest
[0] -= SHA512M_A
;
13932 digest
[1] -= SHA512M_B
;
13933 digest
[2] -= SHA512M_C
;
13934 digest
[3] -= SHA512M_D
;
13935 digest
[4] -= SHA512M_E
;
13936 digest
[5] -= SHA512M_F
;
13937 digest
[6] -= SHA512M_G
;
13938 digest
[7] -= SHA512M_H
;
13940 int salt_len
= tmp_len
- 64;
13942 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13944 salt
->salt_len
= salt_len
;
13946 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13948 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13950 char *ptr
= (char *) salt
->salt_buf
;
13952 ptr
[salt
->salt_len
] = 0x80;
13955 return (PARSER_OK
);
13958 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13960 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13962 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13966 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13969 u32
*digest
= (u32
*) hash_buf
->digest
;
13971 salt_t
*salt
= hash_buf
->salt
;
13973 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13974 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13975 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13976 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13978 digest
[0] = byte_swap_32 (digest
[0]);
13979 digest
[1] = byte_swap_32 (digest
[1]);
13980 digest
[2] = byte_swap_32 (digest
[2]);
13981 digest
[3] = byte_swap_32 (digest
[3]);
13983 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13985 uint salt_len
= input_len
- 32 - 1;
13987 char *salt_buf
= input_buf
+ 32 + 1;
13989 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13991 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13993 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13995 salt
->salt_len
= salt_len
;
13997 return (PARSER_OK
);
14000 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14002 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14004 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
14008 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
14011 u32
*digest
= (u32
*) hash_buf
->digest
;
14013 salt_t
*salt
= hash_buf
->salt
;
14015 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14016 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14017 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14018 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14019 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14021 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14023 uint salt_len
= input_len
- 40 - 1;
14025 char *salt_buf
= input_buf
+ 40 + 1;
14027 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14029 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14031 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14033 salt
->salt_len
= salt_len
;
14035 return (PARSER_OK
);
14038 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14040 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14042 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
14046 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
14049 u32
*digest
= (u32
*) hash_buf
->digest
;
14051 salt_t
*salt
= hash_buf
->salt
;
14053 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14054 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14055 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14056 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14057 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14058 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
14059 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
14060 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
14062 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14064 uint salt_len
= input_len
- 64 - 1;
14066 char *salt_buf
= input_buf
+ 64 + 1;
14068 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14070 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14072 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14074 salt
->salt_len
= salt_len
;
14076 return (PARSER_OK
);
14079 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14081 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14083 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
14087 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
14090 u64
*digest
= (u64
*) hash_buf
->digest
;
14092 salt_t
*salt
= hash_buf
->salt
;
14094 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
14095 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
14096 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
14097 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
14098 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
14099 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
14100 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
14101 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
14103 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14105 uint salt_len
= input_len
- 128 - 1;
14107 char *salt_buf
= input_buf
+ 128 + 1;
14109 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14111 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14113 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14115 salt
->salt_len
= salt_len
;
14117 return (PARSER_OK
);
14120 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14122 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
14124 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
14126 u32
*digest
= (u32
*) hash_buf
->digest
;
14128 salt_t
*salt
= hash_buf
->salt
;
14130 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
14136 char *user_pos
= input_buf
+ 10 + 1;
14138 char *realm_pos
= strchr (user_pos
, '$');
14140 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14142 uint user_len
= realm_pos
- user_pos
;
14144 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
14148 char *salt_pos
= strchr (realm_pos
, '$');
14150 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14152 uint realm_len
= salt_pos
- realm_pos
;
14154 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
14158 char *data_pos
= strchr (salt_pos
, '$');
14160 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14162 uint salt_len
= data_pos
- salt_pos
;
14164 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
14168 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
14170 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
14176 memcpy (krb5pa
->user
, user_pos
, user_len
);
14177 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
14178 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
14180 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
14182 for (uint i
= 0; i
< (36 * 2); i
+= 2)
14184 const char p0
= data_pos
[i
+ 0];
14185 const char p1
= data_pos
[i
+ 1];
14187 *timestamp_ptr
++ = hex_convert (p1
) << 0
14188 | hex_convert (p0
) << 4;
14191 char *checksum_ptr
= (char *) krb5pa
->checksum
;
14193 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
14195 const char p0
= data_pos
[i
+ 0];
14196 const char p1
= data_pos
[i
+ 1];
14198 *checksum_ptr
++ = hex_convert (p1
) << 0
14199 | hex_convert (p0
) << 4;
14203 * copy some data to generic buffers to make sorting happy
14206 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
14207 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
14208 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
14209 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
14210 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
14211 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
14212 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
14213 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
14214 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
14216 salt
->salt_len
= 36;
14218 digest
[0] = krb5pa
->checksum
[0];
14219 digest
[1] = krb5pa
->checksum
[1];
14220 digest
[2] = krb5pa
->checksum
[2];
14221 digest
[3] = krb5pa
->checksum
[3];
14223 return (PARSER_OK
);
14226 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14228 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
14230 u32
*digest
= (u32
*) hash_buf
->digest
;
14232 salt_t
*salt
= hash_buf
->salt
;
14238 char *salt_pos
= input_buf
;
14240 char *hash_pos
= strchr (salt_pos
, '$');
14242 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14244 uint salt_len
= hash_pos
- salt_pos
;
14246 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14250 uint hash_len
= input_len
- 1 - salt_len
;
14252 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14260 for (uint i
= 0; i
< salt_len
; i
++)
14262 if (salt_pos
[i
] == ' ') continue;
14267 // SAP user names cannot be longer than 12 characters
14268 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14270 // SAP user name cannot start with ! or ?
14271 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14277 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14279 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14281 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14283 salt
->salt_len
= salt_len
;
14285 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
14286 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
14290 digest
[0] = byte_swap_32 (digest
[0]);
14291 digest
[1] = byte_swap_32 (digest
[1]);
14293 return (PARSER_OK
);
14296 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14298 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
14300 u32
*digest
= (u32
*) hash_buf
->digest
;
14302 salt_t
*salt
= hash_buf
->salt
;
14308 char *salt_pos
= input_buf
;
14310 char *hash_pos
= strchr (salt_pos
, '$');
14312 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14314 uint salt_len
= hash_pos
- salt_pos
;
14316 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14320 uint hash_len
= input_len
- 1 - salt_len
;
14322 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
14330 for (uint i
= 0; i
< salt_len
; i
++)
14332 if (salt_pos
[i
] == ' ') continue;
14337 // SAP user names cannot be longer than 12 characters
14338 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
14339 // so far nobody complained so we stay with this because it helps in optimization
14340 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
14342 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14344 // SAP user name cannot start with ! or ?
14345 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14351 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14353 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14355 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14357 salt
->salt_len
= salt_len
;
14359 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14360 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14361 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14362 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14363 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14365 return (PARSER_OK
);
14368 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14370 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
14372 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14374 u64
*digest
= (u64
*) hash_buf
->digest
;
14376 salt_t
*salt
= hash_buf
->salt
;
14378 char *iter_pos
= input_buf
+ 3;
14380 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
14382 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
14384 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
14386 salt
->salt_iter
= salt_iter
;
14388 char *salt_pos
= iter_pos
+ 1;
14392 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
14394 salt
->salt_len
= salt_len
;
14396 char *hash_pos
= salt_pos
+ salt_len
;
14398 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14402 char *tmp
= (char *) salt
->salt_buf_pc
;
14404 tmp
[0] = hash_pos
[42];
14408 digest
[ 0] = byte_swap_64 (digest
[ 0]);
14409 digest
[ 1] = byte_swap_64 (digest
[ 1]);
14410 digest
[ 2] = byte_swap_64 (digest
[ 2]);
14411 digest
[ 3] = byte_swap_64 (digest
[ 3]);
14417 return (PARSER_OK
);
14420 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14422 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
14424 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14426 u32
*digest
= (u32
*) hash_buf
->digest
;
14428 salt_t
*salt
= hash_buf
->salt
;
14430 char *salt_buf
= input_buf
+ 6;
14432 uint salt_len
= 16;
14434 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14436 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14438 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14440 salt
->salt_len
= salt_len
;
14442 char *hash_pos
= input_buf
+ 6 + 16;
14444 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14445 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14446 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14447 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14448 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14449 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
14450 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
14451 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
14453 return (PARSER_OK
);
14456 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14458 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
14460 u32
*digest
= (u32
*) hash_buf
->digest
;
14462 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14463 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14467 return (PARSER_OK
);
14470 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14472 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
14474 u32
*digest
= (u32
*) hash_buf
->digest
;
14476 salt_t
*salt
= hash_buf
->salt
;
14478 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
14480 char *saltbuf_pos
= input_buf
;
14482 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
14484 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14486 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14488 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14489 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14491 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14495 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14497 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14499 char *salt_ptr
= (char *) saltbuf_pos
;
14500 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14505 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14507 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14510 rakp_ptr
[j
] = 0x80;
14512 rakp
->salt_len
= j
;
14514 for (i
= 0; i
< 64; i
++)
14516 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14519 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14520 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14521 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14522 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14523 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14524 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14525 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14526 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14528 salt
->salt_len
= 32; // muss min. 32 haben
14530 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14531 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14532 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14533 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14534 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14536 return (PARSER_OK
);
14539 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14541 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14543 u32
*digest
= (u32
*) hash_buf
->digest
;
14545 salt_t
*salt
= hash_buf
->salt
;
14547 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14549 char *salt_pos
= input_buf
+ 1;
14551 memcpy (salt
->salt_buf
, salt_pos
, 8);
14553 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14554 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14556 salt
->salt_len
= 8;
14558 char *hash_pos
= salt_pos
+ 8;
14560 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14561 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14562 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14563 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14564 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14566 digest
[0] -= SHA1M_A
;
14567 digest
[1] -= SHA1M_B
;
14568 digest
[2] -= SHA1M_C
;
14569 digest
[3] -= SHA1M_D
;
14570 digest
[4] -= SHA1M_E
;
14572 return (PARSER_OK
);
14575 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14577 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14579 u32
*digest
= (u32
*) hash_buf
->digest
;
14581 salt_t
*salt
= hash_buf
->salt
;
14583 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14584 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14585 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14586 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14588 digest
[0] = byte_swap_32 (digest
[0]);
14589 digest
[1] = byte_swap_32 (digest
[1]);
14590 digest
[2] = byte_swap_32 (digest
[2]);
14591 digest
[3] = byte_swap_32 (digest
[3]);
14593 digest
[0] -= MD5M_A
;
14594 digest
[1] -= MD5M_B
;
14595 digest
[2] -= MD5M_C
;
14596 digest
[3] -= MD5M_D
;
14598 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14600 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14602 u32
*salt_buf
= salt
->salt_buf
;
14604 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14605 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14606 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14607 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14609 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14610 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14611 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14612 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14614 salt
->salt_len
= 16 + 1;
14616 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14618 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14620 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14622 return (PARSER_OK
);
14625 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14627 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14629 u32
*digest
= (u32
*) hash_buf
->digest
;
14631 salt_t
*salt
= hash_buf
->salt
;
14633 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14639 char *hashbuf_pos
= input_buf
;
14641 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14643 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14645 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14647 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14651 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14653 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14655 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14657 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14661 char *databuf_pos
= strchr (iteration_pos
, ':');
14663 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14665 const uint iteration_len
= databuf_pos
- iteration_pos
;
14667 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14668 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14670 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14672 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14673 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14679 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14680 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14681 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14682 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14683 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14684 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14685 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14686 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14690 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14692 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14694 const char p0
= saltbuf_pos
[i
+ 0];
14695 const char p1
= saltbuf_pos
[i
+ 1];
14697 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14698 | hex_convert (p0
) << 4;
14701 salt
->salt_buf
[4] = 0x01000000;
14702 salt
->salt_buf
[5] = 0x80;
14704 salt
->salt_len
= saltbuf_len
/ 2;
14708 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14712 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14714 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14716 const char p0
= databuf_pos
[i
+ 0];
14717 const char p1
= databuf_pos
[i
+ 1];
14719 *databuf_ptr
++ = hex_convert (p1
) << 0
14720 | hex_convert (p0
) << 4;
14723 *databuf_ptr
++ = 0x80;
14725 for (uint i
= 0; i
< 512; i
++)
14727 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14730 cloudkey
->data_len
= databuf_len
/ 2;
14732 return (PARSER_OK
);
14735 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14737 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14739 u32
*digest
= (u32
*) hash_buf
->digest
;
14741 salt_t
*salt
= hash_buf
->salt
;
14747 char *hashbuf_pos
= input_buf
;
14749 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14751 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14753 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14755 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14759 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14761 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14763 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14765 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14767 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14771 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14773 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14775 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14777 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14779 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14783 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14785 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14786 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14788 // ok, the plan for this algorithm is the following:
14789 // we have 2 salts here, the domain-name and a random salt
14790 // while both are used in the initial transformation,
14791 // only the random salt is used in the following iterations
14792 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14793 // and one that includes only the real salt (stored into salt_buf[]).
14794 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14796 u8 tmp_buf
[100] = { 0 };
14798 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14800 memcpy (digest
, tmp_buf
, 20);
14802 digest
[0] = byte_swap_32 (digest
[0]);
14803 digest
[1] = byte_swap_32 (digest
[1]);
14804 digest
[2] = byte_swap_32 (digest
[2]);
14805 digest
[3] = byte_swap_32 (digest
[3]);
14806 digest
[4] = byte_swap_32 (digest
[4]);
14810 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14812 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14814 char *len_ptr
= NULL
;
14816 for (uint i
= 0; i
< domainbuf_len
; i
++)
14818 if (salt_buf_pc_ptr
[i
] == '.')
14820 len_ptr
= &salt_buf_pc_ptr
[i
];
14830 salt
->salt_buf_pc
[7] = domainbuf_len
;
14834 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14836 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14838 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14840 salt
->salt_len
= salt_len
;
14844 salt
->salt_iter
= atoi (iteration_pos
);
14846 return (PARSER_OK
);
14849 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14851 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14853 u32
*digest
= (u32
*) hash_buf
->digest
;
14855 salt_t
*salt
= hash_buf
->salt
;
14857 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14858 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14859 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14860 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14861 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14863 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14865 uint salt_len
= input_len
- 40 - 1;
14867 char *salt_buf
= input_buf
+ 40 + 1;
14869 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14871 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14873 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14875 salt
->salt_len
= salt_len
;
14877 return (PARSER_OK
);
14880 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14882 const u8 ascii_to_ebcdic
[] =
14884 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14885 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14886 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14887 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14888 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14889 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14890 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14891 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14892 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14893 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14894 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14895 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14896 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14897 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14898 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14899 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14902 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14904 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14906 u32
*digest
= (u32
*) hash_buf
->digest
;
14908 salt_t
*salt
= hash_buf
->salt
;
14910 char *salt_pos
= input_buf
+ 6 + 1;
14912 char *digest_pos
= strchr (salt_pos
, '*');
14914 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14916 uint salt_len
= digest_pos
- salt_pos
;
14918 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14920 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14922 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14926 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14927 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14929 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14931 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14933 salt
->salt_len
= salt_len
;
14935 for (uint i
= 0; i
< salt_len
; i
++)
14937 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14939 for (uint i
= salt_len
; i
< 8; i
++)
14941 salt_buf_pc_ptr
[i
] = 0x40;
14946 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14948 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14949 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14951 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14952 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14954 digest
[0] = byte_swap_32 (digest
[0]);
14955 digest
[1] = byte_swap_32 (digest
[1]);
14957 IP (digest
[0], digest
[1], tt
);
14959 digest
[0] = rotr32 (digest
[0], 29);
14960 digest
[1] = rotr32 (digest
[1], 29);
14964 return (PARSER_OK
);
14967 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14969 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14971 u32
*digest
= (u32
*) hash_buf
->digest
;
14973 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14974 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14975 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14976 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14978 digest
[0] = byte_swap_32 (digest
[0]);
14979 digest
[1] = byte_swap_32 (digest
[1]);
14980 digest
[2] = byte_swap_32 (digest
[2]);
14981 digest
[3] = byte_swap_32 (digest
[3]);
14983 return (PARSER_OK
);
14986 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14988 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14990 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14992 u32
*digest
= (u32
*) hash_buf
->digest
;
14994 salt_t
*salt
= hash_buf
->salt
;
14996 u8 tmp_buf
[120] = { 0 };
14998 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15000 tmp_buf
[3] += -4; // dont ask!
15002 memcpy (salt
->salt_buf
, tmp_buf
, 5);
15004 salt
->salt_len
= 5;
15006 memcpy (digest
, tmp_buf
+ 5, 9);
15008 // yes, only 9 byte are needed to crack, but 10 to display
15010 salt
->salt_buf_pc
[7] = input_buf
[20];
15012 return (PARSER_OK
);
15015 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15017 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
15019 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15021 u32
*digest
= (u32
*) hash_buf
->digest
;
15023 salt_t
*salt
= hash_buf
->salt
;
15025 u8 tmp_buf
[120] = { 0 };
15027 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15029 tmp_buf
[3] += -4; // dont ask!
15033 memcpy (salt
->salt_buf
, tmp_buf
, 16);
15035 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)
15039 char tmp_iter_buf
[11] = { 0 };
15041 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
15043 tmp_iter_buf
[10] = 0;
15045 salt
->salt_iter
= atoi (tmp_iter_buf
);
15047 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
15049 return (PARSER_SALT_ITERATION
);
15052 salt
->salt_iter
--; // first round in init
15054 // 2 additional bytes for display only
15056 salt
->salt_buf_pc
[0] = tmp_buf
[26];
15057 salt
->salt_buf_pc
[1] = tmp_buf
[27];
15061 memcpy (digest
, tmp_buf
+ 28, 8);
15063 digest
[0] = byte_swap_32 (digest
[0]);
15064 digest
[1] = byte_swap_32 (digest
[1]);
15068 return (PARSER_OK
);
15071 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15073 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
15075 u32
*digest
= (u32
*) hash_buf
->digest
;
15077 salt_t
*salt
= hash_buf
->salt
;
15079 char *salt_buf_pos
= input_buf
;
15081 char *hash_buf_pos
= salt_buf_pos
+ 6;
15083 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
15084 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
15085 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
15086 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
15087 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
15088 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
15089 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
15090 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
15092 digest
[0] -= SHA256M_A
;
15093 digest
[1] -= SHA256M_B
;
15094 digest
[2] -= SHA256M_C
;
15095 digest
[3] -= SHA256M_D
;
15096 digest
[4] -= SHA256M_E
;
15097 digest
[5] -= SHA256M_F
;
15098 digest
[6] -= SHA256M_G
;
15099 digest
[7] -= SHA256M_H
;
15101 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15103 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
15105 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15107 salt
->salt_len
= salt_len
;
15109 return (PARSER_OK
);
15112 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15114 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
15116 u32
*digest
= (u32
*) hash_buf
->digest
;
15118 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15120 salt_t
*salt
= hash_buf
->salt
;
15122 char *salt_buf
= input_buf
+ 6;
15124 char *digest_buf
= strchr (salt_buf
, '$');
15126 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15128 uint salt_len
= digest_buf
- salt_buf
;
15130 digest_buf
++; // skip the '$' symbol
15132 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15134 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15136 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15138 salt
->salt_len
= salt_len
;
15140 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15141 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15142 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15143 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15145 digest
[0] = byte_swap_32 (digest
[0]);
15146 digest
[1] = byte_swap_32 (digest
[1]);
15147 digest
[2] = byte_swap_32 (digest
[2]);
15148 digest
[3] = byte_swap_32 (digest
[3]);
15150 digest
[0] -= MD5M_A
;
15151 digest
[1] -= MD5M_B
;
15152 digest
[2] -= MD5M_C
;
15153 digest
[3] -= MD5M_D
;
15155 return (PARSER_OK
);
15158 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15160 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
15162 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15164 u32
*digest
= (u32
*) hash_buf
->digest
;
15166 salt_t
*salt
= hash_buf
->salt
;
15168 char *salt_buf
= input_buf
+ 3;
15170 char *digest_buf
= strchr (salt_buf
, '$');
15172 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15174 uint salt_len
= digest_buf
- salt_buf
;
15176 digest_buf
++; // skip the '$' symbol
15178 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15180 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15182 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15184 salt_buf_ptr
[salt_len
] = 0x2d;
15186 salt
->salt_len
= salt_len
+ 1;
15188 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15189 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15190 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15191 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15193 digest
[0] = byte_swap_32 (digest
[0]);
15194 digest
[1] = byte_swap_32 (digest
[1]);
15195 digest
[2] = byte_swap_32 (digest
[2]);
15196 digest
[3] = byte_swap_32 (digest
[3]);
15198 digest
[0] -= MD5M_A
;
15199 digest
[1] -= MD5M_B
;
15200 digest
[2] -= MD5M_C
;
15201 digest
[3] -= MD5M_D
;
15203 return (PARSER_OK
);
15206 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15208 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
15210 u32
*digest
= (u32
*) hash_buf
->digest
;
15212 salt_t
*salt
= hash_buf
->salt
;
15214 u8 tmp_buf
[100] = { 0 };
15216 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
15218 memcpy (digest
, tmp_buf
, 20);
15220 digest
[0] = byte_swap_32 (digest
[0]);
15221 digest
[1] = byte_swap_32 (digest
[1]);
15222 digest
[2] = byte_swap_32 (digest
[2]);
15223 digest
[3] = byte_swap_32 (digest
[3]);
15224 digest
[4] = byte_swap_32 (digest
[4]);
15226 digest
[0] -= SHA1M_A
;
15227 digest
[1] -= SHA1M_B
;
15228 digest
[2] -= SHA1M_C
;
15229 digest
[3] -= SHA1M_D
;
15230 digest
[4] -= SHA1M_E
;
15232 salt
->salt_buf
[0] = 0x80;
15234 salt
->salt_len
= 0;
15236 return (PARSER_OK
);
15239 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15241 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
15243 u32
*digest
= (u32
*) hash_buf
->digest
;
15245 salt_t
*salt
= hash_buf
->salt
;
15247 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15248 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15249 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15250 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15252 digest
[0] = byte_swap_32 (digest
[0]);
15253 digest
[1] = byte_swap_32 (digest
[1]);
15254 digest
[2] = byte_swap_32 (digest
[2]);
15255 digest
[3] = byte_swap_32 (digest
[3]);
15257 digest
[0] -= MD5M_A
;
15258 digest
[1] -= MD5M_B
;
15259 digest
[2] -= MD5M_C
;
15260 digest
[3] -= MD5M_D
;
15262 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15264 uint salt_len
= input_len
- 32 - 1;
15266 char *salt_buf
= input_buf
+ 32 + 1;
15268 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15270 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15272 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15275 * add static "salt" part
15278 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
15282 salt
->salt_len
= salt_len
;
15284 return (PARSER_OK
);
15287 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15289 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
15291 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
15293 u32
*digest
= (u32
*) hash_buf
->digest
;
15295 salt_t
*salt
= hash_buf
->salt
;
15297 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
15303 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
15305 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
15307 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15309 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
15311 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
15315 char *keylen_pos
= strchr (saltbuf_pos
, '$');
15317 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15319 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
15321 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15325 char *keybuf_pos
= strchr (keylen_pos
, '$');
15327 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15329 uint keylen_len
= keybuf_pos
- keylen_pos
;
15331 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
15335 char *databuf_pos
= strchr (keybuf_pos
, '$');
15337 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15339 uint keybuf_len
= databuf_pos
- keybuf_pos
;
15341 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15345 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
15347 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
15353 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
15354 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
15355 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
15356 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
15358 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
15359 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
15360 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
15361 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
15363 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15364 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15365 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15366 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15368 salt
->salt_len
= 16;
15369 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
15371 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
15373 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
15376 return (PARSER_OK
);
15379 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15381 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
15383 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15385 u32
*digest
= (u32
*) hash_buf
->digest
;
15387 salt_t
*salt
= hash_buf
->salt
;
15393 // first is the N salt parameter
15395 char *N_pos
= input_buf
+ 6;
15397 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15401 salt
->scrypt_N
= atoi (N_pos
);
15405 char *r_pos
= strchr (N_pos
, ':');
15407 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15411 salt
->scrypt_r
= atoi (r_pos
);
15415 char *p_pos
= strchr (r_pos
, ':');
15417 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15421 salt
->scrypt_p
= atoi (p_pos
);
15425 char *saltbuf_pos
= strchr (p_pos
, ':');
15427 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15431 char *hash_pos
= strchr (saltbuf_pos
, ':');
15433 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15439 int salt_len_base64
= hash_pos
- saltbuf_pos
;
15441 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
15443 u8 tmp_buf
[33] = { 0 };
15445 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
15447 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15449 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
15451 salt
->salt_len
= tmp_len
;
15452 salt
->salt_iter
= 1;
15454 // digest - base64 decode
15456 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15458 tmp_len
= input_len
- (hash_pos
- input_buf
);
15460 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
15462 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
15464 memcpy (digest
, tmp_buf
, 32);
15466 return (PARSER_OK
);
15469 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15471 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
15473 u32
*digest
= (u32
*) hash_buf
->digest
;
15475 salt_t
*salt
= hash_buf
->salt
;
15481 char decrypted
[76] = { 0 }; // iv + hash
15483 juniper_decrypt_hash (input_buf
, decrypted
);
15485 char *md5crypt_hash
= decrypted
+ 12;
15487 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15489 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15491 char *salt_pos
= md5crypt_hash
+ 3;
15493 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15495 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15497 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15501 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15503 return (PARSER_OK
);
15506 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15508 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15510 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15512 u32
*digest
= (u32
*) hash_buf
->digest
;
15514 salt_t
*salt
= hash_buf
->salt
;
15516 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15522 // first is *raw* salt
15524 char *salt_pos
= input_buf
+ 3;
15526 char *hash_pos
= strchr (salt_pos
, '$');
15528 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15530 uint salt_len
= hash_pos
- salt_pos
;
15532 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15536 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15538 memcpy (salt_buf_ptr
, salt_pos
, 14);
15540 salt_buf_ptr
[17] = 0x01;
15541 salt_buf_ptr
[18] = 0x80;
15543 // add some stuff to normal salt to make sorted happy
15545 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15546 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15547 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15548 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15550 salt
->salt_len
= salt_len
;
15551 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15553 // base64 decode hash
15555 u8 tmp_buf
[100] = { 0 };
15557 uint hash_len
= input_len
- 3 - salt_len
- 1;
15559 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15561 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15563 memcpy (digest
, tmp_buf
, 32);
15565 digest
[0] = byte_swap_32 (digest
[0]);
15566 digest
[1] = byte_swap_32 (digest
[1]);
15567 digest
[2] = byte_swap_32 (digest
[2]);
15568 digest
[3] = byte_swap_32 (digest
[3]);
15569 digest
[4] = byte_swap_32 (digest
[4]);
15570 digest
[5] = byte_swap_32 (digest
[5]);
15571 digest
[6] = byte_swap_32 (digest
[6]);
15572 digest
[7] = byte_swap_32 (digest
[7]);
15574 return (PARSER_OK
);
15577 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15579 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15581 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15583 u32
*digest
= (u32
*) hash_buf
->digest
;
15585 salt_t
*salt
= hash_buf
->salt
;
15591 // first is *raw* salt
15593 char *salt_pos
= input_buf
+ 3;
15595 char *hash_pos
= strchr (salt_pos
, '$');
15597 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15599 uint salt_len
= hash_pos
- salt_pos
;
15601 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15603 salt
->salt_len
= salt_len
;
15606 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15608 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15609 salt_buf_ptr
[salt_len
] = 0;
15611 // base64 decode hash
15613 u8 tmp_buf
[100] = { 0 };
15615 uint hash_len
= input_len
- 3 - salt_len
- 1;
15617 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15619 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15621 memcpy (digest
, tmp_buf
, 32);
15624 salt
->scrypt_N
= 16384;
15625 salt
->scrypt_r
= 1;
15626 salt
->scrypt_p
= 1;
15627 salt
->salt_iter
= 1;
15629 return (PARSER_OK
);
15632 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15634 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15636 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15638 u32
*digest
= (u32
*) hash_buf
->digest
;
15640 salt_t
*salt
= hash_buf
->salt
;
15642 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15648 char *version_pos
= input_buf
+ 8 + 1;
15650 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15652 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15654 u32 version_len
= verifierHashSize_pos
- version_pos
;
15656 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15658 verifierHashSize_pos
++;
15660 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15662 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15664 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15666 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15670 char *saltSize_pos
= strchr (keySize_pos
, '*');
15672 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15674 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15676 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15680 char *osalt_pos
= strchr (saltSize_pos
, '*');
15682 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15684 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15686 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15690 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15692 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15694 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15696 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15698 encryptedVerifier_pos
++;
15700 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15702 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15704 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15706 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15708 encryptedVerifierHash_pos
++;
15710 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;
15712 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15714 const uint version
= atoi (version_pos
);
15716 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15718 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15720 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15722 const uint keySize
= atoi (keySize_pos
);
15724 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15726 office2007
->keySize
= keySize
;
15728 const uint saltSize
= atoi (saltSize_pos
);
15730 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15736 salt
->salt_len
= 16;
15737 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15739 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15740 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15741 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15742 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15748 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15749 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15750 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15751 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15753 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15754 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15755 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15756 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15757 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15763 digest
[0] = office2007
->encryptedVerifierHash
[0];
15764 digest
[1] = office2007
->encryptedVerifierHash
[1];
15765 digest
[2] = office2007
->encryptedVerifierHash
[2];
15766 digest
[3] = office2007
->encryptedVerifierHash
[3];
15768 return (PARSER_OK
);
15771 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15773 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15775 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15777 u32
*digest
= (u32
*) hash_buf
->digest
;
15779 salt_t
*salt
= hash_buf
->salt
;
15781 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15787 char *version_pos
= input_buf
+ 8 + 1;
15789 char *spinCount_pos
= strchr (version_pos
, '*');
15791 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15793 u32 version_len
= spinCount_pos
- version_pos
;
15795 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15799 char *keySize_pos
= strchr (spinCount_pos
, '*');
15801 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15803 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15805 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15809 char *saltSize_pos
= strchr (keySize_pos
, '*');
15811 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15813 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15815 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15819 char *osalt_pos
= strchr (saltSize_pos
, '*');
15821 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15823 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15825 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15829 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15831 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15833 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15835 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15837 encryptedVerifier_pos
++;
15839 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15841 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15843 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15845 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15847 encryptedVerifierHash_pos
++;
15849 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;
15851 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15853 const uint version
= atoi (version_pos
);
15855 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15857 const uint spinCount
= atoi (spinCount_pos
);
15859 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15861 const uint keySize
= atoi (keySize_pos
);
15863 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15865 const uint saltSize
= atoi (saltSize_pos
);
15867 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15873 salt
->salt_len
= 16;
15874 salt
->salt_iter
= spinCount
;
15876 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15877 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15878 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15879 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15885 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15886 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15887 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15888 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15890 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15891 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15892 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15893 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15894 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15895 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15896 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15897 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15903 digest
[0] = office2010
->encryptedVerifierHash
[0];
15904 digest
[1] = office2010
->encryptedVerifierHash
[1];
15905 digest
[2] = office2010
->encryptedVerifierHash
[2];
15906 digest
[3] = office2010
->encryptedVerifierHash
[3];
15908 return (PARSER_OK
);
15911 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15913 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15915 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15917 u32
*digest
= (u32
*) hash_buf
->digest
;
15919 salt_t
*salt
= hash_buf
->salt
;
15921 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15927 char *version_pos
= input_buf
+ 8 + 1;
15929 char *spinCount_pos
= strchr (version_pos
, '*');
15931 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15933 u32 version_len
= spinCount_pos
- version_pos
;
15935 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15939 char *keySize_pos
= strchr (spinCount_pos
, '*');
15941 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15943 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15945 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15949 char *saltSize_pos
= strchr (keySize_pos
, '*');
15951 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15953 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15955 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15959 char *osalt_pos
= strchr (saltSize_pos
, '*');
15961 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15963 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15965 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15969 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15971 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15973 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15975 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15977 encryptedVerifier_pos
++;
15979 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15981 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15983 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15985 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15987 encryptedVerifierHash_pos
++;
15989 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;
15991 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15993 const uint version
= atoi (version_pos
);
15995 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15997 const uint spinCount
= atoi (spinCount_pos
);
15999 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
16001 const uint keySize
= atoi (keySize_pos
);
16003 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
16005 const uint saltSize
= atoi (saltSize_pos
);
16007 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
16013 salt
->salt_len
= 16;
16014 salt
->salt_iter
= spinCount
;
16016 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16017 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16018 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16019 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16025 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16026 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16027 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16028 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16030 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16031 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16032 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16033 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16034 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16035 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
16036 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
16037 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
16043 digest
[0] = office2013
->encryptedVerifierHash
[0];
16044 digest
[1] = office2013
->encryptedVerifierHash
[1];
16045 digest
[2] = office2013
->encryptedVerifierHash
[2];
16046 digest
[3] = office2013
->encryptedVerifierHash
[3];
16048 return (PARSER_OK
);
16051 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16053 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
16055 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16057 u32
*digest
= (u32
*) hash_buf
->digest
;
16059 salt_t
*salt
= hash_buf
->salt
;
16061 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16067 char *version_pos
= input_buf
+ 11;
16069 char *osalt_pos
= strchr (version_pos
, '*');
16071 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16073 u32 version_len
= osalt_pos
- version_pos
;
16075 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16079 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16081 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16083 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16085 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16087 encryptedVerifier_pos
++;
16089 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16091 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16093 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16095 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16097 encryptedVerifierHash_pos
++;
16099 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16101 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16103 const uint version
= *version_pos
- 0x30;
16105 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16111 oldoffice01
->version
= version
;
16113 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16114 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16115 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16116 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16118 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16119 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16120 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16121 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16123 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16124 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16125 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16126 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16128 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16129 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16130 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16131 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16137 salt
->salt_len
= 16;
16139 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16140 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16141 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16142 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16144 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16145 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16146 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16147 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16149 // this is a workaround as office produces multiple documents with the same salt
16151 salt
->salt_len
+= 32;
16153 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16154 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16155 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16156 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16157 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16158 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16159 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16160 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16166 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
16167 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
16168 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
16169 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
16171 return (PARSER_OK
);
16174 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16176 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
16179 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16181 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
16183 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16185 u32
*digest
= (u32
*) hash_buf
->digest
;
16187 salt_t
*salt
= hash_buf
->salt
;
16189 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16195 char *version_pos
= input_buf
+ 11;
16197 char *osalt_pos
= strchr (version_pos
, '*');
16199 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16201 u32 version_len
= osalt_pos
- version_pos
;
16203 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16207 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16209 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16211 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16213 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16215 encryptedVerifier_pos
++;
16217 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16219 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16221 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16223 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16225 encryptedVerifierHash_pos
++;
16227 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16229 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16231 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16233 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16237 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16239 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16241 const uint version
= *version_pos
- 0x30;
16243 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16249 oldoffice01
->version
= version
;
16251 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16252 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16253 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16254 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16256 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16257 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16258 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16259 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16261 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16262 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16263 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16264 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16266 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16267 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16268 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16269 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16271 oldoffice01
->rc4key
[1] = 0;
16272 oldoffice01
->rc4key
[0] = 0;
16274 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16275 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16276 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16277 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16278 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16279 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16280 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16281 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16282 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16283 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16285 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
16286 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
16292 salt
->salt_len
= 16;
16294 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16295 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16296 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16297 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16299 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16300 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16301 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16302 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16304 // this is a workaround as office produces multiple documents with the same salt
16306 salt
->salt_len
+= 32;
16308 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16309 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16310 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16311 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16312 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16313 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16314 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16315 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16321 digest
[0] = oldoffice01
->rc4key
[0];
16322 digest
[1] = oldoffice01
->rc4key
[1];
16326 return (PARSER_OK
);
16329 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16331 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
16333 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16335 u32
*digest
= (u32
*) hash_buf
->digest
;
16337 salt_t
*salt
= hash_buf
->salt
;
16339 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16345 char *version_pos
= input_buf
+ 11;
16347 char *osalt_pos
= strchr (version_pos
, '*');
16349 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16351 u32 version_len
= osalt_pos
- version_pos
;
16353 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16357 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16359 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16361 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16363 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16365 encryptedVerifier_pos
++;
16367 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16369 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16371 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16373 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16375 encryptedVerifierHash_pos
++;
16377 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16379 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16381 const uint version
= *version_pos
- 0x30;
16383 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16389 oldoffice34
->version
= version
;
16391 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16392 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16393 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16394 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16396 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16397 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16398 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16399 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16401 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16402 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16403 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16404 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16405 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16407 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16408 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16409 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16410 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16411 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16417 salt
->salt_len
= 16;
16419 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16420 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16421 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16422 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16424 // this is a workaround as office produces multiple documents with the same salt
16426 salt
->salt_len
+= 32;
16428 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16429 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16430 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16431 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16432 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16433 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16434 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16435 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16441 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
16442 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
16443 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
16444 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
16446 return (PARSER_OK
);
16449 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16451 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16453 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
16456 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16458 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
16460 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16462 u32
*digest
= (u32
*) hash_buf
->digest
;
16464 salt_t
*salt
= hash_buf
->salt
;
16466 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16472 char *version_pos
= input_buf
+ 11;
16474 char *osalt_pos
= strchr (version_pos
, '*');
16476 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16478 u32 version_len
= osalt_pos
- version_pos
;
16480 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16484 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16486 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16488 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16490 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16492 encryptedVerifier_pos
++;
16494 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16496 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16498 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16500 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16502 encryptedVerifierHash_pos
++;
16504 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16506 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16508 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16510 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16514 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16516 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16518 const uint version
= *version_pos
- 0x30;
16520 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16526 oldoffice34
->version
= version
;
16528 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16529 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16530 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16531 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16533 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16534 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16535 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16536 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16538 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16539 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16540 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16541 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16542 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16544 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16545 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16546 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16547 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16548 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16550 oldoffice34
->rc4key
[1] = 0;
16551 oldoffice34
->rc4key
[0] = 0;
16553 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16554 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16555 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16556 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16557 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16558 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16559 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16560 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16561 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16562 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16564 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16565 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16571 salt
->salt_len
= 16;
16573 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16574 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16575 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16576 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16578 // this is a workaround as office produces multiple documents with the same salt
16580 salt
->salt_len
+= 32;
16582 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16583 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16584 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16585 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16586 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16587 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16588 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16589 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16595 digest
[0] = oldoffice34
->rc4key
[0];
16596 digest
[1] = oldoffice34
->rc4key
[1];
16600 return (PARSER_OK
);
16603 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16605 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16607 u32
*digest
= (u32
*) hash_buf
->digest
;
16609 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16610 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16611 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16612 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16614 digest
[0] = byte_swap_32 (digest
[0]);
16615 digest
[1] = byte_swap_32 (digest
[1]);
16616 digest
[2] = byte_swap_32 (digest
[2]);
16617 digest
[3] = byte_swap_32 (digest
[3]);
16619 return (PARSER_OK
);
16622 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16624 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16626 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16628 u32
*digest
= (u32
*) hash_buf
->digest
;
16630 salt_t
*salt
= hash_buf
->salt
;
16632 char *signature_pos
= input_buf
;
16634 char *salt_pos
= strchr (signature_pos
, '$');
16636 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16638 u32 signature_len
= salt_pos
- signature_pos
;
16640 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16644 char *hash_pos
= strchr (salt_pos
, '$');
16646 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16648 u32 salt_len
= hash_pos
- salt_pos
;
16650 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16654 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16656 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16658 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16659 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16660 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16661 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16662 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16664 digest
[0] -= SHA1M_A
;
16665 digest
[1] -= SHA1M_B
;
16666 digest
[2] -= SHA1M_C
;
16667 digest
[3] -= SHA1M_D
;
16668 digest
[4] -= SHA1M_E
;
16670 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16672 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16674 salt
->salt_len
= salt_len
;
16676 return (PARSER_OK
);
16679 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16681 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16683 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16685 u32
*digest
= (u32
*) hash_buf
->digest
;
16687 salt_t
*salt
= hash_buf
->salt
;
16689 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16695 char *iter_pos
= input_buf
+ 14;
16697 const int iter
= atoi (iter_pos
);
16699 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16701 salt
->salt_iter
= iter
- 1;
16703 char *salt_pos
= strchr (iter_pos
, '$');
16705 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16709 char *hash_pos
= strchr (salt_pos
, '$');
16711 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16713 const uint salt_len
= hash_pos
- salt_pos
;
16717 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16719 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16721 salt
->salt_len
= salt_len
;
16723 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16724 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16726 // add some stuff to normal salt to make sorted happy
16728 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16729 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16730 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16731 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16732 salt
->salt_buf
[4] = salt
->salt_iter
;
16734 // base64 decode hash
16736 u8 tmp_buf
[100] = { 0 };
16738 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16740 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16742 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16744 memcpy (digest
, tmp_buf
, 32);
16746 digest
[0] = byte_swap_32 (digest
[0]);
16747 digest
[1] = byte_swap_32 (digest
[1]);
16748 digest
[2] = byte_swap_32 (digest
[2]);
16749 digest
[3] = byte_swap_32 (digest
[3]);
16750 digest
[4] = byte_swap_32 (digest
[4]);
16751 digest
[5] = byte_swap_32 (digest
[5]);
16752 digest
[6] = byte_swap_32 (digest
[6]);
16753 digest
[7] = byte_swap_32 (digest
[7]);
16755 return (PARSER_OK
);
16758 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16760 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16762 u32
*digest
= (u32
*) hash_buf
->digest
;
16764 salt_t
*salt
= hash_buf
->salt
;
16766 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16767 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16771 digest
[0] = byte_swap_32 (digest
[0]);
16772 digest
[1] = byte_swap_32 (digest
[1]);
16774 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16775 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16776 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16778 char iter_c
= input_buf
[17];
16779 char iter_d
= input_buf
[19];
16781 // atm only defaults, let's see if there's more request
16782 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16783 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16785 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16787 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16788 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16789 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16790 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16792 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16793 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16794 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16795 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16797 salt
->salt_len
= 16;
16799 return (PARSER_OK
);
16802 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16804 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16806 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16808 u32
*digest
= (u32
*) hash_buf
->digest
;
16810 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16812 salt_t
*salt
= hash_buf
->salt
;
16814 char *salt_pos
= input_buf
+ 10;
16816 char *hash_pos
= strchr (salt_pos
, '$');
16818 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16820 uint salt_len
= hash_pos
- salt_pos
;
16824 uint hash_len
= input_len
- 10 - salt_len
- 1;
16826 // base64 decode salt
16828 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16830 u8 tmp_buf
[100] = { 0 };
16832 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16834 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16836 tmp_buf
[salt_len
] = 0x80;
16838 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16840 salt
->salt_len
= salt_len
;
16842 // base64 decode hash
16844 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16846 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16848 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16850 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16852 uint user_len
= hash_len
- 32;
16854 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16856 user_len
--; // skip the trailing space
16858 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16859 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16860 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16861 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16863 digest
[0] = byte_swap_32 (digest
[0]);
16864 digest
[1] = byte_swap_32 (digest
[1]);
16865 digest
[2] = byte_swap_32 (digest
[2]);
16866 digest
[3] = byte_swap_32 (digest
[3]);
16868 // store username for host only (output hash if cracked)
16870 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16871 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16873 return (PARSER_OK
);
16876 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16878 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16880 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16882 u32
*digest
= (u32
*) hash_buf
->digest
;
16884 salt_t
*salt
= hash_buf
->salt
;
16886 char *iter_pos
= input_buf
+ 10;
16888 u32 iter
= atoi (iter_pos
);
16892 return (PARSER_SALT_ITERATION
);
16895 iter
--; // first iteration is special
16897 salt
->salt_iter
= iter
;
16899 char *base64_pos
= strchr (iter_pos
, '}');
16901 if (base64_pos
== NULL
)
16903 return (PARSER_SIGNATURE_UNMATCHED
);
16908 // base64 decode salt
16910 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16912 u8 tmp_buf
[100] = { 0 };
16914 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16916 if (decoded_len
< 24)
16918 return (PARSER_SALT_LENGTH
);
16923 uint salt_len
= decoded_len
- 20;
16925 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16926 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16928 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16930 salt
->salt_len
= salt_len
;
16934 u32
*digest_ptr
= (u32
*) tmp_buf
;
16936 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16937 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16938 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16939 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16940 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16942 return (PARSER_OK
);
16945 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16947 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16949 u32
*digest
= (u32
*) hash_buf
->digest
;
16951 salt_t
*salt
= hash_buf
->salt
;
16953 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16954 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16955 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16956 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16957 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16959 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16961 uint salt_len
= input_len
- 40 - 1;
16963 char *salt_buf
= input_buf
+ 40 + 1;
16965 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16967 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16969 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16971 salt
->salt_len
= salt_len
;
16973 return (PARSER_OK
);
16976 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16978 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16980 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16982 u32
*digest
= (u32
*) hash_buf
->digest
;
16984 salt_t
*salt
= hash_buf
->salt
;
16986 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16992 char *V_pos
= input_buf
+ 5;
16994 char *R_pos
= strchr (V_pos
, '*');
16996 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16998 u32 V_len
= R_pos
- V_pos
;
17002 char *bits_pos
= strchr (R_pos
, '*');
17004 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17006 u32 R_len
= bits_pos
- R_pos
;
17010 char *P_pos
= strchr (bits_pos
, '*');
17012 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17014 u32 bits_len
= P_pos
- bits_pos
;
17018 char *enc_md_pos
= strchr (P_pos
, '*');
17020 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17022 u32 P_len
= enc_md_pos
- P_pos
;
17026 char *id_len_pos
= strchr (enc_md_pos
, '*');
17028 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17030 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17034 char *id_buf_pos
= strchr (id_len_pos
, '*');
17036 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17038 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17042 char *u_len_pos
= strchr (id_buf_pos
, '*');
17044 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17046 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17048 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17052 char *u_buf_pos
= strchr (u_len_pos
, '*');
17054 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17056 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17060 char *o_len_pos
= strchr (u_buf_pos
, '*');
17062 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17064 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17066 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17070 char *o_buf_pos
= strchr (o_len_pos
, '*');
17072 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17074 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17078 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;
17080 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17084 const int V
= atoi (V_pos
);
17085 const int R
= atoi (R_pos
);
17086 const int P
= atoi (P_pos
);
17088 if (V
!= 1) return (PARSER_SALT_VALUE
);
17089 if (R
!= 2) return (PARSER_SALT_VALUE
);
17091 const int enc_md
= atoi (enc_md_pos
);
17093 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17095 const int id_len
= atoi (id_len_pos
);
17096 const int u_len
= atoi (u_len_pos
);
17097 const int o_len
= atoi (o_len_pos
);
17099 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17100 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17101 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17103 const int bits
= atoi (bits_pos
);
17105 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17107 // copy data to esalt
17113 pdf
->enc_md
= enc_md
;
17115 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17116 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17117 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17118 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17119 pdf
->id_len
= id_len
;
17121 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17122 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17123 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17124 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17125 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17126 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17127 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17128 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17129 pdf
->u_len
= u_len
;
17131 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17132 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17133 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17134 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17135 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17136 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17137 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17138 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17139 pdf
->o_len
= o_len
;
17141 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17142 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17143 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17144 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17146 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17147 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17148 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17149 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17150 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17151 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17152 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17153 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17155 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17156 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17157 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17158 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17159 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17160 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17161 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17162 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17164 // we use ID for salt, maybe needs to change, we will see...
17166 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17167 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17168 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17169 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17170 salt
->salt_len
= pdf
->id_len
;
17172 digest
[0] = pdf
->u_buf
[0];
17173 digest
[1] = pdf
->u_buf
[1];
17174 digest
[2] = pdf
->u_buf
[2];
17175 digest
[3] = pdf
->u_buf
[3];
17177 return (PARSER_OK
);
17180 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17182 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
17185 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17187 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
17189 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17191 u32
*digest
= (u32
*) hash_buf
->digest
;
17193 salt_t
*salt
= hash_buf
->salt
;
17195 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17201 char *V_pos
= input_buf
+ 5;
17203 char *R_pos
= strchr (V_pos
, '*');
17205 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17207 u32 V_len
= R_pos
- V_pos
;
17211 char *bits_pos
= strchr (R_pos
, '*');
17213 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17215 u32 R_len
= bits_pos
- R_pos
;
17219 char *P_pos
= strchr (bits_pos
, '*');
17221 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17223 u32 bits_len
= P_pos
- bits_pos
;
17227 char *enc_md_pos
= strchr (P_pos
, '*');
17229 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17231 u32 P_len
= enc_md_pos
- P_pos
;
17235 char *id_len_pos
= strchr (enc_md_pos
, '*');
17237 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17239 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17243 char *id_buf_pos
= strchr (id_len_pos
, '*');
17245 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17247 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17251 char *u_len_pos
= strchr (id_buf_pos
, '*');
17253 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17255 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17257 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17261 char *u_buf_pos
= strchr (u_len_pos
, '*');
17263 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17265 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17269 char *o_len_pos
= strchr (u_buf_pos
, '*');
17271 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17273 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17275 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17279 char *o_buf_pos
= strchr (o_len_pos
, '*');
17281 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17283 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17287 char *rc4key_pos
= strchr (o_buf_pos
, ':');
17289 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17291 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
17293 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17297 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;
17299 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
17303 const int V
= atoi (V_pos
);
17304 const int R
= atoi (R_pos
);
17305 const int P
= atoi (P_pos
);
17307 if (V
!= 1) return (PARSER_SALT_VALUE
);
17308 if (R
!= 2) return (PARSER_SALT_VALUE
);
17310 const int enc_md
= atoi (enc_md_pos
);
17312 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17314 const int id_len
= atoi (id_len_pos
);
17315 const int u_len
= atoi (u_len_pos
);
17316 const int o_len
= atoi (o_len_pos
);
17318 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17319 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17320 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17322 const int bits
= atoi (bits_pos
);
17324 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17326 // copy data to esalt
17332 pdf
->enc_md
= enc_md
;
17334 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17335 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17336 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17337 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17338 pdf
->id_len
= id_len
;
17340 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17341 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17342 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17343 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17344 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17345 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17346 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17347 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17348 pdf
->u_len
= u_len
;
17350 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17351 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17352 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17353 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17354 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17355 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17356 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17357 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17358 pdf
->o_len
= o_len
;
17360 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17361 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17362 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17363 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17365 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17366 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17367 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17368 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17369 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17370 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17371 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17372 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17374 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17375 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17376 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17377 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17378 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17379 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17380 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17381 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17383 pdf
->rc4key
[1] = 0;
17384 pdf
->rc4key
[0] = 0;
17386 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
17387 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
17388 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
17389 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
17390 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
17391 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
17392 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
17393 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
17394 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
17395 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
17397 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
17398 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
17400 // we use ID for salt, maybe needs to change, we will see...
17402 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17403 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17404 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17405 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17406 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17407 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17408 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17409 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17410 salt
->salt_len
= pdf
->id_len
+ 16;
17412 digest
[0] = pdf
->rc4key
[0];
17413 digest
[1] = pdf
->rc4key
[1];
17417 return (PARSER_OK
);
17420 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17422 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
17424 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17426 u32
*digest
= (u32
*) hash_buf
->digest
;
17428 salt_t
*salt
= hash_buf
->salt
;
17430 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17436 char *V_pos
= input_buf
+ 5;
17438 char *R_pos
= strchr (V_pos
, '*');
17440 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17442 u32 V_len
= R_pos
- V_pos
;
17446 char *bits_pos
= strchr (R_pos
, '*');
17448 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17450 u32 R_len
= bits_pos
- R_pos
;
17454 char *P_pos
= strchr (bits_pos
, '*');
17456 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17458 u32 bits_len
= P_pos
- bits_pos
;
17462 char *enc_md_pos
= strchr (P_pos
, '*');
17464 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17466 u32 P_len
= enc_md_pos
- P_pos
;
17470 char *id_len_pos
= strchr (enc_md_pos
, '*');
17472 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17474 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17478 char *id_buf_pos
= strchr (id_len_pos
, '*');
17480 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17482 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17486 char *u_len_pos
= strchr (id_buf_pos
, '*');
17488 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17490 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17492 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17496 char *u_buf_pos
= strchr (u_len_pos
, '*');
17498 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17500 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17504 char *o_len_pos
= strchr (u_buf_pos
, '*');
17506 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17508 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17510 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17514 char *o_buf_pos
= strchr (o_len_pos
, '*');
17516 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17518 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17522 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;
17524 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17528 const int V
= atoi (V_pos
);
17529 const int R
= atoi (R_pos
);
17530 const int P
= atoi (P_pos
);
17534 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17535 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17537 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17539 const int id_len
= atoi (id_len_pos
);
17540 const int u_len
= atoi (u_len_pos
);
17541 const int o_len
= atoi (o_len_pos
);
17543 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17545 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17546 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17548 const int bits
= atoi (bits_pos
);
17550 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17556 enc_md
= atoi (enc_md_pos
);
17559 // copy data to esalt
17565 pdf
->enc_md
= enc_md
;
17567 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17568 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17569 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17570 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17574 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17575 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17576 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17577 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17580 pdf
->id_len
= id_len
;
17582 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17583 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17584 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17585 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17586 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17587 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17588 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17589 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17590 pdf
->u_len
= u_len
;
17592 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17593 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17594 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17595 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17596 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17597 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17598 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17599 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17600 pdf
->o_len
= o_len
;
17602 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17603 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17604 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17605 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17609 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17610 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17611 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17612 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17615 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17616 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17617 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17618 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17619 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17620 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17621 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17622 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17624 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17625 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17626 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17627 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17628 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17629 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17630 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17631 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17633 // precompute rc4 data for later use
17649 uint salt_pc_block
[32] = { 0 };
17651 char *salt_pc_ptr
= (char *) salt_pc_block
;
17653 memcpy (salt_pc_ptr
, padding
, 32);
17654 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17656 uint salt_pc_digest
[4] = { 0 };
17658 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17660 pdf
->rc4data
[0] = salt_pc_digest
[0];
17661 pdf
->rc4data
[1] = salt_pc_digest
[1];
17663 // we use ID for salt, maybe needs to change, we will see...
17665 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17666 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17667 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17668 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17669 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17670 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17671 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17672 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17673 salt
->salt_len
= pdf
->id_len
+ 16;
17675 salt
->salt_iter
= ROUNDS_PDF14
;
17677 digest
[0] = pdf
->u_buf
[0];
17678 digest
[1] = pdf
->u_buf
[1];
17682 return (PARSER_OK
);
17685 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17687 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17689 if (ret
!= PARSER_OK
)
17694 u32
*digest
= (u32
*) hash_buf
->digest
;
17696 salt_t
*salt
= hash_buf
->salt
;
17698 digest
[0] -= SHA256M_A
;
17699 digest
[1] -= SHA256M_B
;
17700 digest
[2] -= SHA256M_C
;
17701 digest
[3] -= SHA256M_D
;
17702 digest
[4] -= SHA256M_E
;
17703 digest
[5] -= SHA256M_F
;
17704 digest
[6] -= SHA256M_G
;
17705 digest
[7] -= SHA256M_H
;
17707 salt
->salt_buf
[2] = 0x80;
17709 return (PARSER_OK
);
17712 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17714 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17716 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17718 u32
*digest
= (u32
*) hash_buf
->digest
;
17720 salt_t
*salt
= hash_buf
->salt
;
17722 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17728 char *V_pos
= input_buf
+ 5;
17730 char *R_pos
= strchr (V_pos
, '*');
17732 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17734 u32 V_len
= R_pos
- V_pos
;
17738 char *bits_pos
= strchr (R_pos
, '*');
17740 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17742 u32 R_len
= bits_pos
- R_pos
;
17746 char *P_pos
= strchr (bits_pos
, '*');
17748 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17750 u32 bits_len
= P_pos
- bits_pos
;
17754 char *enc_md_pos
= strchr (P_pos
, '*');
17756 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17758 u32 P_len
= enc_md_pos
- P_pos
;
17762 char *id_len_pos
= strchr (enc_md_pos
, '*');
17764 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17766 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17770 char *id_buf_pos
= strchr (id_len_pos
, '*');
17772 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17774 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17778 char *u_len_pos
= strchr (id_buf_pos
, '*');
17780 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17782 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17786 char *u_buf_pos
= strchr (u_len_pos
, '*');
17788 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17790 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17794 char *o_len_pos
= strchr (u_buf_pos
, '*');
17796 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17798 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17802 char *o_buf_pos
= strchr (o_len_pos
, '*');
17804 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17806 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17810 char *last
= strchr (o_buf_pos
, '*');
17812 if (last
== NULL
) last
= input_buf
+ input_len
;
17814 u32 o_buf_len
= last
- o_buf_pos
;
17818 const int V
= atoi (V_pos
);
17819 const int R
= atoi (R_pos
);
17823 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17824 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17826 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17828 const int bits
= atoi (bits_pos
);
17830 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17832 int enc_md
= atoi (enc_md_pos
);
17834 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17836 const uint id_len
= atoi (id_len_pos
);
17837 const uint u_len
= atoi (u_len_pos
);
17838 const uint o_len
= atoi (o_len_pos
);
17840 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17841 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17842 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17843 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17844 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17845 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17846 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17847 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17849 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17850 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17851 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17853 // copy data to esalt
17855 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17857 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17859 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17862 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17863 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17865 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17866 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17868 salt
->salt_len
= 8;
17869 salt
->salt_iter
= ROUNDS_PDF17L8
;
17871 digest
[0] = pdf
->u_buf
[0];
17872 digest
[1] = pdf
->u_buf
[1];
17873 digest
[2] = pdf
->u_buf
[2];
17874 digest
[3] = pdf
->u_buf
[3];
17875 digest
[4] = pdf
->u_buf
[4];
17876 digest
[5] = pdf
->u_buf
[5];
17877 digest
[6] = pdf
->u_buf
[6];
17878 digest
[7] = pdf
->u_buf
[7];
17880 return (PARSER_OK
);
17883 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17885 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17887 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17889 u32
*digest
= (u32
*) hash_buf
->digest
;
17891 salt_t
*salt
= hash_buf
->salt
;
17893 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17901 char *iter_pos
= input_buf
+ 7;
17903 u32 iter
= atoi (iter_pos
);
17905 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17906 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17908 // first is *raw* salt
17910 char *salt_pos
= strchr (iter_pos
, ':');
17912 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17916 char *hash_pos
= strchr (salt_pos
, ':');
17918 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17920 u32 salt_len
= hash_pos
- salt_pos
;
17922 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17926 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17928 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17932 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17934 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17936 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17938 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17939 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17941 salt
->salt_len
= salt_len
;
17942 salt
->salt_iter
= iter
- 1;
17946 u8 tmp_buf
[100] = { 0 };
17948 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17950 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17952 memcpy (digest
, tmp_buf
, 16);
17954 digest
[0] = byte_swap_32 (digest
[0]);
17955 digest
[1] = byte_swap_32 (digest
[1]);
17956 digest
[2] = byte_swap_32 (digest
[2]);
17957 digest
[3] = byte_swap_32 (digest
[3]);
17959 // add some stuff to normal salt to make sorted happy
17961 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17962 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17963 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17964 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17965 salt
->salt_buf
[4] = salt
->salt_iter
;
17967 return (PARSER_OK
);
17970 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17972 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17974 u32
*digest
= (u32
*) hash_buf
->digest
;
17976 salt_t
*salt
= hash_buf
->salt
;
17978 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17979 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17980 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17981 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17983 digest
[0] = byte_swap_32 (digest
[0]);
17984 digest
[1] = byte_swap_32 (digest
[1]);
17985 digest
[2] = byte_swap_32 (digest
[2]);
17986 digest
[3] = byte_swap_32 (digest
[3]);
17988 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17990 uint salt_len
= input_len
- 32 - 1;
17992 char *salt_buf
= input_buf
+ 32 + 1;
17994 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17996 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17998 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18000 salt
->salt_len
= salt_len
;
18002 return (PARSER_OK
);
18005 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18007 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
18009 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18011 u32
*digest
= (u32
*) hash_buf
->digest
;
18013 salt_t
*salt
= hash_buf
->salt
;
18015 char *user_pos
= input_buf
+ 10;
18017 char *salt_pos
= strchr (user_pos
, '*');
18019 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18023 char *hash_pos
= strchr (salt_pos
, '*');
18027 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18029 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
18031 uint user_len
= salt_pos
- user_pos
- 1;
18033 uint salt_len
= hash_pos
- salt_pos
- 1;
18035 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
18041 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18042 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18043 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18044 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18046 digest
[0] = byte_swap_32 (digest
[0]);
18047 digest
[1] = byte_swap_32 (digest
[1]);
18048 digest
[2] = byte_swap_32 (digest
[2]);
18049 digest
[3] = byte_swap_32 (digest
[3]);
18051 digest
[0] -= MD5M_A
;
18052 digest
[1] -= MD5M_B
;
18053 digest
[2] -= MD5M_C
;
18054 digest
[3] -= MD5M_D
;
18060 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18062 // first 4 bytes are the "challenge"
18064 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
18065 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
18066 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
18067 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
18069 // append the user name
18071 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
18073 salt
->salt_len
= 4 + user_len
;
18075 return (PARSER_OK
);
18078 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18080 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
18082 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18084 u32
*digest
= (u32
*) hash_buf
->digest
;
18086 salt_t
*salt
= hash_buf
->salt
;
18088 char *salt_pos
= input_buf
+ 9;
18090 char *hash_pos
= strchr (salt_pos
, '*');
18092 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18096 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18098 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
18100 uint salt_len
= hash_pos
- salt_pos
- 1;
18102 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
18108 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18109 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18110 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18111 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18112 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18118 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18120 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18122 salt
->salt_len
= salt_len
;
18124 return (PARSER_OK
);
18127 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18129 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
18131 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18133 u32
*digest
= (u32
*) hash_buf
->digest
;
18135 salt_t
*salt
= hash_buf
->salt
;
18137 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
18143 char *cry_master_len_pos
= input_buf
+ 9;
18145 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
18147 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18149 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
18151 cry_master_buf_pos
++;
18153 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
18155 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18157 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
18159 cry_salt_len_pos
++;
18161 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
18163 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18165 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
18167 cry_salt_buf_pos
++;
18169 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
18171 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18173 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
18177 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
18179 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18181 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
18185 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
18187 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18189 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
18193 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
18195 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18197 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
18199 public_key_len_pos
++;
18201 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
18203 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18205 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
18207 public_key_buf_pos
++;
18209 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;
18211 const uint cry_master_len
= atoi (cry_master_len_pos
);
18212 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
18213 const uint ckey_len
= atoi (ckey_len_pos
);
18214 const uint public_key_len
= atoi (public_key_len_pos
);
18216 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
18217 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
18218 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
18219 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
18221 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
18223 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
18225 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
18228 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
18230 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
18232 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
18235 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
18237 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
18239 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
18242 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
18243 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
18244 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
18247 * store digest (should be unique enought, hopefully)
18250 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
18251 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
18252 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
18253 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
18259 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
18261 const uint cry_rounds
= atoi (cry_rounds_pos
);
18263 salt
->salt_iter
= cry_rounds
- 1;
18265 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18267 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
18269 salt
->salt_len
= salt_len
;
18271 return (PARSER_OK
);
18274 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18276 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
18278 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18280 u32
*digest
= (u32
*) hash_buf
->digest
;
18282 salt_t
*salt
= hash_buf
->salt
;
18284 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
18286 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
18288 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
18290 memcpy (temp_input_buf
, input_buf
, input_len
);
18294 char *URI_server_pos
= temp_input_buf
+ 6;
18296 char *URI_client_pos
= strchr (URI_server_pos
, '*');
18298 if (URI_client_pos
== NULL
)
18300 myfree (temp_input_buf
);
18302 return (PARSER_SEPARATOR_UNMATCHED
);
18305 URI_client_pos
[0] = 0;
18308 uint URI_server_len
= strlen (URI_server_pos
);
18310 if (URI_server_len
> 512)
18312 myfree (temp_input_buf
);
18314 return (PARSER_SALT_LENGTH
);
18319 char *user_pos
= strchr (URI_client_pos
, '*');
18321 if (user_pos
== NULL
)
18323 myfree (temp_input_buf
);
18325 return (PARSER_SEPARATOR_UNMATCHED
);
18331 uint URI_client_len
= strlen (URI_client_pos
);
18333 if (URI_client_len
> 512)
18335 myfree (temp_input_buf
);
18337 return (PARSER_SALT_LENGTH
);
18342 char *realm_pos
= strchr (user_pos
, '*');
18344 if (realm_pos
== NULL
)
18346 myfree (temp_input_buf
);
18348 return (PARSER_SEPARATOR_UNMATCHED
);
18354 uint user_len
= strlen (user_pos
);
18356 if (user_len
> 116)
18358 myfree (temp_input_buf
);
18360 return (PARSER_SALT_LENGTH
);
18365 char *method_pos
= strchr (realm_pos
, '*');
18367 if (method_pos
== NULL
)
18369 myfree (temp_input_buf
);
18371 return (PARSER_SEPARATOR_UNMATCHED
);
18377 uint realm_len
= strlen (realm_pos
);
18379 if (realm_len
> 116)
18381 myfree (temp_input_buf
);
18383 return (PARSER_SALT_LENGTH
);
18388 char *URI_prefix_pos
= strchr (method_pos
, '*');
18390 if (URI_prefix_pos
== NULL
)
18392 myfree (temp_input_buf
);
18394 return (PARSER_SEPARATOR_UNMATCHED
);
18397 URI_prefix_pos
[0] = 0;
18400 uint method_len
= strlen (method_pos
);
18402 if (method_len
> 246)
18404 myfree (temp_input_buf
);
18406 return (PARSER_SALT_LENGTH
);
18411 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
18413 if (URI_resource_pos
== NULL
)
18415 myfree (temp_input_buf
);
18417 return (PARSER_SEPARATOR_UNMATCHED
);
18420 URI_resource_pos
[0] = 0;
18421 URI_resource_pos
++;
18423 uint URI_prefix_len
= strlen (URI_prefix_pos
);
18425 if (URI_prefix_len
> 245)
18427 myfree (temp_input_buf
);
18429 return (PARSER_SALT_LENGTH
);
18434 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
18436 if (URI_suffix_pos
== NULL
)
18438 myfree (temp_input_buf
);
18440 return (PARSER_SEPARATOR_UNMATCHED
);
18443 URI_suffix_pos
[0] = 0;
18446 uint URI_resource_len
= strlen (URI_resource_pos
);
18448 if (URI_resource_len
< 1 || URI_resource_len
> 246)
18450 myfree (temp_input_buf
);
18452 return (PARSER_SALT_LENGTH
);
18457 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
18459 if (nonce_pos
== NULL
)
18461 myfree (temp_input_buf
);
18463 return (PARSER_SEPARATOR_UNMATCHED
);
18469 uint URI_suffix_len
= strlen (URI_suffix_pos
);
18471 if (URI_suffix_len
> 245)
18473 myfree (temp_input_buf
);
18475 return (PARSER_SALT_LENGTH
);
18480 char *nonce_client_pos
= strchr (nonce_pos
, '*');
18482 if (nonce_client_pos
== NULL
)
18484 myfree (temp_input_buf
);
18486 return (PARSER_SEPARATOR_UNMATCHED
);
18489 nonce_client_pos
[0] = 0;
18490 nonce_client_pos
++;
18492 uint nonce_len
= strlen (nonce_pos
);
18494 if (nonce_len
< 1 || nonce_len
> 50)
18496 myfree (temp_input_buf
);
18498 return (PARSER_SALT_LENGTH
);
18503 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18505 if (nonce_count_pos
== NULL
)
18507 myfree (temp_input_buf
);
18509 return (PARSER_SEPARATOR_UNMATCHED
);
18512 nonce_count_pos
[0] = 0;
18515 uint nonce_client_len
= strlen (nonce_client_pos
);
18517 if (nonce_client_len
> 50)
18519 myfree (temp_input_buf
);
18521 return (PARSER_SALT_LENGTH
);
18526 char *qop_pos
= strchr (nonce_count_pos
, '*');
18528 if (qop_pos
== NULL
)
18530 myfree (temp_input_buf
);
18532 return (PARSER_SEPARATOR_UNMATCHED
);
18538 uint nonce_count_len
= strlen (nonce_count_pos
);
18540 if (nonce_count_len
> 50)
18542 myfree (temp_input_buf
);
18544 return (PARSER_SALT_LENGTH
);
18549 char *directive_pos
= strchr (qop_pos
, '*');
18551 if (directive_pos
== NULL
)
18553 myfree (temp_input_buf
);
18555 return (PARSER_SEPARATOR_UNMATCHED
);
18558 directive_pos
[0] = 0;
18561 uint qop_len
= strlen (qop_pos
);
18565 myfree (temp_input_buf
);
18567 return (PARSER_SALT_LENGTH
);
18572 char *digest_pos
= strchr (directive_pos
, '*');
18574 if (digest_pos
== NULL
)
18576 myfree (temp_input_buf
);
18578 return (PARSER_SEPARATOR_UNMATCHED
);
18584 uint directive_len
= strlen (directive_pos
);
18586 if (directive_len
!= 3)
18588 myfree (temp_input_buf
);
18590 return (PARSER_SALT_LENGTH
);
18593 if (memcmp (directive_pos
, "MD5", 3))
18595 log_info ("ERROR: only the MD5 directive is currently supported\n");
18597 myfree (temp_input_buf
);
18599 return (PARSER_SIP_AUTH_DIRECTIVE
);
18603 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18608 uint md5_max_len
= 4 * 64;
18610 uint md5_remaining_len
= md5_max_len
;
18612 uint tmp_md5_buf
[64] = { 0 };
18614 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18616 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18618 md5_len
+= method_len
+ 1;
18619 tmp_md5_ptr
+= method_len
+ 1;
18621 if (URI_prefix_len
> 0)
18623 md5_remaining_len
= md5_max_len
- md5_len
;
18625 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18627 md5_len
+= URI_prefix_len
+ 1;
18628 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18631 md5_remaining_len
= md5_max_len
- md5_len
;
18633 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18635 md5_len
+= URI_resource_len
;
18636 tmp_md5_ptr
+= URI_resource_len
;
18638 if (URI_suffix_len
> 0)
18640 md5_remaining_len
= md5_max_len
- md5_len
;
18642 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18644 md5_len
+= 1 + URI_suffix_len
;
18647 uint tmp_digest
[4] = { 0 };
18649 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18651 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18652 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18653 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18654 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18660 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18662 uint esalt_len
= 0;
18664 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18666 // there are 2 possibilities for the esalt:
18668 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18670 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18672 if (esalt_len
> max_esalt_len
)
18674 myfree (temp_input_buf
);
18676 return (PARSER_SALT_LENGTH
);
18679 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18691 esalt_len
= 1 + nonce_len
+ 1 + 32;
18693 if (esalt_len
> max_esalt_len
)
18695 myfree (temp_input_buf
);
18697 return (PARSER_SALT_LENGTH
);
18700 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18708 // add 0x80 to esalt
18710 esalt_buf_ptr
[esalt_len
] = 0x80;
18712 sip
->esalt_len
= esalt_len
;
18718 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18720 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18722 uint max_salt_len
= 119;
18724 if (salt_len
> max_salt_len
)
18726 myfree (temp_input_buf
);
18728 return (PARSER_SALT_LENGTH
);
18731 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18733 sip
->salt_len
= salt_len
;
18736 * fake salt (for sorting)
18739 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18743 uint fake_salt_len
= salt_len
;
18745 if (fake_salt_len
> max_salt_len
)
18747 fake_salt_len
= max_salt_len
;
18750 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18752 salt
->salt_len
= fake_salt_len
;
18758 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18759 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18760 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18761 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18763 digest
[0] = byte_swap_32 (digest
[0]);
18764 digest
[1] = byte_swap_32 (digest
[1]);
18765 digest
[2] = byte_swap_32 (digest
[2]);
18766 digest
[3] = byte_swap_32 (digest
[3]);
18768 myfree (temp_input_buf
);
18770 return (PARSER_OK
);
18773 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18775 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18777 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18779 u32
*digest
= (u32
*) hash_buf
->digest
;
18781 salt_t
*salt
= hash_buf
->salt
;
18785 char *digest_pos
= input_buf
;
18787 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18794 char *salt_buf
= input_buf
+ 8 + 1;
18798 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18800 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18802 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18804 salt
->salt_len
= salt_len
;
18806 return (PARSER_OK
);
18809 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18811 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18813 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18815 u32
*digest
= (u32
*) hash_buf
->digest
;
18817 salt_t
*salt
= hash_buf
->salt
;
18819 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18825 char *p_buf_pos
= input_buf
+ 4;
18827 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18829 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18831 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18833 NumCyclesPower_pos
++;
18835 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18837 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18839 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18843 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18845 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18847 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18851 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18853 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18855 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18859 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18861 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18863 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18867 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18869 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18871 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18875 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18877 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18879 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18883 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18885 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18887 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18891 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18893 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18895 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18899 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;
18901 const uint iter
= atoi (NumCyclesPower_pos
);
18902 const uint crc
= atoi (crc_buf_pos
);
18903 const uint p_buf
= atoi (p_buf_pos
);
18904 const uint salt_len
= atoi (salt_len_pos
);
18905 const uint iv_len
= atoi (iv_len_pos
);
18906 const uint unpack_size
= atoi (unpack_size_pos
);
18907 const uint data_len
= atoi (data_len_pos
);
18913 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18914 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18916 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18918 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18920 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18926 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18927 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18928 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18929 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18931 seven_zip
->iv_len
= iv_len
;
18933 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18935 seven_zip
->salt_len
= 0;
18937 seven_zip
->crc
= crc
;
18939 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18941 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18943 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18946 seven_zip
->data_len
= data_len
;
18948 seven_zip
->unpack_size
= unpack_size
;
18952 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18953 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18954 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18955 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18957 salt
->salt_len
= 16;
18959 salt
->salt_sign
[0] = iter
;
18961 salt
->salt_iter
= 1 << iter
;
18972 return (PARSER_OK
);
18975 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18977 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18979 u32
*digest
= (u32
*) hash_buf
->digest
;
18981 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18982 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18983 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18984 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18985 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18986 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18987 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18988 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18990 digest
[0] = byte_swap_32 (digest
[0]);
18991 digest
[1] = byte_swap_32 (digest
[1]);
18992 digest
[2] = byte_swap_32 (digest
[2]);
18993 digest
[3] = byte_swap_32 (digest
[3]);
18994 digest
[4] = byte_swap_32 (digest
[4]);
18995 digest
[5] = byte_swap_32 (digest
[5]);
18996 digest
[6] = byte_swap_32 (digest
[6]);
18997 digest
[7] = byte_swap_32 (digest
[7]);
18999 return (PARSER_OK
);
19002 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19004 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
19006 u32
*digest
= (u32
*) hash_buf
->digest
;
19008 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19009 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19010 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
19011 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
19012 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
19013 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
19014 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
19015 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
19016 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
19017 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
19018 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
19019 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
19020 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
19021 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
19022 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
19023 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
19025 digest
[ 0] = byte_swap_32 (digest
[ 0]);
19026 digest
[ 1] = byte_swap_32 (digest
[ 1]);
19027 digest
[ 2] = byte_swap_32 (digest
[ 2]);
19028 digest
[ 3] = byte_swap_32 (digest
[ 3]);
19029 digest
[ 4] = byte_swap_32 (digest
[ 4]);
19030 digest
[ 5] = byte_swap_32 (digest
[ 5]);
19031 digest
[ 6] = byte_swap_32 (digest
[ 6]);
19032 digest
[ 7] = byte_swap_32 (digest
[ 7]);
19033 digest
[ 8] = byte_swap_32 (digest
[ 8]);
19034 digest
[ 9] = byte_swap_32 (digest
[ 9]);
19035 digest
[10] = byte_swap_32 (digest
[10]);
19036 digest
[11] = byte_swap_32 (digest
[11]);
19037 digest
[12] = byte_swap_32 (digest
[12]);
19038 digest
[13] = byte_swap_32 (digest
[13]);
19039 digest
[14] = byte_swap_32 (digest
[14]);
19040 digest
[15] = byte_swap_32 (digest
[15]);
19042 return (PARSER_OK
);
19045 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19047 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
19049 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
19051 u32
*digest
= (u32
*) hash_buf
->digest
;
19053 salt_t
*salt
= hash_buf
->salt
;
19055 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
19063 char *iter_pos
= input_buf
+ 4;
19065 u32 iter
= atoi (iter_pos
);
19067 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19068 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19070 // first is *raw* salt
19072 char *salt_pos
= strchr (iter_pos
, ':');
19074 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19078 char *hash_pos
= strchr (salt_pos
, ':');
19080 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19082 u32 salt_len
= hash_pos
- salt_pos
;
19084 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19088 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19090 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19094 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
19096 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19098 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19100 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19101 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19103 salt
->salt_len
= salt_len
;
19104 salt
->salt_iter
= iter
- 1;
19108 u8 tmp_buf
[100] = { 0 };
19110 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19112 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19114 memcpy (digest
, tmp_buf
, 16);
19116 // add some stuff to normal salt to make sorted happy
19118 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
19119 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
19120 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
19121 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
19122 salt
->salt_buf
[4] = salt
->salt_iter
;
19124 return (PARSER_OK
);
19127 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19129 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
19131 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
19133 u32
*digest
= (u32
*) hash_buf
->digest
;
19135 salt_t
*salt
= hash_buf
->salt
;
19137 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
19145 char *iter_pos
= input_buf
+ 5;
19147 u32 iter
= atoi (iter_pos
);
19149 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19150 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19152 // first is *raw* salt
19154 char *salt_pos
= strchr (iter_pos
, ':');
19156 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19160 char *hash_pos
= strchr (salt_pos
, ':');
19162 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19164 u32 salt_len
= hash_pos
- salt_pos
;
19166 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19170 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19172 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19176 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
19178 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19180 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19182 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19183 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19185 salt
->salt_len
= salt_len
;
19186 salt
->salt_iter
= iter
- 1;
19190 u8 tmp_buf
[100] = { 0 };
19192 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19194 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19196 memcpy (digest
, tmp_buf
, 16);
19198 digest
[0] = byte_swap_32 (digest
[0]);
19199 digest
[1] = byte_swap_32 (digest
[1]);
19200 digest
[2] = byte_swap_32 (digest
[2]);
19201 digest
[3] = byte_swap_32 (digest
[3]);
19203 // add some stuff to normal salt to make sorted happy
19205 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
19206 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
19207 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
19208 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
19209 salt
->salt_buf
[4] = salt
->salt_iter
;
19211 return (PARSER_OK
);
19214 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19216 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
19218 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
19220 u64
*digest
= (u64
*) hash_buf
->digest
;
19222 salt_t
*salt
= hash_buf
->salt
;
19224 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
19232 char *iter_pos
= input_buf
+ 7;
19234 u32 iter
= atoi (iter_pos
);
19236 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19237 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19239 // first is *raw* salt
19241 char *salt_pos
= strchr (iter_pos
, ':');
19243 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19247 char *hash_pos
= strchr (salt_pos
, ':');
19249 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19251 u32 salt_len
= hash_pos
- salt_pos
;
19253 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19257 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19259 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19263 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
19265 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19267 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19269 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19270 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19272 salt
->salt_len
= salt_len
;
19273 salt
->salt_iter
= iter
- 1;
19277 u8 tmp_buf
[100] = { 0 };
19279 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19281 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19283 memcpy (digest
, tmp_buf
, 64);
19285 digest
[0] = byte_swap_64 (digest
[0]);
19286 digest
[1] = byte_swap_64 (digest
[1]);
19287 digest
[2] = byte_swap_64 (digest
[2]);
19288 digest
[3] = byte_swap_64 (digest
[3]);
19289 digest
[4] = byte_swap_64 (digest
[4]);
19290 digest
[5] = byte_swap_64 (digest
[5]);
19291 digest
[6] = byte_swap_64 (digest
[6]);
19292 digest
[7] = byte_swap_64 (digest
[7]);
19294 // add some stuff to normal salt to make sorted happy
19296 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
19297 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
19298 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
19299 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
19300 salt
->salt_buf
[4] = salt
->salt_iter
;
19302 return (PARSER_OK
);
19305 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19307 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
19309 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
19311 uint
*digest
= (uint
*) hash_buf
->digest
;
19313 salt_t
*salt
= hash_buf
->salt
;
19319 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
19321 char *hash_pos
= strchr (salt_pos
, '$');
19323 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19325 u32 salt_len
= hash_pos
- salt_pos
;
19327 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19331 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
19333 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
19337 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
19338 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
19356 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19357 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19359 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
19360 salt
->salt_len
= 8;
19362 return (PARSER_OK
);
19365 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19367 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
19369 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19371 unsigned char c19
= itoa64_to_int (input_buf
[19]);
19373 if (c19
& 3) return (PARSER_HASH_VALUE
);
19375 salt_t
*salt
= hash_buf
->salt
;
19377 u32
*digest
= (u32
*) hash_buf
->digest
;
19381 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
19382 | itoa64_to_int (input_buf
[2]) << 6
19383 | itoa64_to_int (input_buf
[3]) << 12
19384 | itoa64_to_int (input_buf
[4]) << 18;
19388 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
19389 | itoa64_to_int (input_buf
[6]) << 6
19390 | itoa64_to_int (input_buf
[7]) << 12
19391 | itoa64_to_int (input_buf
[8]) << 18;
19393 salt
->salt_len
= 4;
19395 u8 tmp_buf
[100] = { 0 };
19397 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
19399 memcpy (digest
, tmp_buf
, 8);
19403 IP (digest
[0], digest
[1], tt
);
19405 digest
[0] = rotr32 (digest
[0], 31);
19406 digest
[1] = rotr32 (digest
[1], 31);
19410 return (PARSER_OK
);
19413 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19415 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
19417 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
19419 u32
*digest
= (u32
*) hash_buf
->digest
;
19421 salt_t
*salt
= hash_buf
->salt
;
19427 char *type_pos
= input_buf
+ 6 + 1;
19429 char *salt_pos
= strchr (type_pos
, '*');
19431 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19433 u32 type_len
= salt_pos
- type_pos
;
19435 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
19439 char *crypted_pos
= strchr (salt_pos
, '*');
19441 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19443 u32 salt_len
= crypted_pos
- salt_pos
;
19445 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19449 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
19451 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
19457 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19458 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19460 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19461 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19463 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
19464 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
19465 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
19466 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
19468 salt
->salt_len
= 24;
19469 salt
->salt_iter
= ROUNDS_RAR3
;
19471 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
19472 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
19474 digest
[0] = 0xc43d7b00;
19475 digest
[1] = 0x40070000;
19479 return (PARSER_OK
);
19482 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19484 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19486 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19488 u32
*digest
= (u32
*) hash_buf
->digest
;
19490 salt_t
*salt
= hash_buf
->salt
;
19492 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19498 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19500 char *param1_pos
= strchr (param0_pos
, '$');
19502 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19504 u32 param0_len
= param1_pos
- param0_pos
;
19508 char *param2_pos
= strchr (param1_pos
, '$');
19510 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19512 u32 param1_len
= param2_pos
- param1_pos
;
19516 char *param3_pos
= strchr (param2_pos
, '$');
19518 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19520 u32 param2_len
= param3_pos
- param2_pos
;
19524 char *param4_pos
= strchr (param3_pos
, '$');
19526 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19528 u32 param3_len
= param4_pos
- param3_pos
;
19532 char *param5_pos
= strchr (param4_pos
, '$');
19534 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19536 u32 param4_len
= param5_pos
- param4_pos
;
19540 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19542 char *salt_buf
= param1_pos
;
19543 char *iv
= param3_pos
;
19544 char *pswcheck
= param5_pos
;
19546 const uint salt_len
= atoi (param0_pos
);
19547 const uint iterations
= atoi (param2_pos
);
19548 const uint pswcheck_len
= atoi (param4_pos
);
19554 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19555 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19556 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19558 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19559 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19560 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19566 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19567 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19568 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19569 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19571 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19572 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19573 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19574 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19576 salt
->salt_len
= 16;
19578 salt
->salt_sign
[0] = iterations
;
19580 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19586 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19587 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19591 return (PARSER_OK
);
19594 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19596 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19598 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19600 u32
*digest
= (u32
*) hash_buf
->digest
;
19602 salt_t
*salt
= hash_buf
->salt
;
19604 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19611 char *account_pos
= input_buf
+ 11 + 1;
19617 if (account_pos
[0] == '*')
19621 data_pos
= strchr (account_pos
, '*');
19626 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19628 uint account_len
= data_pos
- account_pos
+ 1;
19630 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19635 data_len
= input_len
- 11 - 1 - account_len
- 2;
19637 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19641 /* assume $krb5tgs$23$checksum$edata2 */
19642 data_pos
= account_pos
;
19644 memcpy (krb5tgs
->account_info
, "**", 3);
19646 data_len
= input_len
- 11 - 1 - 1;
19649 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19651 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19653 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19655 const char p0
= data_pos
[i
+ 0];
19656 const char p1
= data_pos
[i
+ 1];
19658 *checksum_ptr
++ = hex_convert (p1
) << 0
19659 | hex_convert (p0
) << 4;
19662 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19664 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19667 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19669 const char p0
= data_pos
[i
+ 0];
19670 const char p1
= data_pos
[i
+ 1];
19671 *edata_ptr
++ = hex_convert (p1
) << 0
19672 | hex_convert (p0
) << 4;
19675 /* this is needed for hmac_md5 */
19676 *edata_ptr
++ = 0x80;
19678 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19679 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19680 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19681 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19683 salt
->salt_len
= 32;
19685 digest
[0] = krb5tgs
->checksum
[0];
19686 digest
[1] = krb5tgs
->checksum
[1];
19687 digest
[2] = krb5tgs
->checksum
[2];
19688 digest
[3] = krb5tgs
->checksum
[3];
19690 return (PARSER_OK
);
19693 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19695 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19697 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19699 u32
*digest
= (u32
*) hash_buf
->digest
;
19701 salt_t
*salt
= hash_buf
->salt
;
19708 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19712 char *wrapped_key_pos
;
19716 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19718 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19720 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19722 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19727 data_pos
= salt_pos
;
19729 wrapped_key_pos
= strchr (salt_pos
, '*');
19731 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19733 uint salt_len
= wrapped_key_pos
- salt_pos
;
19735 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19740 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19742 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19744 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19745 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19746 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19747 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19751 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19752 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19753 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19754 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19755 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19756 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19758 salt
->salt_len
= 40;
19760 digest
[0] = salt
->salt_buf
[0];
19761 digest
[1] = salt
->salt_buf
[1];
19762 digest
[2] = salt
->salt_buf
[2];
19763 digest
[3] = salt
->salt_buf
[3];
19765 return (PARSER_OK
);
19768 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19770 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19772 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19774 u32
*digest
= (u32
*) hash_buf
->digest
;
19776 salt_t
*salt
= hash_buf
->salt
;
19778 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19788 char *algorithm_pos
;
19790 char *final_random_seed_pos
;
19791 u32 final_random_seed_len
;
19793 char *transf_random_seed_pos
;
19794 u32 transf_random_seed_len
;
19799 /* default is no keyfile provided */
19800 char *keyfile_len_pos
;
19801 u32 keyfile_len
= 0;
19802 u32 is_keyfile_present
= 0;
19803 char *keyfile_inline_pos
;
19806 /* specific to version 1 */
19807 char *contents_len_pos
;
19809 char *contents_pos
;
19811 /* specific to version 2 */
19812 char *expected_bytes_pos
;
19813 u32 expected_bytes_len
;
19815 char *contents_hash_pos
;
19816 u32 contents_hash_len
;
19818 version_pos
= input_buf
+ 8 + 1 + 1;
19820 keepass
->version
= atoi (version_pos
);
19822 rounds_pos
= strchr (version_pos
, '*');
19824 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19828 salt
->salt_iter
= (atoi (rounds_pos
));
19830 algorithm_pos
= strchr (rounds_pos
, '*');
19832 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19836 keepass
->algorithm
= atoi (algorithm_pos
);
19838 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19840 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19842 final_random_seed_pos
++;
19844 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19845 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19846 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19847 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19849 if (keepass
->version
== 2)
19851 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19852 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19853 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19854 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19857 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19859 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19861 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19863 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19864 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19866 transf_random_seed_pos
++;
19868 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19869 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19870 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19871 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19872 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19873 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19874 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19875 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19877 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19879 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19881 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19883 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19887 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19888 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19889 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19890 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19892 if (keepass
->version
== 1)
19894 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19896 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19898 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19900 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19902 contents_hash_pos
++;
19904 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19905 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19906 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19907 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19908 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19909 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19910 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19911 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19913 /* get length of contents following */
19914 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19916 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19918 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19920 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19924 u32 inline_flag
= atoi (inline_flag_pos
);
19926 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19928 contents_len_pos
= strchr (inline_flag_pos
, '*');
19930 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19932 contents_len_pos
++;
19934 contents_len
= atoi (contents_len_pos
);
19936 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19938 contents_pos
= strchr (contents_len_pos
, '*');
19940 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19946 keepass
->contents_len
= contents_len
;
19948 contents_len
= contents_len
/ 4;
19950 keyfile_inline_pos
= strchr (contents_pos
, '*');
19952 u32 real_contents_len
;
19954 if (keyfile_inline_pos
== NULL
)
19955 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19958 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19959 keyfile_inline_pos
++;
19960 is_keyfile_present
= 1;
19963 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
19965 for (i
= 0; i
< contents_len
; i
++)
19966 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
19968 else if (keepass
->version
== 2)
19970 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
19972 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19974 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
19976 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19978 expected_bytes_pos
++;
19980 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
19981 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
19982 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
19983 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
19984 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
19985 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
19986 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
19987 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
19989 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
19991 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19993 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
19995 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
19997 contents_hash_pos
++;
19999 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
20000 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
20001 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
20002 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
20003 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
20004 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
20005 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
20006 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
20008 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
20010 if (keyfile_inline_pos
== NULL
)
20011 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
20014 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
20015 keyfile_inline_pos
++;
20016 is_keyfile_present
= 1;
20018 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
20021 if (is_keyfile_present
!= 0)
20023 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
20027 keyfile_len
= atoi (keyfile_len_pos
);
20029 keepass
->keyfile_len
= keyfile_len
;
20031 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20033 keyfile_pos
= strchr (keyfile_len_pos
, '*');
20035 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20039 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
20041 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20043 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
20044 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
20045 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
20046 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
20047 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
20048 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
20049 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
20050 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
20053 digest
[0] = keepass
->enc_iv
[0];
20054 digest
[1] = keepass
->enc_iv
[1];
20055 digest
[2] = keepass
->enc_iv
[2];
20056 digest
[3] = keepass
->enc_iv
[3];
20058 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
20059 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
20060 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
20061 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
20062 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
20063 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
20064 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
20065 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
20067 return (PARSER_OK
);
20070 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20072 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
20074 u32
*digest
= (u32
*) hash_buf
->digest
;
20076 salt_t
*salt
= hash_buf
->salt
;
20078 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20079 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20080 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20081 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20082 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20083 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20084 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20085 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20087 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20089 uint salt_len
= input_len
- 64 - 1;
20091 char *salt_buf
= input_buf
+ 64 + 1;
20093 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
20095 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
20097 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
20099 salt
->salt_len
= salt_len
;
20102 * we can precompute the first sha256 transform
20105 uint w
[16] = { 0 };
20107 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
20108 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
20109 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
20110 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
20111 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
20112 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
20113 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
20114 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
20115 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
20116 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
20117 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
20118 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
20119 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
20120 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
20121 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
20122 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
20124 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
20126 sha256_64 (w
, pc256
);
20128 salt
->salt_buf_pc
[0] = pc256
[0];
20129 salt
->salt_buf_pc
[1] = pc256
[1];
20130 salt
->salt_buf_pc
[2] = pc256
[2];
20131 salt
->salt_buf_pc
[3] = pc256
[3];
20132 salt
->salt_buf_pc
[4] = pc256
[4];
20133 salt
->salt_buf_pc
[5] = pc256
[5];
20134 salt
->salt_buf_pc
[6] = pc256
[6];
20135 salt
->salt_buf_pc
[7] = pc256
[7];
20137 digest
[0] -= pc256
[0];
20138 digest
[1] -= pc256
[1];
20139 digest
[2] -= pc256
[2];
20140 digest
[3] -= pc256
[3];
20141 digest
[4] -= pc256
[4];
20142 digest
[5] -= pc256
[5];
20143 digest
[6] -= pc256
[6];
20144 digest
[7] -= pc256
[7];
20146 return (PARSER_OK
);
20149 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20151 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
20153 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
20155 u32
*digest
= (u32
*) hash_buf
->digest
;
20157 salt_t
*salt
= hash_buf
->salt
;
20163 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
20165 char *data_buf_pos
= strchr (data_len_pos
, '$');
20167 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20169 u32 data_len_len
= data_buf_pos
- data_len_pos
;
20171 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
20172 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
20176 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
20178 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
20180 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
20182 u32 data_len
= atoi (data_len_pos
);
20184 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
20190 char *salt_pos
= data_buf_pos
;
20192 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20193 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20194 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
20195 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
20197 // this is actually the CT, which is also the hash later (if matched)
20199 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
20200 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
20201 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
20202 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
20204 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
20206 salt
->salt_iter
= 10 - 1;
20212 digest
[0] = salt
->salt_buf
[4];
20213 digest
[1] = salt
->salt_buf
[5];
20214 digest
[2] = salt
->salt_buf
[6];
20215 digest
[3] = salt
->salt_buf
[7];
20217 return (PARSER_OK
);
20220 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20222 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
20224 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
20226 u32
*digest
= (u32
*) hash_buf
->digest
;
20228 salt_t
*salt
= hash_buf
->salt
;
20234 char *salt_pos
= input_buf
+ 11 + 1;
20236 char *iter_pos
= strchr (salt_pos
, ',');
20238 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20240 u32 salt_len
= iter_pos
- salt_pos
;
20242 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
20246 char *hash_pos
= strchr (iter_pos
, ',');
20248 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20250 u32 iter_len
= hash_pos
- iter_pos
;
20252 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
20256 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
20258 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
20264 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20265 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20266 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
20267 salt
->salt_buf
[3] = 0x00018000;
20269 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
20270 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
20271 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
20272 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
20274 salt
->salt_len
= salt_len
/ 2;
20276 salt
->salt_iter
= atoi (iter_pos
) - 1;
20282 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20283 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20284 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20285 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20286 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20287 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20288 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20289 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20291 return (PARSER_OK
);
20294 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20296 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
20298 u32
*digest
= (u32
*) hash_buf
->digest
;
20300 salt_t
*salt
= hash_buf
->salt
;
20306 char *hash_pos
= input_buf
+ 64;
20307 char *salt1_pos
= input_buf
+ 128;
20308 char *salt2_pos
= input_buf
;
20314 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
20315 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
20316 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
20317 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
20319 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
20320 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
20321 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
20322 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
20324 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
20325 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
20326 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
20327 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
20329 salt
->salt_len
= 48;
20331 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
20337 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20338 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20339 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20340 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20341 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20342 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20343 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20344 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20346 return (PARSER_OK
);
20349 int zip2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20351 if ((input_len
< DISPLAY_LEN_MIN_13600
) || (input_len
> DISPLAY_LEN_MAX_13600
)) return (PARSER_GLOBAL_LENGTH
);
20353 if (memcmp (SIGNATURE_ZIP2_START
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
20354 if (memcmp (SIGNATURE_ZIP2_STOP
, input_buf
+ input_len
- 7, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
20356 u32
*digest
= (u32
*) hash_buf
->digest
;
20358 salt_t
*salt
= hash_buf
->salt
;
20360 zip2_t
*zip2
= (zip2_t
*) hash_buf
->esalt
;
20366 char *param0_pos
= input_buf
+ 6 + 1;
20368 char *param1_pos
= strchr (param0_pos
, '*');
20370 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20372 u32 param0_len
= param1_pos
- param0_pos
;
20376 char *param2_pos
= strchr (param1_pos
, '*');
20378 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20380 u32 param1_len
= param2_pos
- param1_pos
;
20384 char *param3_pos
= strchr (param2_pos
, '*');
20386 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20388 u32 param2_len
= param3_pos
- param2_pos
;
20392 char *param4_pos
= strchr (param3_pos
, '*');
20394 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20396 u32 param3_len
= param4_pos
- param3_pos
;
20400 char *param5_pos
= strchr (param4_pos
, '*');
20402 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20404 u32 param4_len
= param5_pos
- param4_pos
;
20408 char *param6_pos
= strchr (param5_pos
, '*');
20410 if (param6_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20412 u32 param5_len
= param6_pos
- param5_pos
;
20416 char *param7_pos
= strchr (param6_pos
, '*');
20418 if (param7_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20420 u32 param6_len
= param7_pos
- param6_pos
;
20424 char *param8_pos
= strchr (param7_pos
, '*');
20426 if (param8_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20428 u32 param7_len
= param8_pos
- param7_pos
;
20432 const uint type
= atoi (param0_pos
);
20433 const uint mode
= atoi (param1_pos
);
20434 const uint magic
= atoi (param2_pos
);
20436 char *salt_buf
= param3_pos
;
20438 uint verify_bytes
; sscanf (param4_pos
, "%4x*", &verify_bytes
);
20440 const uint compress_length
= atoi (param5_pos
);
20442 char *data_buf
= param6_pos
;
20443 char *auth
= param7_pos
;
20449 if (param0_len
!= 1) return (PARSER_SALT_VALUE
);
20451 if (param1_len
!= 1) return (PARSER_SALT_VALUE
);
20453 if (param2_len
!= 1) return (PARSER_SALT_VALUE
);
20455 if ((param3_len
!= 16) && (param3_len
!= 24) && (param3_len
!= 32)) return (PARSER_SALT_VALUE
);
20457 if (param4_len
>= 5) return (PARSER_SALT_VALUE
);
20459 if (param5_len
>= 5) return (PARSER_SALT_VALUE
);
20461 if (param6_len
>= 8192) return (PARSER_SALT_VALUE
);
20463 if (param6_len
& 1) return (PARSER_SALT_VALUE
);
20465 if (param7_len
!= 20) return (PARSER_SALT_VALUE
);
20467 if (type
!= 0) return (PARSER_SALT_VALUE
);
20469 if ((mode
!= 1) && (mode
!= 2) && (mode
!= 3)) return (PARSER_SALT_VALUE
);
20471 if (magic
!= 0) return (PARSER_SALT_VALUE
);
20473 if (verify_bytes
>= 0x10000) return (PARSER_SALT_VALUE
);
20481 zip2
->magic
= magic
;
20485 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20486 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20487 zip2
->salt_buf
[2] = 0;
20488 zip2
->salt_buf
[3] = 0;
20490 zip2
->salt_len
= 8;
20492 else if (mode
== 2)
20494 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20495 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20496 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20497 zip2
->salt_buf
[3] = 0;
20499 zip2
->salt_len
= 12;
20501 else if (mode
== 3)
20503 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20504 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20505 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20506 zip2
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
20508 zip2
->salt_len
= 16;
20511 zip2
->salt_buf
[0] = byte_swap_32 (zip2
->salt_buf
[0]);
20512 zip2
->salt_buf
[1] = byte_swap_32 (zip2
->salt_buf
[1]);
20513 zip2
->salt_buf
[2] = byte_swap_32 (zip2
->salt_buf
[2]);
20514 zip2
->salt_buf
[3] = byte_swap_32 (zip2
->salt_buf
[3]);
20516 zip2
->verify_bytes
= verify_bytes
;
20518 zip2
->compress_length
= compress_length
;
20520 char *data_buf_ptr
= (char *) zip2
->data_buf
;
20522 for (uint i
= 0; i
< param6_len
; i
+= 2)
20524 const char p0
= data_buf
[i
+ 0];
20525 const char p1
= data_buf
[i
+ 1];
20527 *data_buf_ptr
++ = hex_convert (p1
) << 0
20528 | hex_convert (p0
) << 4;
20533 *data_buf_ptr
= 0x80;
20535 char *auth_ptr
= (char *) zip2
->auth_buf
;
20537 for (uint i
= 0; i
< param7_len
; i
+= 2)
20539 const char p0
= auth
[i
+ 0];
20540 const char p1
= auth
[i
+ 1];
20542 *auth_ptr
++ = hex_convert (p1
) << 0
20543 | hex_convert (p0
) << 4;
20552 salt
->salt_buf
[0] = zip2
->salt_buf
[0];
20553 salt
->salt_buf
[1] = zip2
->salt_buf
[1];
20554 salt
->salt_buf
[2] = zip2
->salt_buf
[2];
20555 salt
->salt_buf
[3] = zip2
->salt_buf
[3];
20556 salt
->salt_buf
[4] = zip2
->data_buf
[0];
20557 salt
->salt_buf
[5] = zip2
->data_buf
[1];
20558 salt
->salt_buf
[6] = zip2
->data_buf
[2];
20559 salt
->salt_buf
[7] = zip2
->data_buf
[3];
20561 salt
->salt_len
= 32;
20563 salt
->salt_iter
= ROUNDS_ZIP2
- 1;
20566 * digest buf (fake)
20569 digest
[0] = zip2
->auth_buf
[0];
20570 digest
[1] = zip2
->auth_buf
[1];
20571 digest
[2] = zip2
->auth_buf
[2];
20572 digest
[3] = zip2
->auth_buf
[3];
20574 return (PARSER_OK
);
20577 int win8phone_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20579 if ((input_len
< DISPLAY_LEN_MIN_13800
) || (input_len
> DISPLAY_LEN_MAX_13800
)) return (PARSER_GLOBAL_LENGTH
);
20581 u32
*digest
= (u32
*) hash_buf
->digest
;
20583 salt_t
*salt
= hash_buf
->salt
;
20585 win8phone_t
*esalt
= hash_buf
->esalt
;
20587 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20588 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20589 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20590 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20591 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20592 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20593 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20594 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20596 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20598 char *salt_buf_ptr
= input_buf
+ 64 + 1;
20600 u32
*salt_buf
= esalt
->salt_buf
;
20602 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
20604 salt_buf
[i
] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[j
]);
20607 salt
->salt_buf
[0] = salt_buf
[0];
20608 salt
->salt_buf
[1] = salt_buf
[1];
20609 salt
->salt_buf
[2] = salt_buf
[2];
20610 salt
->salt_buf
[3] = salt_buf
[3];
20611 salt
->salt_buf
[4] = salt_buf
[4];
20612 salt
->salt_buf
[5] = salt_buf
[5];
20613 salt
->salt_buf
[6] = salt_buf
[6];
20614 salt
->salt_buf
[7] = salt_buf
[7];
20616 salt
->salt_len
= 64;
20618 return (PARSER_OK
);
20622 * parallel running threads
20627 BOOL WINAPI
sigHandler_default (DWORD sig
)
20631 case CTRL_CLOSE_EVENT
:
20634 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
20635 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
20636 * function otherwise it is too late (e.g. after returning from this function)
20641 SetConsoleCtrlHandler (NULL
, TRUE
);
20648 case CTRL_LOGOFF_EVENT
:
20649 case CTRL_SHUTDOWN_EVENT
:
20653 SetConsoleCtrlHandler (NULL
, TRUE
);
20661 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
20665 case CTRL_CLOSE_EVENT
:
20669 SetConsoleCtrlHandler (NULL
, TRUE
);
20676 case CTRL_LOGOFF_EVENT
:
20677 case CTRL_SHUTDOWN_EVENT
:
20681 SetConsoleCtrlHandler (NULL
, TRUE
);
20689 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
20691 if (callback
== NULL
)
20693 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
20697 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
20703 void sigHandler_default (int sig
)
20707 signal (sig
, NULL
);
20710 void sigHandler_benchmark (int sig
)
20714 signal (sig
, NULL
);
20717 void hc_signal (void (callback
) (int))
20719 if (callback
== NULL
) callback
= SIG_DFL
;
20721 signal (SIGINT
, callback
);
20722 signal (SIGTERM
, callback
);
20723 signal (SIGABRT
, callback
);
20728 void status_display ();
20730 void *thread_keypress (void *p
)
20732 int benchmark
= *((int *) p
);
20734 uint quiet
= data
.quiet
;
20738 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
20740 int ch
= tty_getchar();
20742 if (ch
== -1) break;
20744 if (ch
== 0) continue;
20746 //https://github.com/hashcat/hashcat/issues/302
20751 hc_thread_mutex_lock (mux_display
);
20767 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20768 if (quiet
== 0) fflush (stdout
);
20780 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20781 if (quiet
== 0) fflush (stdout
);
20793 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20794 if (quiet
== 0) fflush (stdout
);
20806 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20807 if (quiet
== 0) fflush (stdout
);
20815 if (benchmark
== 1) break;
20817 stop_at_checkpoint ();
20821 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20822 if (quiet
== 0) fflush (stdout
);
20830 if (benchmark
== 1)
20842 //https://github.com/hashcat/hashcat/issues/302
20847 hc_thread_mutex_unlock (mux_display
);
20859 bool class_num (const u8 c
)
20861 return ((c
>= '0') && (c
<= '9'));
20864 bool class_lower (const u8 c
)
20866 return ((c
>= 'a') && (c
<= 'z'));
20869 bool class_upper (const u8 c
)
20871 return ((c
>= 'A') && (c
<= 'Z'));
20874 bool class_alpha (const u8 c
)
20876 return (class_lower (c
) || class_upper (c
));
20879 int conv_ctoi (const u8 c
)
20885 else if (class_upper (c
))
20887 return c
- 'A' + 10;
20893 int conv_itoc (const u8 c
)
20901 return c
+ 'A' - 10;
20911 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20912 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20913 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20914 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20915 #define MAX_KERNEL_RULES 255
20916 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20917 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20918 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20920 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20921 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20922 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20923 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20925 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20930 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20932 switch (rule_buf
[rule_pos
])
20938 case RULE_OP_MANGLE_NOOP
:
20939 SET_NAME (rule
, rule_buf
[rule_pos
]);
20942 case RULE_OP_MANGLE_LREST
:
20943 SET_NAME (rule
, rule_buf
[rule_pos
]);
20946 case RULE_OP_MANGLE_UREST
:
20947 SET_NAME (rule
, rule_buf
[rule_pos
]);
20950 case RULE_OP_MANGLE_LREST_UFIRST
:
20951 SET_NAME (rule
, rule_buf
[rule_pos
]);
20954 case RULE_OP_MANGLE_UREST_LFIRST
:
20955 SET_NAME (rule
, rule_buf
[rule_pos
]);
20958 case RULE_OP_MANGLE_TREST
:
20959 SET_NAME (rule
, rule_buf
[rule_pos
]);
20962 case RULE_OP_MANGLE_TOGGLE_AT
:
20963 SET_NAME (rule
, rule_buf
[rule_pos
]);
20964 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20967 case RULE_OP_MANGLE_REVERSE
:
20968 SET_NAME (rule
, rule_buf
[rule_pos
]);
20971 case RULE_OP_MANGLE_DUPEWORD
:
20972 SET_NAME (rule
, rule_buf
[rule_pos
]);
20975 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20976 SET_NAME (rule
, rule_buf
[rule_pos
]);
20977 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20980 case RULE_OP_MANGLE_REFLECT
:
20981 SET_NAME (rule
, rule_buf
[rule_pos
]);
20984 case RULE_OP_MANGLE_ROTATE_LEFT
:
20985 SET_NAME (rule
, rule_buf
[rule_pos
]);
20988 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20989 SET_NAME (rule
, rule_buf
[rule_pos
]);
20992 case RULE_OP_MANGLE_APPEND
:
20993 SET_NAME (rule
, rule_buf
[rule_pos
]);
20994 SET_P0 (rule
, rule_buf
[rule_pos
]);
20997 case RULE_OP_MANGLE_PREPEND
:
20998 SET_NAME (rule
, rule_buf
[rule_pos
]);
20999 SET_P0 (rule
, rule_buf
[rule_pos
]);
21002 case RULE_OP_MANGLE_DELETE_FIRST
:
21003 SET_NAME (rule
, rule_buf
[rule_pos
]);
21006 case RULE_OP_MANGLE_DELETE_LAST
:
21007 SET_NAME (rule
, rule_buf
[rule_pos
]);
21010 case RULE_OP_MANGLE_DELETE_AT
:
21011 SET_NAME (rule
, rule_buf
[rule_pos
]);
21012 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21015 case RULE_OP_MANGLE_EXTRACT
:
21016 SET_NAME (rule
, rule_buf
[rule_pos
]);
21017 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21018 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21021 case RULE_OP_MANGLE_OMIT
:
21022 SET_NAME (rule
, rule_buf
[rule_pos
]);
21023 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21024 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21027 case RULE_OP_MANGLE_INSERT
:
21028 SET_NAME (rule
, rule_buf
[rule_pos
]);
21029 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21030 SET_P1 (rule
, rule_buf
[rule_pos
]);
21033 case RULE_OP_MANGLE_OVERSTRIKE
:
21034 SET_NAME (rule
, rule_buf
[rule_pos
]);
21035 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21036 SET_P1 (rule
, rule_buf
[rule_pos
]);
21039 case RULE_OP_MANGLE_TRUNCATE_AT
:
21040 SET_NAME (rule
, rule_buf
[rule_pos
]);
21041 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21044 case RULE_OP_MANGLE_REPLACE
:
21045 SET_NAME (rule
, rule_buf
[rule_pos
]);
21046 SET_P0 (rule
, rule_buf
[rule_pos
]);
21047 SET_P1 (rule
, rule_buf
[rule_pos
]);
21050 case RULE_OP_MANGLE_PURGECHAR
:
21054 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21058 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21059 SET_NAME (rule
, rule_buf
[rule_pos
]);
21060 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21063 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21064 SET_NAME (rule
, rule_buf
[rule_pos
]);
21065 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21068 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21069 SET_NAME (rule
, rule_buf
[rule_pos
]);
21072 case RULE_OP_MANGLE_SWITCH_FIRST
:
21073 SET_NAME (rule
, rule_buf
[rule_pos
]);
21076 case RULE_OP_MANGLE_SWITCH_LAST
:
21077 SET_NAME (rule
, rule_buf
[rule_pos
]);
21080 case RULE_OP_MANGLE_SWITCH_AT
:
21081 SET_NAME (rule
, rule_buf
[rule_pos
]);
21082 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21083 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21086 case RULE_OP_MANGLE_CHR_SHIFTL
:
21087 SET_NAME (rule
, rule_buf
[rule_pos
]);
21088 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21091 case RULE_OP_MANGLE_CHR_SHIFTR
:
21092 SET_NAME (rule
, rule_buf
[rule_pos
]);
21093 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21096 case RULE_OP_MANGLE_CHR_INCR
:
21097 SET_NAME (rule
, rule_buf
[rule_pos
]);
21098 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21101 case RULE_OP_MANGLE_CHR_DECR
:
21102 SET_NAME (rule
, rule_buf
[rule_pos
]);
21103 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21106 case RULE_OP_MANGLE_REPLACE_NP1
:
21107 SET_NAME (rule
, rule_buf
[rule_pos
]);
21108 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21111 case RULE_OP_MANGLE_REPLACE_NM1
:
21112 SET_NAME (rule
, rule_buf
[rule_pos
]);
21113 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21116 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21117 SET_NAME (rule
, rule_buf
[rule_pos
]);
21118 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21121 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21122 SET_NAME (rule
, rule_buf
[rule_pos
]);
21123 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21126 case RULE_OP_MANGLE_TITLE
:
21127 SET_NAME (rule
, rule_buf
[rule_pos
]);
21136 if (rule_pos
< rule_len
) return (-1);
21141 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
21145 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
21149 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
21153 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
21157 case RULE_OP_MANGLE_NOOP
:
21158 rule_buf
[rule_pos
] = rule_cmd
;
21161 case RULE_OP_MANGLE_LREST
:
21162 rule_buf
[rule_pos
] = rule_cmd
;
21165 case RULE_OP_MANGLE_UREST
:
21166 rule_buf
[rule_pos
] = rule_cmd
;
21169 case RULE_OP_MANGLE_LREST_UFIRST
:
21170 rule_buf
[rule_pos
] = rule_cmd
;
21173 case RULE_OP_MANGLE_UREST_LFIRST
:
21174 rule_buf
[rule_pos
] = rule_cmd
;
21177 case RULE_OP_MANGLE_TREST
:
21178 rule_buf
[rule_pos
] = rule_cmd
;
21181 case RULE_OP_MANGLE_TOGGLE_AT
:
21182 rule_buf
[rule_pos
] = rule_cmd
;
21183 GET_P0_CONV (rule
);
21186 case RULE_OP_MANGLE_REVERSE
:
21187 rule_buf
[rule_pos
] = rule_cmd
;
21190 case RULE_OP_MANGLE_DUPEWORD
:
21191 rule_buf
[rule_pos
] = rule_cmd
;
21194 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21195 rule_buf
[rule_pos
] = rule_cmd
;
21196 GET_P0_CONV (rule
);
21199 case RULE_OP_MANGLE_REFLECT
:
21200 rule_buf
[rule_pos
] = rule_cmd
;
21203 case RULE_OP_MANGLE_ROTATE_LEFT
:
21204 rule_buf
[rule_pos
] = rule_cmd
;
21207 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21208 rule_buf
[rule_pos
] = rule_cmd
;
21211 case RULE_OP_MANGLE_APPEND
:
21212 rule_buf
[rule_pos
] = rule_cmd
;
21216 case RULE_OP_MANGLE_PREPEND
:
21217 rule_buf
[rule_pos
] = rule_cmd
;
21221 case RULE_OP_MANGLE_DELETE_FIRST
:
21222 rule_buf
[rule_pos
] = rule_cmd
;
21225 case RULE_OP_MANGLE_DELETE_LAST
:
21226 rule_buf
[rule_pos
] = rule_cmd
;
21229 case RULE_OP_MANGLE_DELETE_AT
:
21230 rule_buf
[rule_pos
] = rule_cmd
;
21231 GET_P0_CONV (rule
);
21234 case RULE_OP_MANGLE_EXTRACT
:
21235 rule_buf
[rule_pos
] = rule_cmd
;
21236 GET_P0_CONV (rule
);
21237 GET_P1_CONV (rule
);
21240 case RULE_OP_MANGLE_OMIT
:
21241 rule_buf
[rule_pos
] = rule_cmd
;
21242 GET_P0_CONV (rule
);
21243 GET_P1_CONV (rule
);
21246 case RULE_OP_MANGLE_INSERT
:
21247 rule_buf
[rule_pos
] = rule_cmd
;
21248 GET_P0_CONV (rule
);
21252 case RULE_OP_MANGLE_OVERSTRIKE
:
21253 rule_buf
[rule_pos
] = rule_cmd
;
21254 GET_P0_CONV (rule
);
21258 case RULE_OP_MANGLE_TRUNCATE_AT
:
21259 rule_buf
[rule_pos
] = rule_cmd
;
21260 GET_P0_CONV (rule
);
21263 case RULE_OP_MANGLE_REPLACE
:
21264 rule_buf
[rule_pos
] = rule_cmd
;
21269 case RULE_OP_MANGLE_PURGECHAR
:
21273 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21277 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21278 rule_buf
[rule_pos
] = rule_cmd
;
21279 GET_P0_CONV (rule
);
21282 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21283 rule_buf
[rule_pos
] = rule_cmd
;
21284 GET_P0_CONV (rule
);
21287 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21288 rule_buf
[rule_pos
] = rule_cmd
;
21291 case RULE_OP_MANGLE_SWITCH_FIRST
:
21292 rule_buf
[rule_pos
] = rule_cmd
;
21295 case RULE_OP_MANGLE_SWITCH_LAST
:
21296 rule_buf
[rule_pos
] = rule_cmd
;
21299 case RULE_OP_MANGLE_SWITCH_AT
:
21300 rule_buf
[rule_pos
] = rule_cmd
;
21301 GET_P0_CONV (rule
);
21302 GET_P1_CONV (rule
);
21305 case RULE_OP_MANGLE_CHR_SHIFTL
:
21306 rule_buf
[rule_pos
] = rule_cmd
;
21307 GET_P0_CONV (rule
);
21310 case RULE_OP_MANGLE_CHR_SHIFTR
:
21311 rule_buf
[rule_pos
] = rule_cmd
;
21312 GET_P0_CONV (rule
);
21315 case RULE_OP_MANGLE_CHR_INCR
:
21316 rule_buf
[rule_pos
] = rule_cmd
;
21317 GET_P0_CONV (rule
);
21320 case RULE_OP_MANGLE_CHR_DECR
:
21321 rule_buf
[rule_pos
] = rule_cmd
;
21322 GET_P0_CONV (rule
);
21325 case RULE_OP_MANGLE_REPLACE_NP1
:
21326 rule_buf
[rule_pos
] = rule_cmd
;
21327 GET_P0_CONV (rule
);
21330 case RULE_OP_MANGLE_REPLACE_NM1
:
21331 rule_buf
[rule_pos
] = rule_cmd
;
21332 GET_P0_CONV (rule
);
21335 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21336 rule_buf
[rule_pos
] = rule_cmd
;
21337 GET_P0_CONV (rule
);
21340 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21341 rule_buf
[rule_pos
] = rule_cmd
;
21342 GET_P0_CONV (rule
);
21345 case RULE_OP_MANGLE_TITLE
:
21346 rule_buf
[rule_pos
] = rule_cmd
;
21350 return rule_pos
- 1;
21368 * CPU rules : this is from hashcat sources, cpu based rules
21371 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
21372 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
21374 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
21375 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
21376 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
21378 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
21379 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
21380 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
21382 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
21386 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
21391 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
21395 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
21400 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
21404 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
21409 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
21414 for (l
= 0; l
< arr_len
; l
++)
21416 r
= arr_len
- 1 - l
;
21420 MANGLE_SWITCH (arr
, l
, r
);
21426 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
21428 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21430 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
21432 return (arr_len
* 2);
21435 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
21437 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21439 int orig_len
= arr_len
;
21443 for (i
= 0; i
< times
; i
++)
21445 memcpy (&arr
[arr_len
], arr
, orig_len
);
21447 arr_len
+= orig_len
;
21453 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
21455 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21457 mangle_double (arr
, arr_len
);
21459 mangle_reverse (arr
+ arr_len
, arr_len
);
21461 return (arr_len
* 2);
21464 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
21469 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
21471 MANGLE_SWITCH (arr
, l
, r
);
21477 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
21482 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
21484 MANGLE_SWITCH (arr
, l
, r
);
21490 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21492 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21496 return (arr_len
+ 1);
21499 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21501 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21505 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21507 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21512 return (arr_len
+ 1);
21515 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21517 if (upos
>= arr_len
) return (arr_len
);
21521 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
21523 arr
[arr_pos
] = arr
[arr_pos
+ 1];
21526 return (arr_len
- 1);
21529 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21531 if (upos
>= arr_len
) return (arr_len
);
21533 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
21537 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
21539 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
21545 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21547 if (upos
>= arr_len
) return (arr_len
);
21549 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
21553 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
21555 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
21558 return (arr_len
- ulen
);
21561 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21563 if (upos
>= arr_len
) return (arr_len
);
21565 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21569 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
21571 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21576 return (arr_len
+ 1);
21579 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
)
21581 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21583 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
21585 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
21587 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
21589 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
21591 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
21593 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
21595 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
21597 return (arr_len
+ arr2_cpy
);
21600 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21602 if (upos
>= arr_len
) return (arr_len
);
21609 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21611 if (upos
>= arr_len
) return (arr_len
);
21613 memset (arr
+ upos
, 0, arr_len
- upos
);
21618 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
21622 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21624 if (arr
[arr_pos
] != oldc
) continue;
21626 arr
[arr_pos
] = newc
;
21632 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21638 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21640 if (arr
[arr_pos
] == c
) continue;
21642 arr
[ret_len
] = arr
[arr_pos
];
21650 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21652 if (ulen
> arr_len
) return (arr_len
);
21654 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21656 char cs
[100] = { 0 };
21658 memcpy (cs
, arr
, ulen
);
21662 for (i
= 0; i
< ulen
; i
++)
21666 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
21672 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21674 if (ulen
> arr_len
) return (arr_len
);
21676 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21678 int upos
= arr_len
- ulen
;
21682 for (i
= 0; i
< ulen
; i
++)
21684 char c
= arr
[upos
+ i
];
21686 arr_len
= mangle_append (arr
, arr_len
, c
);
21692 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21694 if ( arr_len
== 0) return (arr_len
);
21695 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21697 char c
= arr
[upos
];
21701 for (i
= 0; i
< ulen
; i
++)
21703 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
21709 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
21711 if ( arr_len
== 0) return (arr_len
);
21712 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21716 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21718 int new_pos
= arr_pos
* 2;
21720 arr
[new_pos
] = arr
[arr_pos
];
21722 arr
[new_pos
+ 1] = arr
[arr_pos
];
21725 return (arr_len
* 2);
21728 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21730 if (upos
>= arr_len
) return (arr_len
);
21731 if (upos2
>= arr_len
) return (arr_len
);
21733 MANGLE_SWITCH (arr
, upos
, upos2
);
21738 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21740 MANGLE_SWITCH (arr
, upos
, upos2
);
21745 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21747 if (upos
>= arr_len
) return (arr_len
);
21754 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21756 if (upos
>= arr_len
) return (arr_len
);
21763 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21765 if (upos
>= arr_len
) return (arr_len
);
21772 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21774 if (upos
>= arr_len
) return (arr_len
);
21781 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21783 int upper_next
= 1;
21787 for (pos
= 0; pos
< arr_len
; pos
++)
21789 if (arr
[pos
] == ' ')
21800 MANGLE_UPPER_AT (arr
, pos
);
21804 MANGLE_LOWER_AT (arr
, pos
);
21811 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21813 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21819 for (j
= 0; j
< rp_gen_num
; j
++)
21826 switch ((char) get_random_num (0, 9))
21829 r
= get_random_num (0, sizeof (grp_op_nop
));
21830 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21834 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21835 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21836 p1
= get_random_num (0, sizeof (grp_pos
));
21837 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21841 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21842 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21843 p1
= get_random_num (1, 6);
21844 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21848 r
= get_random_num (0, sizeof (grp_op_chr
));
21849 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21850 p1
= get_random_num (0x20, 0x7e);
21851 rule_buf
[rule_pos
++] = (char) p1
;
21855 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21856 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21857 p1
= get_random_num (0x20, 0x7e);
21858 rule_buf
[rule_pos
++] = (char) p1
;
21859 p2
= get_random_num (0x20, 0x7e);
21861 p2
= get_random_num (0x20, 0x7e);
21862 rule_buf
[rule_pos
++] = (char) p2
;
21866 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21867 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21868 p1
= get_random_num (0, sizeof (grp_pos
));
21869 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21870 p2
= get_random_num (0x20, 0x7e);
21871 rule_buf
[rule_pos
++] = (char) p2
;
21875 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21876 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21877 p1
= get_random_num (0, sizeof (grp_pos
));
21878 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21879 p2
= get_random_num (0, sizeof (grp_pos
));
21881 p2
= get_random_num (0, sizeof (grp_pos
));
21882 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21886 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21887 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21888 p1
= get_random_num (0, sizeof (grp_pos
));
21889 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21890 p2
= get_random_num (1, sizeof (grp_pos
));
21892 p2
= get_random_num (1, sizeof (grp_pos
));
21893 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21897 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21898 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21899 p1
= get_random_num (0, sizeof (grp_pos
));
21900 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21901 p2
= get_random_num (1, sizeof (grp_pos
));
21902 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21903 p3
= get_random_num (0, sizeof (grp_pos
));
21904 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21912 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21914 char mem
[BLOCK_SIZE
] = { 0 };
21916 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21918 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21920 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21922 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21924 int out_len
= in_len
;
21925 int mem_len
= in_len
;
21927 memcpy (out
, in
, out_len
);
21931 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21936 switch (rule
[rule_pos
])
21941 case RULE_OP_MANGLE_NOOP
:
21944 case RULE_OP_MANGLE_LREST
:
21945 out_len
= mangle_lrest (out
, out_len
);
21948 case RULE_OP_MANGLE_UREST
:
21949 out_len
= mangle_urest (out
, out_len
);
21952 case RULE_OP_MANGLE_LREST_UFIRST
:
21953 out_len
= mangle_lrest (out
, out_len
);
21954 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21957 case RULE_OP_MANGLE_UREST_LFIRST
:
21958 out_len
= mangle_urest (out
, out_len
);
21959 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21962 case RULE_OP_MANGLE_TREST
:
21963 out_len
= mangle_trest (out
, out_len
);
21966 case RULE_OP_MANGLE_TOGGLE_AT
:
21967 NEXT_RULEPOS (rule_pos
);
21968 NEXT_RPTOI (rule
, rule_pos
, upos
);
21969 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21972 case RULE_OP_MANGLE_REVERSE
:
21973 out_len
= mangle_reverse (out
, out_len
);
21976 case RULE_OP_MANGLE_DUPEWORD
:
21977 out_len
= mangle_double (out
, out_len
);
21980 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21981 NEXT_RULEPOS (rule_pos
);
21982 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21983 out_len
= mangle_double_times (out
, out_len
, ulen
);
21986 case RULE_OP_MANGLE_REFLECT
:
21987 out_len
= mangle_reflect (out
, out_len
);
21990 case RULE_OP_MANGLE_ROTATE_LEFT
:
21991 mangle_rotate_left (out
, out_len
);
21994 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21995 mangle_rotate_right (out
, out_len
);
21998 case RULE_OP_MANGLE_APPEND
:
21999 NEXT_RULEPOS (rule_pos
);
22000 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
22003 case RULE_OP_MANGLE_PREPEND
:
22004 NEXT_RULEPOS (rule_pos
);
22005 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
22008 case RULE_OP_MANGLE_DELETE_FIRST
:
22009 out_len
= mangle_delete_at (out
, out_len
, 0);
22012 case RULE_OP_MANGLE_DELETE_LAST
:
22013 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
22016 case RULE_OP_MANGLE_DELETE_AT
:
22017 NEXT_RULEPOS (rule_pos
);
22018 NEXT_RPTOI (rule
, rule_pos
, upos
);
22019 out_len
= mangle_delete_at (out
, out_len
, upos
);
22022 case RULE_OP_MANGLE_EXTRACT
:
22023 NEXT_RULEPOS (rule_pos
);
22024 NEXT_RPTOI (rule
, rule_pos
, upos
);
22025 NEXT_RULEPOS (rule_pos
);
22026 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22027 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
22030 case RULE_OP_MANGLE_OMIT
:
22031 NEXT_RULEPOS (rule_pos
);
22032 NEXT_RPTOI (rule
, rule_pos
, upos
);
22033 NEXT_RULEPOS (rule_pos
);
22034 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22035 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
22038 case RULE_OP_MANGLE_INSERT
:
22039 NEXT_RULEPOS (rule_pos
);
22040 NEXT_RPTOI (rule
, rule_pos
, upos
);
22041 NEXT_RULEPOS (rule_pos
);
22042 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
22045 case RULE_OP_MANGLE_OVERSTRIKE
:
22046 NEXT_RULEPOS (rule_pos
);
22047 NEXT_RPTOI (rule
, rule_pos
, upos
);
22048 NEXT_RULEPOS (rule_pos
);
22049 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
22052 case RULE_OP_MANGLE_TRUNCATE_AT
:
22053 NEXT_RULEPOS (rule_pos
);
22054 NEXT_RPTOI (rule
, rule_pos
, upos
);
22055 out_len
= mangle_truncate_at (out
, out_len
, upos
);
22058 case RULE_OP_MANGLE_REPLACE
:
22059 NEXT_RULEPOS (rule_pos
);
22060 NEXT_RULEPOS (rule_pos
);
22061 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
22064 case RULE_OP_MANGLE_PURGECHAR
:
22065 NEXT_RULEPOS (rule_pos
);
22066 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
22069 case RULE_OP_MANGLE_TOGGLECASE_REC
:
22073 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
22074 NEXT_RULEPOS (rule_pos
);
22075 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22076 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
22079 case RULE_OP_MANGLE_DUPECHAR_LAST
:
22080 NEXT_RULEPOS (rule_pos
);
22081 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22082 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
22085 case RULE_OP_MANGLE_DUPECHAR_ALL
:
22086 out_len
= mangle_dupechar (out
, out_len
);
22089 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
22090 NEXT_RULEPOS (rule_pos
);
22091 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22092 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
22095 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
22096 NEXT_RULEPOS (rule_pos
);
22097 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22098 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
22101 case RULE_OP_MANGLE_SWITCH_FIRST
:
22102 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
22105 case RULE_OP_MANGLE_SWITCH_LAST
:
22106 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
22109 case RULE_OP_MANGLE_SWITCH_AT
:
22110 NEXT_RULEPOS (rule_pos
);
22111 NEXT_RPTOI (rule
, rule_pos
, upos
);
22112 NEXT_RULEPOS (rule_pos
);
22113 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22114 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
22117 case RULE_OP_MANGLE_CHR_SHIFTL
:
22118 NEXT_RULEPOS (rule_pos
);
22119 NEXT_RPTOI (rule
, rule_pos
, upos
);
22120 mangle_chr_shiftl (out
, out_len
, upos
);
22123 case RULE_OP_MANGLE_CHR_SHIFTR
:
22124 NEXT_RULEPOS (rule_pos
);
22125 NEXT_RPTOI (rule
, rule_pos
, upos
);
22126 mangle_chr_shiftr (out
, out_len
, upos
);
22129 case RULE_OP_MANGLE_CHR_INCR
:
22130 NEXT_RULEPOS (rule_pos
);
22131 NEXT_RPTOI (rule
, rule_pos
, upos
);
22132 mangle_chr_incr (out
, out_len
, upos
);
22135 case RULE_OP_MANGLE_CHR_DECR
:
22136 NEXT_RULEPOS (rule_pos
);
22137 NEXT_RPTOI (rule
, rule_pos
, upos
);
22138 mangle_chr_decr (out
, out_len
, upos
);
22141 case RULE_OP_MANGLE_REPLACE_NP1
:
22142 NEXT_RULEPOS (rule_pos
);
22143 NEXT_RPTOI (rule
, rule_pos
, upos
);
22144 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
22147 case RULE_OP_MANGLE_REPLACE_NM1
:
22148 NEXT_RULEPOS (rule_pos
);
22149 NEXT_RPTOI (rule
, rule_pos
, upos
);
22150 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
22153 case RULE_OP_MANGLE_TITLE
:
22154 out_len
= mangle_title (out
, out_len
);
22157 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
22158 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22159 NEXT_RULEPOS (rule_pos
);
22160 NEXT_RPTOI (rule
, rule_pos
, upos
);
22161 NEXT_RULEPOS (rule_pos
);
22162 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22163 NEXT_RULEPOS (rule_pos
);
22164 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22165 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
22168 case RULE_OP_MANGLE_APPEND_MEMORY
:
22169 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22170 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22171 memcpy (out
+ out_len
, mem
, mem_len
);
22172 out_len
+= mem_len
;
22175 case RULE_OP_MANGLE_PREPEND_MEMORY
:
22176 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22177 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22178 memcpy (mem
+ mem_len
, out
, out_len
);
22179 out_len
+= mem_len
;
22180 memcpy (out
, mem
, out_len
);
22183 case RULE_OP_MEMORIZE_WORD
:
22184 memcpy (mem
, out
, out_len
);
22188 case RULE_OP_REJECT_LESS
:
22189 NEXT_RULEPOS (rule_pos
);
22190 NEXT_RPTOI (rule
, rule_pos
, upos
);
22191 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
22194 case RULE_OP_REJECT_GREATER
:
22195 NEXT_RULEPOS (rule_pos
);
22196 NEXT_RPTOI (rule
, rule_pos
, upos
);
22197 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
22200 case RULE_OP_REJECT_CONTAIN
:
22201 NEXT_RULEPOS (rule_pos
);
22202 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
22205 case RULE_OP_REJECT_NOT_CONTAIN
:
22206 NEXT_RULEPOS (rule_pos
);
22207 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
22210 case RULE_OP_REJECT_EQUAL_FIRST
:
22211 NEXT_RULEPOS (rule_pos
);
22212 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22215 case RULE_OP_REJECT_EQUAL_LAST
:
22216 NEXT_RULEPOS (rule_pos
);
22217 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22220 case RULE_OP_REJECT_EQUAL_AT
:
22221 NEXT_RULEPOS (rule_pos
);
22222 NEXT_RPTOI (rule
, rule_pos
, upos
);
22223 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22224 NEXT_RULEPOS (rule_pos
);
22225 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22228 case RULE_OP_REJECT_CONTAINS
:
22229 NEXT_RULEPOS (rule_pos
);
22230 NEXT_RPTOI (rule
, rule_pos
, upos
);
22231 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22232 NEXT_RULEPOS (rule_pos
);
22233 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
22234 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
22237 case RULE_OP_REJECT_MEMORY
:
22238 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
22242 return (RULE_RC_SYNTAX_ERROR
);
22247 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);