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
);
2674 #if defined(_WIN) && defined(HAVE_NVAPI)
2675 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2679 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nv
, nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2683 log_info ("WARN: No NvAPI adapters found");
2690 #endif // _WIN && HAVE_NVAPI
2692 #if defined(LINUX) && defined(HAVE_NVML)
2693 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2697 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2699 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nv
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2701 // can be used to determine if the device by index matches the cuda device by index
2702 // char name[100]; memset (name, 0, sizeof (name));
2703 // hm_NVML_nvmlDeviceGetName (data.hm_nv, nvGPUHandle[i], name, sizeof (name) - 1);
2710 log_info ("WARN: No NVML adapters found");
2717 #endif // LINUX && HAVE_NVML
2720 int get_adapters_num_amd (void *adl
, int *iNumberAdapters
)
2722 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2724 if (iNumberAdapters
== 0)
2726 log_info ("WARN: No ADL adapters found.");
2735 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2737 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2738 ADLODParameters lpOdParameters;
2740 lpOdParameters.iSize = sizeof (ADLODParameters);
2741 size_t plevels_size = 0;
2743 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2745 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2746 __func__, iAdapterIndex,
2747 lpOdParameters.iNumberOfPerformanceLevels,
2748 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2749 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2751 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2753 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2755 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2757 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2759 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2760 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2761 __func__, iAdapterIndex, j,
2762 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2764 myfree (lpOdPerformanceLevels);
2770 LPAdapterInfo
hm_get_adapter_info_amd (void *adl
, int iNumberAdapters
)
2772 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2774 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2776 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2778 return lpAdapterInfo
;
2783 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2786 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2790 for (uint i = 0; i < num_adl_adapters; i++)
2792 int opencl_bus_num = hm_device[i].busid;
2793 int opencl_dev_num = hm_device[i].devid;
2795 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2803 if (idx >= DEVICES_MAX) return -1;
2808 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2810 for (uint i = 0; i < opencl_num_devices; i++)
2812 cl_device_topology_amd device_topology;
2814 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2816 hm_device[i].busid = device_topology.pcie.bus;
2817 hm_device[i].devid = device_topology.pcie.device;
2822 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2824 // basically bubble sort
2826 for (int i
= 0; i
< num_adl_adapters
; i
++)
2828 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2830 // get info of adapter [x]
2832 u32 adapter_index_x
= valid_adl_device_list
[j
];
2833 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2835 u32 bus_num_x
= info_x
.iBusNumber
;
2836 u32 dev_num_x
= info_x
.iDeviceNumber
;
2838 // get info of adapter [y]
2840 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2841 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2843 u32 bus_num_y
= info_y
.iBusNumber
;
2844 u32 dev_num_y
= info_y
.iDeviceNumber
;
2848 if (bus_num_y
< bus_num_x
)
2852 else if (bus_num_y
== bus_num_x
)
2854 if (dev_num_y
< dev_num_x
)
2862 u32 temp
= valid_adl_device_list
[j
+ 1];
2864 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2865 valid_adl_device_list
[j
+ 0] = temp
;
2871 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2873 *num_adl_adapters
= 0;
2875 u32
*adl_adapters
= NULL
;
2877 int *bus_numbers
= NULL
;
2878 int *device_numbers
= NULL
;
2880 for (int i
= 0; i
< iNumberAdapters
; i
++)
2882 AdapterInfo info
= lpAdapterInfo
[i
];
2884 if (strlen (info
.strUDID
) < 1) continue;
2887 if (info
.iVendorID
!= 1002) continue;
2889 if (info
.iVendorID
!= 0x1002) continue;
2892 if (info
.iBusNumber
< 0) continue;
2893 if (info
.iDeviceNumber
< 0) continue;
2897 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2899 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2906 if (found
) continue;
2908 // add it to the list
2910 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2912 adl_adapters
[*num_adl_adapters
] = i
;
2914 // rest is just bookkeeping
2916 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2917 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2919 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2920 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2922 (*num_adl_adapters
)++;
2925 myfree (bus_numbers
);
2926 myfree (device_numbers
);
2928 // sort the list by increasing bus id, device id number
2930 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2932 return adl_adapters
;
2935 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2937 // loop through all valid devices
2939 for (int i
= 0; i
< num_adl_adapters
; i
++)
2941 u32 adapter_index
= valid_adl_device_list
[i
];
2945 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2947 // unfortunately this doesn't work since bus id and dev id are not unique
2948 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2949 // if (opencl_device_index == -1) continue;
2951 int opencl_device_index
= i
;
2953 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2955 // get fanspeed info
2957 if (hm_device
[opencl_device_index
].od_version
== 5)
2959 ADLFanSpeedInfo FanSpeedInfo
;
2961 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2963 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2965 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2967 // check read and write capability in fanspeedinfo
2969 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2970 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2972 hm_device
[opencl_device_index
].fan_supported
= 1;
2976 hm_device
[opencl_device_index
].fan_supported
= 0;
2979 else // od_version == 6
2981 ADLOD6FanSpeedInfo faninfo
;
2983 memset (&faninfo
, 0, sizeof (faninfo
));
2985 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2987 // check read capability in fanspeedinfo
2989 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2991 hm_device
[opencl_device_index
].fan_supported
= 1;
2995 hm_device
[opencl_device_index
].fan_supported
= 0;
3003 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3005 for (int i
= 0; i
< num_adl_adapters
; i
++)
3007 u32 adapter_index
= valid_adl_device_list
[i
];
3011 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3013 // get overdrive version
3015 int od_supported
= 0;
3019 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3021 // store the overdrive version in hm_device
3023 // unfortunately this doesn't work since bus id and dev id are not unique
3024 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3025 // if (opencl_device_index == -1) continue;
3027 int opencl_device_index
= i
;
3029 hm_device
[opencl_device_index
].od_version
= od_version
;
3035 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3037 for (int i
= 0; i
< num_adl_adapters
; i
++)
3039 u32 adapter_index
= valid_adl_device_list
[i
];
3043 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3045 // store the iAdapterIndex in hm_device
3047 // unfortunately this doesn't work since bus id and dev id are not unique
3048 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3049 // if (opencl_device_index == -1) continue;
3051 int opencl_device_index
= i
;
3053 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3056 return num_adl_adapters
;
3060 int hm_get_threshold_slowdown_with_device_id (const uint device_id
)
3062 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3065 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3069 if (data
.hm_device
[device_id
].od_version
== 5)
3073 else if (data
.hm_device
[device_id
].od_version
== 6)
3075 int CurrentValue
= 0;
3076 int DefaultValue
= 0;
3078 if (hm_ADL_Overdrive6_TargetTemperatureData_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &CurrentValue
, &DefaultValue
) != ADL_OK
) return -1;
3080 // the return value has never been tested since hm_ADL_Overdrive6_TargetTemperatureData_Get() never worked on any system. expect problems.
3082 return DefaultValue
;
3088 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3089 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3091 #if defined(LINUX) && defined(HAVE_NVML)
3094 hm_NVML_nvmlDeviceGetTemperatureThreshold (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_THRESHOLD_SLOWDOWN
, (unsigned int *) &target
);
3099 #if defined(WIN) && defined(HAVE_NVAPI)
3101 #endif // WIN && HAVE_NVAPI
3103 #endif // HAVE_NVML || HAVE_NVAPI
3108 int hm_get_temperature_with_device_id (const uint device_id
)
3110 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3113 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3117 if (data
.hm_device
[device_id
].od_version
== 5)
3119 ADLTemperature Temperature
;
3121 Temperature
.iSize
= sizeof (ADLTemperature
);
3123 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3125 return Temperature
.iTemperature
/ 1000;
3127 else if (data
.hm_device
[device_id
].od_version
== 6)
3129 int Temperature
= 0;
3131 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3133 return Temperature
/ 1000;
3139 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3140 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3142 #if defined(LINUX) && defined(HAVE_NVML)
3143 int temperature
= 0;
3145 hm_NVML_nvmlDeviceGetTemperature (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
);
3150 #if defined(WIN) && defined(HAVE_NVAPI)
3151 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3153 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3154 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3155 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3156 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3158 if (hm_NvAPI_GPU_GetThermalSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3160 return pThermalSettings
.sensor
[0].currentTemp
;
3161 #endif // WIN && HAVE_NVAPI
3163 #endif // HAVE_NVML || HAVE_NVAPI
3168 int hm_get_fanspeed_with_device_id (const uint device_id
)
3170 // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
3171 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3173 if (data
.hm_device
[device_id
].fan_supported
== 1)
3176 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3180 if (data
.hm_device
[device_id
].od_version
== 5)
3182 ADLFanSpeedValue lpFanSpeedValue
;
3184 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3186 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3187 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3188 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3190 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3192 return lpFanSpeedValue
.iFanSpeed
;
3194 else // od_version == 6
3196 ADLOD6FanSpeedInfo faninfo
;
3198 memset (&faninfo
, 0, sizeof (faninfo
));
3200 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3202 return faninfo
.iFanSpeedPercent
;
3208 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3209 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3211 #if defined(LINUX) && defined(HAVE_NVML)
3214 hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (uint
*) &speed
);
3219 #if defined(WIN) && defined(HAVE_NVAPI)
3220 NV_GPU_COOLER_SETTINGS pCoolerSettings
;
3222 pCoolerSettings
.Version
= GPU_COOLER_SETTINGS_VER
| sizeof (NV_GPU_COOLER_SETTINGS
);
3224 hm_NvAPI_GPU_GetCoolerSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pCoolerSettings
);
3226 return pCoolerSettings
.Cooler
[0].CurrentLevel
;
3229 #endif // HAVE_NVML || HAVE_NVAPI
3235 int hm_get_utilization_with_device_id (const uint device_id
)
3237 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3240 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3244 ADLPMActivity PMActivity
;
3246 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3248 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3250 return PMActivity
.iActivityPercent
;
3255 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3256 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3258 #if defined(LINUX) && defined(HAVE_NVML)
3259 nvmlUtilization_t utilization
;
3261 hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3263 return utilization
.gpu
;
3266 #if defined(WIN) && defined(HAVE_NVAPI)
3267 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3269 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3271 if (hm_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3273 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3276 #endif // HAVE_NVML || HAVE_NVAPI
3281 int hm_get_memoryspeed_with_device_id (const uint device_id
)
3283 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3286 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3290 ADLPMActivity PMActivity
;
3292 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3294 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3296 return PMActivity
.iMemoryClock
/ 100;
3301 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3302 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3304 #if defined(LINUX) && defined(HAVE_NVML)
3307 hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_CLOCK_MEM
, &clock
);
3312 #if defined(WIN) && defined(HAVE_NVAPI)
3313 NV_GPU_CLOCK_FREQUENCIES pClkFreqs
= { 0 };
3315 pClkFreqs
.version
= NV_GPU_CLOCK_FREQUENCIES_VER
;
3316 pClkFreqs
.ClockType
= NV_GPU_CLOCK_FREQUENCIES_CURRENT_FREQ
;
3318 if (hm_NvAPI_GPU_GetAllClockFrequencies (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pClkFreqs
) != NVAPI_OK
) return -1;
3320 return pClkFreqs
.domain
[NVAPI_GPU_PUBLIC_CLOCK_MEMORY
].frequency
/ 1000;
3323 #endif // HAVE_NVML || HAVE_NVAPI
3328 int hm_get_corespeed_with_device_id (const uint device_id
)
3330 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3333 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3337 ADLPMActivity PMActivity
;
3339 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3341 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3343 return PMActivity
.iEngineClock
/ 100;
3348 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3349 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3351 #if defined(LINUX) && defined(HAVE_NVML)
3354 hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_CLOCK_SM
, &clock
);
3359 #if defined(WIN) && defined(HAVE_NVAPI)
3360 NV_GPU_CLOCK_FREQUENCIES pClkFreqs
= { 0 };
3362 pClkFreqs
.version
= NV_GPU_CLOCK_FREQUENCIES_VER
;
3363 pClkFreqs
.ClockType
= NV_GPU_CLOCK_FREQUENCIES_CURRENT_FREQ
;
3365 if (hm_NvAPI_GPU_GetAllClockFrequencies (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pClkFreqs
) != NVAPI_OK
) return -1;
3367 return pClkFreqs
.domain
[NVAPI_GPU_PUBLIC_CLOCK_GRAPHICS
].frequency
/ 1000;
3370 #endif // HAVE_NVML || HAVE_NVAPI
3376 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3378 if (data
.hm_device
[device_id
].fan_supported
== 1)
3382 if (data
.hm_device
[device_id
].od_version
== 5)
3384 ADLFanSpeedValue lpFanSpeedValue
;
3386 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3388 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3389 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3390 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3391 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3393 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3397 else // od_version == 6
3399 ADLOD6FanSpeedValue fan_speed_value
;
3401 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3403 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3404 fan_speed_value
.iFanSpeed
= fanspeed
;
3406 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3417 // helper function for status display
3419 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3421 #define VALUE_NOT_AVAILABLE "N/A"
3425 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3429 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3432 #endif // HAVE_HWMON
3438 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3440 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3442 if (css_cnt
> SP_PW_MAX
)
3444 log_error ("ERROR: mask length is too long");
3449 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3451 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3453 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3454 uint cs_len
= css
[css_pos
].cs_len
;
3456 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3458 uint c
= cs_buf
[cs_pos
] & 0xff;
3465 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3467 cs_t
*cs
= &css
[css_cnt
];
3469 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3471 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3475 for (i
= 0; i
< cs
->cs_len
; i
++)
3477 const uint u
= cs
->cs_buf
[i
];
3482 for (i
= 0; i
< in_len
; i
++)
3484 uint u
= in_buf
[i
] & 0xff;
3486 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3488 if (css_uniq
[u
] == 1) continue;
3492 cs
->cs_buf
[cs
->cs_len
] = u
;
3500 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3504 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3506 uint p0
= in_buf
[in_pos
] & 0xff;
3508 if (interpret
== 1 && p0
== '?')
3512 if (in_pos
== in_len
) break;
3514 uint p1
= in_buf
[in_pos
] & 0xff;
3518 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3520 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3522 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3524 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3526 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3528 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3530 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3531 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3533 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3534 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3536 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3537 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3539 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3540 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3542 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3544 default: log_error ("Syntax error: %s", in_buf
);
3550 if (data
.hex_charset
)
3554 if (in_pos
== in_len
)
3556 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3561 uint p1
= in_buf
[in_pos
] & 0xff;
3563 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3565 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3572 chr
= hex_convert (p1
) << 0;
3573 chr
|= hex_convert (p0
) << 4;
3575 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3581 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3587 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3591 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3593 sum
*= css
[css_pos
].cs_len
;
3599 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3601 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3606 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3608 char p0
= mask_buf
[mask_pos
];
3614 if (mask_pos
== mask_len
) break;
3616 char p1
= mask_buf
[mask_pos
];
3622 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3624 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3626 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3628 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3630 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3632 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3634 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3635 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3637 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3638 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3640 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3641 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3643 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3644 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3646 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3648 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3654 if (data
.hex_charset
)
3658 // if there is no 2nd hex character, show an error:
3660 if (mask_pos
== mask_len
)
3662 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3667 char p1
= mask_buf
[mask_pos
];
3669 // if they are not valid hex character, show an error:
3671 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3673 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3680 chr
|= hex_convert (p1
) << 0;
3681 chr
|= hex_convert (p0
) << 4;
3683 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3689 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3696 log_error ("ERROR: invalid mask length (0)");
3706 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3708 for (int i
= 0; i
< css_cnt
; i
++)
3710 uint len
= css
[i
].cs_len
;
3711 u64 next
= val
/ len
;
3712 uint pos
= val
% len
;
3713 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3718 void mp_cut_at (char *mask
, uint max
)
3722 uint mask_len
= strlen (mask
);
3724 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3726 if (mask
[i
] == '?') i
++;
3732 void mp_setup_sys (cs_t
*mp_sys
)
3736 uint donec
[CHARSIZ
] = { 0 };
3738 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3739 mp_sys
[0].cs_buf
[pos
++] = chr
;
3740 mp_sys
[0].cs_len
= pos
; }
3742 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3743 mp_sys
[1].cs_buf
[pos
++] = chr
;
3744 mp_sys
[1].cs_len
= pos
; }
3746 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3747 mp_sys
[2].cs_buf
[pos
++] = chr
;
3748 mp_sys
[2].cs_len
= pos
; }
3750 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3751 mp_sys
[3].cs_buf
[pos
++] = chr
;
3752 mp_sys
[3].cs_len
= pos
; }
3754 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3755 mp_sys
[4].cs_len
= pos
; }
3757 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3758 mp_sys
[5].cs_len
= pos
; }
3761 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3763 FILE *fp
= fopen (buf
, "rb");
3765 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3767 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3771 char mp_file
[1024] = { 0 };
3773 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3777 len
= in_superchop (mp_file
);
3781 log_info ("WARNING: charset file corrupted");
3783 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3787 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3792 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3794 mp_usr
[index
].cs_len
= 0;
3796 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3799 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3801 char *new_mask_buf
= (char *) mymalloc (256);
3807 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3809 if (css_pos
== len
) break;
3811 char p0
= mask_buf
[mask_pos
];
3813 new_mask_buf
[mask_pos
] = p0
;
3819 if (mask_pos
== mask_len
) break;
3821 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3825 if (data
.hex_charset
)
3829 if (mask_pos
== mask_len
)
3831 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3836 char p1
= mask_buf
[mask_pos
];
3838 // if they are not valid hex character, show an error:
3840 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3842 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3847 new_mask_buf
[mask_pos
] = p1
;
3852 if (css_pos
== len
) return (new_mask_buf
);
3854 myfree (new_mask_buf
);
3863 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3869 for (i
= start
; i
< stop
; i
++)
3871 sum
*= root_css_buf
[i
].cs_len
;
3877 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3881 cs_t
*cs
= &root_css_buf
[start
];
3885 for (i
= start
; i
< stop
; i
++)
3887 const u64 m
= v
% cs
->cs_len
;
3888 const u64 d
= v
/ cs
->cs_len
;
3892 const uint k
= cs
->cs_buf
[m
];
3894 pw_buf
[i
- start
] = (char) k
;
3896 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3900 int sp_comp_val (const void *p1
, const void *p2
)
3902 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3903 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3905 return b2
->val
- b1
->val
;
3908 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
)
3915 * Initialize hcstats
3918 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3920 u64
*root_stats_ptr
= root_stats_buf
;
3922 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3924 for (i
= 0; i
< SP_PW_MAX
; i
++)
3926 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3928 root_stats_ptr
+= CHARSIZ
;
3931 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3933 u64
*markov_stats_ptr
= markov_stats_buf
;
3935 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3937 for (i
= 0; i
< SP_PW_MAX
; i
++)
3939 for (j
= 0; j
< CHARSIZ
; j
++)
3941 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3943 markov_stats_ptr
+= CHARSIZ
;
3953 char hcstat_tmp
[256] = { 0 };
3955 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3957 hcstat
= hcstat_tmp
;
3960 FILE *fd
= fopen (hcstat
, "rb");
3964 log_error ("%s: %s", hcstat
, strerror (errno
));
3969 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3971 log_error ("%s: Could not load data", hcstat
);
3978 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3980 log_error ("%s: Could not load data", hcstat
);
3990 * Markov modifier of hcstat_table on user request
3995 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
3996 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
4001 /* Add all stats to first position */
4003 for (i
= 1; i
< SP_PW_MAX
; i
++)
4005 u64
*out
= root_stats_buf_by_pos
[0];
4006 u64
*in
= root_stats_buf_by_pos
[i
];
4008 for (j
= 0; j
< CHARSIZ
; j
++)
4014 for (i
= 1; i
< SP_PW_MAX
; i
++)
4016 u64
*out
= markov_stats_buf_by_key
[0][0];
4017 u64
*in
= markov_stats_buf_by_key
[i
][0];
4019 for (j
= 0; j
< CHARSIZ
; j
++)
4021 for (k
= 0; k
< CHARSIZ
; k
++)
4028 /* copy them to all pw_positions */
4030 for (i
= 1; i
< SP_PW_MAX
; i
++)
4032 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
4035 for (i
= 1; i
< SP_PW_MAX
; i
++)
4037 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
4045 hcstat_table_t
*root_table_ptr
= root_table_buf
;
4047 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
4049 for (i
= 0; i
< SP_PW_MAX
; i
++)
4051 root_table_buf_by_pos
[i
] = root_table_ptr
;
4053 root_table_ptr
+= CHARSIZ
;
4056 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
4058 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4060 for (i
= 0; i
< SP_PW_MAX
; i
++)
4062 for (j
= 0; j
< CHARSIZ
; j
++)
4064 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
4066 markov_table_ptr
+= CHARSIZ
;
4071 * Convert hcstat to tables
4074 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
4076 uint key
= i
% CHARSIZ
;
4078 root_table_buf
[i
].key
= key
;
4079 root_table_buf
[i
].val
= root_stats_buf
[i
];
4082 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
4084 uint key
= i
% CHARSIZ
;
4086 markov_table_buf
[i
].key
= key
;
4087 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
4090 myfree (root_stats_buf
);
4091 myfree (markov_stats_buf
);
4097 for (i
= 0; i
< SP_PW_MAX
; i
++)
4099 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4102 for (i
= 0; i
< SP_PW_MAX
; i
++)
4104 for (j
= 0; j
< CHARSIZ
; j
++)
4106 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4111 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
])
4114 * Convert tables to css
4117 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
4119 uint pw_pos
= i
/ CHARSIZ
;
4121 cs_t
*cs
= &root_css_buf
[pw_pos
];
4123 if (cs
->cs_len
== threshold
) continue;
4125 uint key
= root_table_buf
[i
].key
;
4127 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
4129 cs
->cs_buf
[cs
->cs_len
] = key
;
4135 * Convert table to css
4138 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4140 uint c
= i
/ CHARSIZ
;
4142 cs_t
*cs
= &markov_css_buf
[c
];
4144 if (cs
->cs_len
== threshold
) continue;
4146 uint pw_pos
= c
/ CHARSIZ
;
4148 uint key
= markov_table_buf
[i
].key
;
4150 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4152 cs
->cs_buf
[cs
->cs_len
] = key
;
4158 for (uint i = 0; i < 8; i++)
4160 for (uint j = 0x20; j < 0x80; j++)
4162 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4164 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4166 for (uint k = 0; k < 10; k++)
4168 printf (" %u\n", ptr->cs_buf[k]);
4175 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4177 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4179 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4189 for (uint j
= 1; j
< CHARSIZ
; j
++)
4199 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4201 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4203 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4205 out
+= CHARSIZ
* CHARSIZ
;
4206 in
+= CHARSIZ
* CHARSIZ
;
4208 for (uint j
= 0; j
< CHARSIZ
; j
++)
4215 for (uint k
= 1; k
< CHARSIZ
; k
++)
4227 * mixed shared functions
4230 void dump_hex (const u8
*s
, const int sz
)
4232 for (int i
= 0; i
< sz
; i
++)
4234 log_info_nn ("%02x ", s
[i
]);
4240 void usage_mini_print (const char *progname
)
4242 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4245 void usage_big_print (const char *progname
)
4247 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4250 char *get_exec_path ()
4252 int exec_path_len
= 1024;
4254 char *exec_path
= (char *) mymalloc (exec_path_len
);
4258 char tmp
[32] = { 0 };
4260 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4262 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4266 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4270 uint size
= exec_path_len
;
4272 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4274 log_error("! executable path buffer too small\n");
4279 const int len
= strlen (exec_path
);
4282 #error Your Operating System is not supported or detected
4290 char *get_install_dir (const char *progname
)
4292 char *install_dir
= mystrdup (progname
);
4293 char *last_slash
= NULL
;
4295 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4299 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4305 install_dir
[0] = '.';
4309 return (install_dir
);
4312 char *get_profile_dir (const char *homedir
)
4314 #define DOT_HASHCAT ".hashcat"
4316 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4318 char *profile_dir
= (char *) mymalloc (len
+ 1);
4320 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4325 char *get_session_dir (const char *profile_dir
)
4327 #define SESSIONS_FOLDER "sessions"
4329 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4331 char *session_dir
= (char *) mymalloc (len
+ 1);
4333 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4338 uint
count_lines (FILE *fd
)
4342 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4348 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4350 if (nread
< 1) continue;
4354 for (i
= 0; i
< nread
; i
++)
4356 if (prev
== '\n') cnt
++;
4367 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4371 FILE *fd
= fopen (filename
, "rb");
4375 log_error ("%s: %s", filename
, strerror (errno
));
4380 #define MAX_KEY_SIZE (1024 * 1024)
4382 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4384 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4390 for (int fpos
= 0; fpos
< nread
; fpos
++)
4392 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4394 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4395 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4396 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4397 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4399 if (kpos
>= 64) kpos
= 0;
4406 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4410 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4411 if (CPU_ISSET(core
, cpu_set
)) break;
4413 thread_affinity_policy_data_t policy
= { core
};
4415 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4417 if (data
.quiet
== 0)
4419 if (rc
!= KERN_SUCCESS
)
4421 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4429 void set_cpu_affinity (char *cpu_affinity
)
4432 DWORD_PTR aff_mask
= 0;
4440 char *devices
= strdup (cpu_affinity
);
4442 char *next
= strtok (devices
, ",");
4446 uint cpu_id
= atoi (next
);
4461 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4467 aff_mask
|= 1 << (cpu_id
- 1);
4469 CPU_SET ((cpu_id
- 1), &cpuset
);
4472 } while ((next
= strtok (NULL
, ",")) != NULL
);
4478 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4479 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4481 pthread_t thread
= pthread_self ();
4482 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4486 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4488 char *element
, *end
;
4490 end
= (char *) base
+ nmemb
* size
;
4492 for (element
= (char *) base
; element
< end
; element
+= size
)
4493 if (!compar (element
, key
))
4499 int sort_by_u32 (const void *v1
, const void *v2
)
4501 const u32
*s1
= (const u32
*) v1
;
4502 const u32
*s2
= (const u32
*) v2
;
4507 int sort_by_salt (const void *v1
, const void *v2
)
4509 const salt_t
*s1
= (const salt_t
*) v1
;
4510 const salt_t
*s2
= (const salt_t
*) v2
;
4512 const int res1
= s1
->salt_len
- s2
->salt_len
;
4514 if (res1
!= 0) return (res1
);
4516 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4518 if (res2
!= 0) return (res2
);
4526 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4527 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4534 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4535 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4541 int sort_by_salt_buf (const void *v1
, const void *v2
)
4543 const pot_t
*p1
= (const pot_t
*) v1
;
4544 const pot_t
*p2
= (const pot_t
*) v2
;
4546 const hash_t
*h1
= &p1
->hash
;
4547 const hash_t
*h2
= &p2
->hash
;
4549 const salt_t
*s1
= h1
->salt
;
4550 const salt_t
*s2
= h2
->salt
;
4556 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4557 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4563 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4565 const hash_t
*h1
= (const hash_t
*) v1
;
4566 const hash_t
*h2
= (const hash_t
*) v2
;
4568 const salt_t
*s1
= h1
->salt
;
4569 const salt_t
*s2
= h2
->salt
;
4571 // testphase: this should work
4576 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4577 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4580 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4581 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4582 if (s1->salt_len > s2->salt_len) return ( 1);
4583 if (s1->salt_len < s2->salt_len) return (-1);
4585 uint n = s1->salt_len;
4589 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4590 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4597 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4599 const hash_t
*h1
= (const hash_t
*) v1
;
4600 const hash_t
*h2
= (const hash_t
*) v2
;
4602 const salt_t
*s1
= h1
->salt
;
4603 const salt_t
*s2
= h2
->salt
;
4605 // 16 - 2 (since last 2 uints contain the digest)
4610 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4611 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4617 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4619 const hash_t
*h1
= (const hash_t
*) v1
;
4620 const hash_t
*h2
= (const hash_t
*) v2
;
4622 const void *d1
= h1
->digest
;
4623 const void *d2
= h2
->digest
;
4625 return data
.sort_by_digest (d1
, d2
);
4628 int sort_by_hash (const void *v1
, const void *v2
)
4630 const hash_t
*h1
= (const hash_t
*) v1
;
4631 const hash_t
*h2
= (const hash_t
*) v2
;
4635 const salt_t
*s1
= h1
->salt
;
4636 const salt_t
*s2
= h2
->salt
;
4638 int res
= sort_by_salt (s1
, s2
);
4640 if (res
!= 0) return (res
);
4643 const void *d1
= h1
->digest
;
4644 const void *d2
= h2
->digest
;
4646 return data
.sort_by_digest (d1
, d2
);
4649 int sort_by_pot (const void *v1
, const void *v2
)
4651 const pot_t
*p1
= (const pot_t
*) v1
;
4652 const pot_t
*p2
= (const pot_t
*) v2
;
4654 const hash_t
*h1
= &p1
->hash
;
4655 const hash_t
*h2
= &p2
->hash
;
4657 return sort_by_hash (h1
, h2
);
4660 int sort_by_mtime (const void *p1
, const void *p2
)
4662 const char **f1
= (const char **) p1
;
4663 const char **f2
= (const char **) p2
;
4665 struct stat s1
; stat (*f1
, &s1
);
4666 struct stat s2
; stat (*f2
, &s2
);
4668 return s2
.st_mtime
- s1
.st_mtime
;
4671 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4673 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4674 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4676 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4679 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4681 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4682 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4684 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4687 int sort_by_stringptr (const void *p1
, const void *p2
)
4689 const char **s1
= (const char **) p1
;
4690 const char **s2
= (const char **) p2
;
4692 return strcmp (*s1
, *s2
);
4695 int sort_by_dictstat (const void *s1
, const void *s2
)
4697 dictstat_t
*d1
= (dictstat_t
*) s1
;
4698 dictstat_t
*d2
= (dictstat_t
*) s2
;
4701 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4703 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4706 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4709 int sort_by_bitmap (const void *p1
, const void *p2
)
4711 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4712 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4714 return b1
->collisions
- b2
->collisions
;
4717 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4719 const u32
*d1
= (const u32
*) v1
;
4720 const u32
*d2
= (const u32
*) v2
;
4726 if (d1
[n
] > d2
[n
]) return ( 1);
4727 if (d1
[n
] < d2
[n
]) return (-1);
4733 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4735 const u32
*d1
= (const u32
*) v1
;
4736 const u32
*d2
= (const u32
*) v2
;
4742 if (d1
[n
] > d2
[n
]) return ( 1);
4743 if (d1
[n
] < d2
[n
]) return (-1);
4749 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4751 const u32
*d1
= (const u32
*) v1
;
4752 const u32
*d2
= (const u32
*) v2
;
4758 if (d1
[n
] > d2
[n
]) return ( 1);
4759 if (d1
[n
] < d2
[n
]) return (-1);
4765 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4767 const u32
*d1
= (const u32
*) v1
;
4768 const u32
*d2
= (const u32
*) v2
;
4774 if (d1
[n
] > d2
[n
]) return ( 1);
4775 if (d1
[n
] < d2
[n
]) return (-1);
4781 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4783 const u32
*d1
= (const u32
*) v1
;
4784 const u32
*d2
= (const u32
*) v2
;
4790 if (d1
[n
] > d2
[n
]) return ( 1);
4791 if (d1
[n
] < d2
[n
]) return (-1);
4797 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4799 const u32
*d1
= (const u32
*) v1
;
4800 const u32
*d2
= (const u32
*) v2
;
4806 if (d1
[n
] > d2
[n
]) return ( 1);
4807 if (d1
[n
] < d2
[n
]) return (-1);
4813 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4815 const u32
*d1
= (const u32
*) v1
;
4816 const u32
*d2
= (const u32
*) v2
;
4822 if (d1
[n
] > d2
[n
]) return ( 1);
4823 if (d1
[n
] < d2
[n
]) return (-1);
4829 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4831 const u32
*d1
= (const u32
*) v1
;
4832 const u32
*d2
= (const u32
*) v2
;
4838 if (d1
[n
] > d2
[n
]) return ( 1);
4839 if (d1
[n
] < d2
[n
]) return (-1);
4845 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4847 const u64
*d1
= (const u64
*) v1
;
4848 const u64
*d2
= (const u64
*) v2
;
4854 if (d1
[n
] > d2
[n
]) return ( 1);
4855 if (d1
[n
] < d2
[n
]) return (-1);
4861 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4863 const u64
*d1
= (const u64
*) v1
;
4864 const u64
*d2
= (const u64
*) v2
;
4870 if (d1
[n
] > d2
[n
]) return ( 1);
4871 if (d1
[n
] < d2
[n
]) return (-1);
4877 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4879 const u64
*d1
= (const u64
*) v1
;
4880 const u64
*d2
= (const u64
*) v2
;
4886 if (d1
[n
] > d2
[n
]) return ( 1);
4887 if (d1
[n
] < d2
[n
]) return (-1);
4893 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4895 const u32
*d1
= (const u32
*) v1
;
4896 const u32
*d2
= (const u32
*) v2
;
4898 const uint dgst_pos0
= data
.dgst_pos0
;
4899 const uint dgst_pos1
= data
.dgst_pos1
;
4900 const uint dgst_pos2
= data
.dgst_pos2
;
4901 const uint dgst_pos3
= data
.dgst_pos3
;
4903 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4904 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4905 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4906 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4907 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4908 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4909 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4910 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4915 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4917 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4918 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4920 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4922 if (res1
!= 0) return (res1
);
4927 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4929 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4930 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4932 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4934 if (res1
!= 0) return (res1
);
4936 const int res2
= t1
->attack_mode
4939 if (res2
!= 0) return (res2
);
4941 const int res3
= t1
->hash_type
4944 if (res3
!= 0) return (res3
);
4949 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
)
4951 uint outfile_autohex
= data
.outfile_autohex
;
4953 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4955 FILE *debug_fp
= NULL
;
4957 if (debug_file
!= NULL
)
4959 debug_fp
= fopen (debug_file
, "ab");
4961 lock_file (debug_fp
);
4968 if (debug_fp
== NULL
)
4970 log_info ("WARNING: Could not open debug-file for writing");
4974 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4976 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4978 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4981 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4983 if (debug_mode
== 4)
4985 fputc (':', debug_fp
);
4987 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4990 fputc ('\n', debug_fp
);
4992 if (debug_file
!= NULL
) fclose (debug_fp
);
4996 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4998 int needs_hexify
= 0;
5000 if (outfile_autohex
== 1)
5002 for (uint i
= 0; i
< plain_len
; i
++)
5004 if (plain_ptr
[i
] < 0x20)
5011 if (plain_ptr
[i
] > 0x7f)
5020 if (needs_hexify
== 1)
5022 fprintf (fp
, "$HEX[");
5024 for (uint i
= 0; i
< plain_len
; i
++)
5026 fprintf (fp
, "%02x", plain_ptr
[i
]);
5033 fwrite (plain_ptr
, plain_len
, 1, fp
);
5037 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
)
5039 uint outfile_format
= data
.outfile_format
;
5041 char separator
= data
.separator
;
5043 if (outfile_format
& OUTFILE_FMT_HASH
)
5045 fprintf (out_fp
, "%s", out_buf
);
5047 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5049 fputc (separator
, out_fp
);
5052 else if (data
.username
)
5054 if (username
!= NULL
)
5056 for (uint i
= 0; i
< user_len
; i
++)
5058 fprintf (out_fp
, "%c", username
[i
]);
5061 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5063 fputc (separator
, out_fp
);
5068 if (outfile_format
& OUTFILE_FMT_PLAIN
)
5070 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
5072 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5074 fputc (separator
, out_fp
);
5078 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
5080 for (uint i
= 0; i
< plain_len
; i
++)
5082 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
5085 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
5087 fputc (separator
, out_fp
);
5091 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
5094 __mingw_fprintf (out_fp
, "%llu", crackpos
);
5099 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
5101 fprintf (out_fp
, "%llu", crackpos
);
5106 fputc ('\n', out_fp
);
5109 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
)
5113 pot_key
.hash
.salt
= hashes_buf
->salt
;
5114 pot_key
.hash
.digest
= hashes_buf
->digest
;
5116 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5122 input_buf
[input_len
] = 0;
5125 unsigned char *username
= NULL
;
5130 user_t
*user
= hashes_buf
->hash_info
->user
;
5134 username
= (unsigned char *) (user
->user_name
);
5136 user_len
= user
->user_len
;
5140 // do output the line
5141 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5145 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5146 #define LM_MASKED_PLAIN "[notfound]"
5148 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
)
5154 pot_left_key
.hash
.salt
= hash_left
->salt
;
5155 pot_left_key
.hash
.digest
= hash_left
->digest
;
5157 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5161 uint weak_hash_found
= 0;
5163 pot_t pot_right_key
;
5165 pot_right_key
.hash
.salt
= hash_right
->salt
;
5166 pot_right_key
.hash
.digest
= hash_right
->digest
;
5168 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5170 if (pot_right_ptr
== NULL
)
5172 // special case, if "weak hash"
5174 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5176 weak_hash_found
= 1;
5178 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5180 // in theory this is not needed, but we are paranoia:
5182 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5183 pot_right_ptr
->plain_len
= 0;
5187 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5189 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
5194 // at least one half was found:
5198 input_buf
[input_len
] = 0;
5202 unsigned char *username
= NULL
;
5207 user_t
*user
= hash_left
->hash_info
->user
;
5211 username
= (unsigned char *) (user
->user_name
);
5213 user_len
= user
->user_len
;
5217 // mask the part which was not found
5219 uint left_part_masked
= 0;
5220 uint right_part_masked
= 0;
5222 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5224 if (pot_left_ptr
== NULL
)
5226 left_part_masked
= 1;
5228 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5230 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5232 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5233 pot_left_ptr
->plain_len
= mask_plain_len
;
5236 if (pot_right_ptr
== NULL
)
5238 right_part_masked
= 1;
5240 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5242 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5244 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5245 pot_right_ptr
->plain_len
= mask_plain_len
;
5248 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5252 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5254 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5256 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5258 // do output the line
5260 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5262 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5264 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5265 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5268 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
)
5272 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5274 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5276 if (pot_ptr
== NULL
)
5280 input_buf
[input_len
] = 0;
5282 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5286 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
)
5292 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5294 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5298 pot_t pot_right_key
;
5300 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5302 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5304 uint weak_hash_found
= 0;
5306 if (pot_right_ptr
== NULL
)
5308 // special case, if "weak hash"
5310 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5312 weak_hash_found
= 1;
5314 // we just need that pot_right_ptr is not a NULL pointer
5316 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5320 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5322 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5327 // ... at least one part was not cracked
5331 input_buf
[input_len
] = 0;
5333 // only show the hash part which is still not cracked
5335 uint user_len
= input_len
- 32;
5337 char *hash_output
= (char *) mymalloc (33);
5339 memcpy (hash_output
, input_buf
, input_len
);
5341 if (pot_left_ptr
!= NULL
)
5343 // only show right part (because left part was already found)
5345 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5347 hash_output
[user_len
+ 16] = 0;
5350 if (pot_right_ptr
!= NULL
)
5352 // only show left part (because right part was already found)
5354 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5356 hash_output
[user_len
+ 16] = 0;
5359 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5361 myfree (hash_output
);
5363 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5366 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5368 uint opencl_platforms_filter
= 0;
5370 if (opencl_platforms
)
5372 char *platforms
= strdup (opencl_platforms
);
5374 char *next
= strtok (platforms
, ",");
5378 int platform
= atoi (next
);
5380 if (platform
< 1 || platform
> 32)
5382 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5387 opencl_platforms_filter
|= 1 << (platform
- 1);
5389 } while ((next
= strtok (NULL
, ",")) != NULL
);
5395 opencl_platforms_filter
= -1;
5398 return opencl_platforms_filter
;
5401 u32
setup_devices_filter (char *opencl_devices
)
5403 u32 devices_filter
= 0;
5407 char *devices
= strdup (opencl_devices
);
5409 char *next
= strtok (devices
, ",");
5413 int device_id
= atoi (next
);
5415 if (device_id
< 1 || device_id
> 32)
5417 log_error ("ERROR: invalid device_id %u specified", device_id
);
5422 devices_filter
|= 1 << (device_id
- 1);
5424 } while ((next
= strtok (NULL
, ",")) != NULL
);
5430 devices_filter
= -1;
5433 return devices_filter
;
5436 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5438 cl_device_type device_types_filter
= 0;
5440 if (opencl_device_types
)
5442 char *device_types
= strdup (opencl_device_types
);
5444 char *next
= strtok (device_types
, ",");
5448 int device_type
= atoi (next
);
5450 if (device_type
< 1 || device_type
> 3)
5452 log_error ("ERROR: invalid device_type %u specified", device_type
);
5457 device_types_filter
|= 1 << device_type
;
5459 } while ((next
= strtok (NULL
, ",")) != NULL
);
5461 free (device_types
);
5465 // Do not use CPU by default, this often reduces GPU performance because
5466 // the CPU is too busy to handle GPU synchronization
5468 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5471 return device_types_filter
;
5474 u32
get_random_num (const u32 min
, const u32 max
)
5476 if (min
== max
) return (min
);
5478 return ((rand () % (max
- min
)) + min
);
5481 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5483 u32 quotient
= dividend
/ divisor
;
5485 if (dividend
% divisor
) quotient
++;
5490 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5492 u64 quotient
= dividend
/ divisor
;
5494 if (dividend
% divisor
) quotient
++;
5499 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5501 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5502 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5504 if (tm
->tm_year
- 70)
5506 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5507 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5509 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5511 else if (tm
->tm_yday
)
5513 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5514 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5516 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5518 else if (tm
->tm_hour
)
5520 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5521 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5523 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5525 else if (tm
->tm_min
)
5527 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5528 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5530 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5534 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5536 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5540 void format_speed_display (float val
, char *buf
, size_t len
)
5551 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5562 /* generate output */
5566 snprintf (buf
, len
- 1, "%.0f ", val
);
5570 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5574 void lowercase (u8
*buf
, int len
)
5576 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5579 void uppercase (u8
*buf
, int len
)
5581 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5584 int fgetl (FILE *fp
, char *line_buf
)
5590 const int c
= fgetc (fp
);
5592 if (c
== EOF
) break;
5594 line_buf
[line_len
] = (char) c
;
5598 if (line_len
== HCBUFSIZ
) line_len
--;
5600 if (c
== '\n') break;
5603 if (line_len
== 0) return 0;
5605 if (line_buf
[line_len
- 1] == '\n')
5609 line_buf
[line_len
] = 0;
5612 if (line_len
== 0) return 0;
5614 if (line_buf
[line_len
- 1] == '\r')
5618 line_buf
[line_len
] = 0;
5624 int in_superchop (char *buf
)
5626 int len
= strlen (buf
);
5630 if (buf
[len
- 1] == '\n')
5637 if (buf
[len
- 1] == '\r')
5652 char **scan_directory (const char *path
)
5654 char *tmp_path
= mystrdup (path
);
5656 size_t tmp_path_len
= strlen (tmp_path
);
5658 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5660 tmp_path
[tmp_path_len
- 1] = 0;
5662 tmp_path_len
= strlen (tmp_path
);
5665 char **files
= NULL
;
5671 if ((d
= opendir (tmp_path
)) != NULL
)
5677 memset (&e
, 0, sizeof (e
));
5678 struct dirent
*de
= NULL
;
5680 if (readdir_r (d
, &e
, &de
) != 0)
5682 log_error ("ERROR: readdir_r() failed");
5687 if (de
== NULL
) break;
5691 while ((de
= readdir (d
)) != NULL
)
5694 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5696 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5698 char *path_file
= (char *) mymalloc (path_size
+ 1);
5700 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5702 path_file
[path_size
] = 0;
5706 if ((d_test
= opendir (path_file
)) != NULL
)
5714 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5718 files
[num_files
- 1] = path_file
;
5724 else if (errno
== ENOTDIR
)
5726 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5730 files
[num_files
- 1] = mystrdup (path
);
5733 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5737 files
[num_files
- 1] = NULL
;
5744 int count_dictionaries (char **dictionary_files
)
5746 if (dictionary_files
== NULL
) return 0;
5750 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5758 char *stroptitype (const uint opti_type
)
5762 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5763 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5764 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5765 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5766 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5767 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5768 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5769 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5770 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5771 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5772 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5773 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5774 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5775 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5776 case OPTI_TYPE_SLOW_HASH_SIMD
: return ((char *) OPTI_STR_SLOW_HASH_SIMD
); break;
5777 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5778 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5779 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5780 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5786 char *strparser (const uint parser_status
)
5788 switch (parser_status
)
5790 case PARSER_OK
: return ((char *) PA_000
); break;
5791 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5792 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5793 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5794 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5795 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5796 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5797 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5798 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5799 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5800 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5801 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5802 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5803 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5804 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5805 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5806 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5809 return ((char *) PA_255
);
5812 char *strhashtype (const uint hash_mode
)
5816 case 0: return ((char *) HT_00000
); break;
5817 case 10: return ((char *) HT_00010
); break;
5818 case 11: return ((char *) HT_00011
); break;
5819 case 12: return ((char *) HT_00012
); break;
5820 case 20: return ((char *) HT_00020
); break;
5821 case 21: return ((char *) HT_00021
); break;
5822 case 22: return ((char *) HT_00022
); break;
5823 case 23: return ((char *) HT_00023
); break;
5824 case 30: return ((char *) HT_00030
); break;
5825 case 40: return ((char *) HT_00040
); break;
5826 case 50: return ((char *) HT_00050
); break;
5827 case 60: return ((char *) HT_00060
); break;
5828 case 100: return ((char *) HT_00100
); break;
5829 case 101: return ((char *) HT_00101
); break;
5830 case 110: return ((char *) HT_00110
); break;
5831 case 111: return ((char *) HT_00111
); break;
5832 case 112: return ((char *) HT_00112
); break;
5833 case 120: return ((char *) HT_00120
); break;
5834 case 121: return ((char *) HT_00121
); break;
5835 case 122: return ((char *) HT_00122
); break;
5836 case 124: return ((char *) HT_00124
); break;
5837 case 125: return ((char *) HT_00125
); break;
5838 case 130: return ((char *) HT_00130
); break;
5839 case 131: return ((char *) HT_00131
); break;
5840 case 132: return ((char *) HT_00132
); break;
5841 case 133: return ((char *) HT_00133
); break;
5842 case 140: return ((char *) HT_00140
); break;
5843 case 141: return ((char *) HT_00141
); break;
5844 case 150: return ((char *) HT_00150
); break;
5845 case 160: return ((char *) HT_00160
); break;
5846 case 190: return ((char *) HT_00190
); break;
5847 case 200: return ((char *) HT_00200
); break;
5848 case 300: return ((char *) HT_00300
); break;
5849 case 400: return ((char *) HT_00400
); break;
5850 case 500: return ((char *) HT_00500
); break;
5851 case 501: return ((char *) HT_00501
); break;
5852 case 900: return ((char *) HT_00900
); break;
5853 case 910: return ((char *) HT_00910
); break;
5854 case 1000: return ((char *) HT_01000
); break;
5855 case 1100: return ((char *) HT_01100
); break;
5856 case 1400: return ((char *) HT_01400
); break;
5857 case 1410: return ((char *) HT_01410
); break;
5858 case 1420: return ((char *) HT_01420
); break;
5859 case 1421: return ((char *) HT_01421
); break;
5860 case 1430: return ((char *) HT_01430
); break;
5861 case 1440: return ((char *) HT_01440
); break;
5862 case 1441: return ((char *) HT_01441
); break;
5863 case 1450: return ((char *) HT_01450
); break;
5864 case 1460: return ((char *) HT_01460
); break;
5865 case 1500: return ((char *) HT_01500
); break;
5866 case 1600: return ((char *) HT_01600
); break;
5867 case 1700: return ((char *) HT_01700
); break;
5868 case 1710: return ((char *) HT_01710
); break;
5869 case 1711: return ((char *) HT_01711
); break;
5870 case 1720: return ((char *) HT_01720
); break;
5871 case 1722: return ((char *) HT_01722
); break;
5872 case 1730: return ((char *) HT_01730
); break;
5873 case 1731: return ((char *) HT_01731
); break;
5874 case 1740: return ((char *) HT_01740
); break;
5875 case 1750: return ((char *) HT_01750
); break;
5876 case 1760: return ((char *) HT_01760
); break;
5877 case 1800: return ((char *) HT_01800
); break;
5878 case 2100: return ((char *) HT_02100
); break;
5879 case 2400: return ((char *) HT_02400
); break;
5880 case 2410: return ((char *) HT_02410
); break;
5881 case 2500: return ((char *) HT_02500
); break;
5882 case 2600: return ((char *) HT_02600
); break;
5883 case 2611: return ((char *) HT_02611
); break;
5884 case 2612: return ((char *) HT_02612
); break;
5885 case 2711: return ((char *) HT_02711
); break;
5886 case 2811: return ((char *) HT_02811
); break;
5887 case 3000: return ((char *) HT_03000
); break;
5888 case 3100: return ((char *) HT_03100
); break;
5889 case 3200: return ((char *) HT_03200
); break;
5890 case 3710: return ((char *) HT_03710
); break;
5891 case 3711: return ((char *) HT_03711
); break;
5892 case 3800: return ((char *) HT_03800
); break;
5893 case 4300: return ((char *) HT_04300
); break;
5894 case 4400: return ((char *) HT_04400
); break;
5895 case 4500: return ((char *) HT_04500
); break;
5896 case 4700: return ((char *) HT_04700
); break;
5897 case 4800: return ((char *) HT_04800
); break;
5898 case 4900: return ((char *) HT_04900
); break;
5899 case 5000: return ((char *) HT_05000
); break;
5900 case 5100: return ((char *) HT_05100
); break;
5901 case 5200: return ((char *) HT_05200
); break;
5902 case 5300: return ((char *) HT_05300
); break;
5903 case 5400: return ((char *) HT_05400
); break;
5904 case 5500: return ((char *) HT_05500
); break;
5905 case 5600: return ((char *) HT_05600
); break;
5906 case 5700: return ((char *) HT_05700
); break;
5907 case 5800: return ((char *) HT_05800
); break;
5908 case 6000: return ((char *) HT_06000
); break;
5909 case 6100: return ((char *) HT_06100
); break;
5910 case 6211: return ((char *) HT_06211
); break;
5911 case 6212: return ((char *) HT_06212
); break;
5912 case 6213: return ((char *) HT_06213
); break;
5913 case 6221: return ((char *) HT_06221
); break;
5914 case 6222: return ((char *) HT_06222
); break;
5915 case 6223: return ((char *) HT_06223
); break;
5916 case 6231: return ((char *) HT_06231
); break;
5917 case 6232: return ((char *) HT_06232
); break;
5918 case 6233: return ((char *) HT_06233
); break;
5919 case 6241: return ((char *) HT_06241
); break;
5920 case 6242: return ((char *) HT_06242
); break;
5921 case 6243: return ((char *) HT_06243
); break;
5922 case 6300: return ((char *) HT_06300
); break;
5923 case 6400: return ((char *) HT_06400
); break;
5924 case 6500: return ((char *) HT_06500
); break;
5925 case 6600: return ((char *) HT_06600
); break;
5926 case 6700: return ((char *) HT_06700
); break;
5927 case 6800: return ((char *) HT_06800
); break;
5928 case 6900: return ((char *) HT_06900
); break;
5929 case 7100: return ((char *) HT_07100
); break;
5930 case 7200: return ((char *) HT_07200
); break;
5931 case 7300: return ((char *) HT_07300
); break;
5932 case 7400: return ((char *) HT_07400
); break;
5933 case 7500: return ((char *) HT_07500
); break;
5934 case 7600: return ((char *) HT_07600
); break;
5935 case 7700: return ((char *) HT_07700
); break;
5936 case 7800: return ((char *) HT_07800
); break;
5937 case 7900: return ((char *) HT_07900
); break;
5938 case 8000: return ((char *) HT_08000
); break;
5939 case 8100: return ((char *) HT_08100
); break;
5940 case 8200: return ((char *) HT_08200
); break;
5941 case 8300: return ((char *) HT_08300
); break;
5942 case 8400: return ((char *) HT_08400
); break;
5943 case 8500: return ((char *) HT_08500
); break;
5944 case 8600: return ((char *) HT_08600
); break;
5945 case 8700: return ((char *) HT_08700
); break;
5946 case 8800: return ((char *) HT_08800
); break;
5947 case 8900: return ((char *) HT_08900
); break;
5948 case 9000: return ((char *) HT_09000
); break;
5949 case 9100: return ((char *) HT_09100
); break;
5950 case 9200: return ((char *) HT_09200
); break;
5951 case 9300: return ((char *) HT_09300
); break;
5952 case 9400: return ((char *) HT_09400
); break;
5953 case 9500: return ((char *) HT_09500
); break;
5954 case 9600: return ((char *) HT_09600
); break;
5955 case 9700: return ((char *) HT_09700
); break;
5956 case 9710: return ((char *) HT_09710
); break;
5957 case 9720: return ((char *) HT_09720
); break;
5958 case 9800: return ((char *) HT_09800
); break;
5959 case 9810: return ((char *) HT_09810
); break;
5960 case 9820: return ((char *) HT_09820
); break;
5961 case 9900: return ((char *) HT_09900
); break;
5962 case 10000: return ((char *) HT_10000
); break;
5963 case 10100: return ((char *) HT_10100
); break;
5964 case 10200: return ((char *) HT_10200
); break;
5965 case 10300: return ((char *) HT_10300
); break;
5966 case 10400: return ((char *) HT_10400
); break;
5967 case 10410: return ((char *) HT_10410
); break;
5968 case 10420: return ((char *) HT_10420
); break;
5969 case 10500: return ((char *) HT_10500
); break;
5970 case 10600: return ((char *) HT_10600
); break;
5971 case 10700: return ((char *) HT_10700
); break;
5972 case 10800: return ((char *) HT_10800
); break;
5973 case 10900: return ((char *) HT_10900
); break;
5974 case 11000: return ((char *) HT_11000
); break;
5975 case 11100: return ((char *) HT_11100
); break;
5976 case 11200: return ((char *) HT_11200
); break;
5977 case 11300: return ((char *) HT_11300
); break;
5978 case 11400: return ((char *) HT_11400
); break;
5979 case 11500: return ((char *) HT_11500
); break;
5980 case 11600: return ((char *) HT_11600
); break;
5981 case 11700: return ((char *) HT_11700
); break;
5982 case 11800: return ((char *) HT_11800
); break;
5983 case 11900: return ((char *) HT_11900
); break;
5984 case 12000: return ((char *) HT_12000
); break;
5985 case 12100: return ((char *) HT_12100
); break;
5986 case 12200: return ((char *) HT_12200
); break;
5987 case 12300: return ((char *) HT_12300
); break;
5988 case 12400: return ((char *) HT_12400
); break;
5989 case 12500: return ((char *) HT_12500
); break;
5990 case 12600: return ((char *) HT_12600
); break;
5991 case 12700: return ((char *) HT_12700
); break;
5992 case 12800: return ((char *) HT_12800
); break;
5993 case 12900: return ((char *) HT_12900
); break;
5994 case 13000: return ((char *) HT_13000
); break;
5995 case 13100: return ((char *) HT_13100
); break;
5996 case 13200: return ((char *) HT_13200
); break;
5997 case 13300: return ((char *) HT_13300
); break;
5998 case 13400: return ((char *) HT_13400
); break;
5999 case 13500: return ((char *) HT_13500
); break;
6000 case 13600: return ((char *) HT_13600
); break;
6001 case 13711: return ((char *) HT_13711
); break;
6002 case 13712: return ((char *) HT_13712
); break;
6003 case 13713: return ((char *) HT_13713
); break;
6004 case 13721: return ((char *) HT_13721
); break;
6005 case 13722: return ((char *) HT_13722
); break;
6006 case 13723: return ((char *) HT_13723
); break;
6007 case 13731: return ((char *) HT_13731
); break;
6008 case 13732: return ((char *) HT_13732
); break;
6009 case 13733: return ((char *) HT_13733
); break;
6010 case 13741: return ((char *) HT_13741
); break;
6011 case 13742: return ((char *) HT_13742
); break;
6012 case 13743: return ((char *) HT_13743
); break;
6013 case 13751: return ((char *) HT_13751
); break;
6014 case 13752: return ((char *) HT_13752
); break;
6015 case 13753: return ((char *) HT_13753
); break;
6016 case 13761: return ((char *) HT_13761
); break;
6017 case 13762: return ((char *) HT_13762
); break;
6018 case 13763: return ((char *) HT_13763
); break;
6021 return ((char *) "Unknown");
6024 char *strstatus (const uint devices_status
)
6026 switch (devices_status
)
6028 case STATUS_INIT
: return ((char *) ST_0000
); break;
6029 case STATUS_STARTING
: return ((char *) ST_0001
); break;
6030 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
6031 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
6032 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
6033 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
6034 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
6035 case STATUS_QUIT
: return ((char *) ST_0007
); break;
6036 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
6037 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
6038 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
6041 return ((char *) "Unknown");
6044 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
6046 uint hash_type
= data
.hash_type
;
6047 uint hash_mode
= data
.hash_mode
;
6048 uint salt_type
= data
.salt_type
;
6049 uint opts_type
= data
.opts_type
;
6050 uint opti_type
= data
.opti_type
;
6051 uint dgst_size
= data
.dgst_size
;
6053 char *hashfile
= data
.hashfile
;
6057 uint digest_buf
[64] = { 0 };
6059 u64
*digest_buf64
= (u64
*) digest_buf
;
6061 char *digests_buf_ptr
= (char *) data
.digests_buf
;
6063 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
6065 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6071 case HASH_TYPE_DESCRYPT
:
6072 FP (digest_buf
[1], digest_buf
[0], tt
);
6075 case HASH_TYPE_DESRACF
:
6076 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6077 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6079 FP (digest_buf
[1], digest_buf
[0], tt
);
6083 FP (digest_buf
[1], digest_buf
[0], tt
);
6086 case HASH_TYPE_NETNTLM
:
6087 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6088 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6089 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
6090 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
6092 FP (digest_buf
[1], digest_buf
[0], tt
);
6093 FP (digest_buf
[3], digest_buf
[2], tt
);
6096 case HASH_TYPE_BSDICRYPT
:
6097 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
6098 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
6100 FP (digest_buf
[1], digest_buf
[0], tt
);
6105 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
6110 digest_buf
[0] += MD4M_A
;
6111 digest_buf
[1] += MD4M_B
;
6112 digest_buf
[2] += MD4M_C
;
6113 digest_buf
[3] += MD4M_D
;
6117 digest_buf
[0] += MD5M_A
;
6118 digest_buf
[1] += MD5M_B
;
6119 digest_buf
[2] += MD5M_C
;
6120 digest_buf
[3] += MD5M_D
;
6123 case HASH_TYPE_SHA1
:
6124 digest_buf
[0] += SHA1M_A
;
6125 digest_buf
[1] += SHA1M_B
;
6126 digest_buf
[2] += SHA1M_C
;
6127 digest_buf
[3] += SHA1M_D
;
6128 digest_buf
[4] += SHA1M_E
;
6131 case HASH_TYPE_SHA256
:
6132 digest_buf
[0] += SHA256M_A
;
6133 digest_buf
[1] += SHA256M_B
;
6134 digest_buf
[2] += SHA256M_C
;
6135 digest_buf
[3] += SHA256M_D
;
6136 digest_buf
[4] += SHA256M_E
;
6137 digest_buf
[5] += SHA256M_F
;
6138 digest_buf
[6] += SHA256M_G
;
6139 digest_buf
[7] += SHA256M_H
;
6142 case HASH_TYPE_SHA384
:
6143 digest_buf64
[0] += SHA384M_A
;
6144 digest_buf64
[1] += SHA384M_B
;
6145 digest_buf64
[2] += SHA384M_C
;
6146 digest_buf64
[3] += SHA384M_D
;
6147 digest_buf64
[4] += SHA384M_E
;
6148 digest_buf64
[5] += SHA384M_F
;
6149 digest_buf64
[6] += 0;
6150 digest_buf64
[7] += 0;
6153 case HASH_TYPE_SHA512
:
6154 digest_buf64
[0] += SHA512M_A
;
6155 digest_buf64
[1] += SHA512M_B
;
6156 digest_buf64
[2] += SHA512M_C
;
6157 digest_buf64
[3] += SHA512M_D
;
6158 digest_buf64
[4] += SHA512M_E
;
6159 digest_buf64
[5] += SHA512M_F
;
6160 digest_buf64
[6] += SHA512M_G
;
6161 digest_buf64
[7] += SHA512M_H
;
6166 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6168 if (dgst_size
== DGST_SIZE_4_2
)
6170 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6172 else if (dgst_size
== DGST_SIZE_4_4
)
6174 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6176 else if (dgst_size
== DGST_SIZE_4_5
)
6178 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6180 else if (dgst_size
== DGST_SIZE_4_6
)
6182 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6184 else if (dgst_size
== DGST_SIZE_4_8
)
6186 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6188 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6190 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6192 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6194 else if (hash_type
== HASH_TYPE_SHA384
)
6196 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6198 else if (hash_type
== HASH_TYPE_SHA512
)
6200 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6202 else if (hash_type
== HASH_TYPE_GOST
)
6204 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6207 else if (dgst_size
== DGST_SIZE_4_64
)
6209 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6211 else if (dgst_size
== DGST_SIZE_8_25
)
6213 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6217 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6218 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6219 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6225 memset (&salt
, 0, sizeof (salt_t
));
6227 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6229 char *ptr
= (char *) salt
.salt_buf
;
6231 uint len
= salt
.salt_len
;
6233 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6239 case HASH_TYPE_NETNTLM
:
6241 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6242 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6244 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6250 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6252 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6260 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6262 uint max
= salt
.salt_len
/ 4;
6266 for (uint i
= 0; i
< max
; i
++)
6268 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6272 if (opts_type
& OPTS_TYPE_ST_HEX
)
6274 char tmp
[64] = { 0 };
6276 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6278 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6283 memcpy (ptr
, tmp
, len
);
6286 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6288 memset (ptr
+ len
, 0, memset_size
);
6290 salt
.salt_len
= len
;
6294 // some modes require special encoding
6297 uint out_buf_plain
[256] = { 0 };
6298 uint out_buf_salt
[256] = { 0 };
6300 char tmp_buf
[1024] = { 0 };
6302 char *ptr_plain
= (char *) out_buf_plain
;
6303 char *ptr_salt
= (char *) out_buf_salt
;
6305 if (hash_mode
== 22)
6307 char username
[30] = { 0 };
6309 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6311 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6313 u16
*ptr
= (u16
*) digest_buf
;
6315 tmp_buf
[ 0] = sig
[0];
6316 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6317 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6318 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6319 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6320 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6321 tmp_buf
[ 6] = sig
[1];
6322 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6323 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6324 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6325 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6326 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6327 tmp_buf
[12] = sig
[2];
6328 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6329 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6330 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6331 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6332 tmp_buf
[17] = sig
[3];
6333 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6334 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6335 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6336 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6337 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6338 tmp_buf
[23] = sig
[4];
6339 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6340 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6341 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6342 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6343 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6344 tmp_buf
[29] = sig
[5];
6346 snprintf (out_buf
, len
-1, "%s:%s",
6350 else if (hash_mode
== 23)
6352 // do not show the skyper part in output
6354 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6356 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6358 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6365 else if (hash_mode
== 101)
6367 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6369 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6370 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6371 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6372 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6373 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6375 memcpy (tmp_buf
, digest_buf
, 20);
6377 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6379 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6381 else if (hash_mode
== 111)
6383 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6385 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6386 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6387 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6388 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6389 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6391 memcpy (tmp_buf
, digest_buf
, 20);
6392 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6394 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6396 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6398 else if ((hash_mode
== 122) || (hash_mode
== 125))
6400 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6401 (char *) salt
.salt_buf
,
6408 else if (hash_mode
== 124)
6410 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6411 (char *) salt
.salt_buf
,
6418 else if (hash_mode
== 131)
6420 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6421 (char *) salt
.salt_buf
,
6429 else if (hash_mode
== 132)
6431 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6432 (char *) salt
.salt_buf
,
6439 else if (hash_mode
== 133)
6441 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6443 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6444 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6445 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6446 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6447 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6449 memcpy (tmp_buf
, digest_buf
, 20);
6451 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6453 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6455 else if (hash_mode
== 141)
6457 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6459 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6461 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6463 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6465 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6466 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6467 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6468 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6469 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6471 memcpy (tmp_buf
, digest_buf
, 20);
6473 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6477 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6479 else if (hash_mode
== 400)
6481 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6483 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6484 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6485 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6486 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6488 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6490 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6492 else if (hash_mode
== 500)
6494 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6496 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6497 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6498 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6499 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6501 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6503 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6505 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6509 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6512 else if (hash_mode
== 501)
6514 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6516 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6517 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6519 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6521 else if (hash_mode
== 1421)
6523 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6525 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6541 else if (hash_mode
== 1441)
6543 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6545 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6547 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6549 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6551 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6552 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6553 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6554 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6555 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6556 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6557 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6558 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6560 memcpy (tmp_buf
, digest_buf
, 32);
6562 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6566 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6568 else if (hash_mode
== 1500)
6570 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6571 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6572 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6573 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6574 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6576 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6578 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6580 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6581 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6583 memcpy (tmp_buf
, digest_buf
, 8);
6585 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6587 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6591 else if (hash_mode
== 1600)
6593 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6595 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6596 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6597 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6598 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6600 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6602 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6604 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6608 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6611 else if (hash_mode
== 1711)
6613 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6615 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6616 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6617 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6618 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6619 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6620 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6621 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6622 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6624 memcpy (tmp_buf
, digest_buf
, 64);
6625 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6627 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6629 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6631 else if (hash_mode
== 1722)
6633 uint
*ptr
= digest_buf
;
6635 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6636 (unsigned char *) salt
.salt_buf
,
6646 else if (hash_mode
== 1731)
6648 uint
*ptr
= digest_buf
;
6650 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6651 (unsigned char *) salt
.salt_buf
,
6661 else if (hash_mode
== 1800)
6665 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6666 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6667 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6668 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6669 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6670 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6671 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6672 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6674 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6676 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6678 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6682 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6685 else if (hash_mode
== 2100)
6689 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6691 salt
.salt_iter
+ 1);
6693 uint signature_len
= strlen (out_buf
);
6695 pos
+= signature_len
;
6696 len
-= signature_len
;
6698 char *salt_ptr
= (char *) salt
.salt_buf
;
6700 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6702 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6703 byte_swap_32 (digest_buf
[0]),
6704 byte_swap_32 (digest_buf
[1]),
6705 byte_swap_32 (digest_buf
[2]),
6706 byte_swap_32 (digest_buf
[3]));
6708 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6710 memcpy (tmp_buf
, digest_buf
, 16);
6712 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6714 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6715 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6716 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6717 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6719 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6720 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6721 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6722 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6724 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6725 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6726 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6727 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6729 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6730 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6731 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6732 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6734 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6735 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6736 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6737 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6741 else if (hash_mode
== 2500)
6743 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6745 wpa_t
*wpa
= &wpas
[salt_pos
];
6747 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6748 (char *) salt
.salt_buf
,
6762 else if (hash_mode
== 4400)
6764 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6765 byte_swap_32 (digest_buf
[0]),
6766 byte_swap_32 (digest_buf
[1]),
6767 byte_swap_32 (digest_buf
[2]),
6768 byte_swap_32 (digest_buf
[3]));
6770 else if (hash_mode
== 4700)
6772 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6773 byte_swap_32 (digest_buf
[0]),
6774 byte_swap_32 (digest_buf
[1]),
6775 byte_swap_32 (digest_buf
[2]),
6776 byte_swap_32 (digest_buf
[3]),
6777 byte_swap_32 (digest_buf
[4]));
6779 else if (hash_mode
== 4800)
6781 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6783 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6788 byte_swap_32 (salt
.salt_buf
[0]),
6789 byte_swap_32 (salt
.salt_buf
[1]),
6790 byte_swap_32 (salt
.salt_buf
[2]),
6791 byte_swap_32 (salt
.salt_buf
[3]),
6794 else if (hash_mode
== 4900)
6796 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6797 byte_swap_32 (digest_buf
[0]),
6798 byte_swap_32 (digest_buf
[1]),
6799 byte_swap_32 (digest_buf
[2]),
6800 byte_swap_32 (digest_buf
[3]),
6801 byte_swap_32 (digest_buf
[4]));
6803 else if (hash_mode
== 5100)
6805 snprintf (out_buf
, len
-1, "%08x%08x",
6809 else if (hash_mode
== 5200)
6811 snprintf (out_buf
, len
-1, "%s", hashfile
);
6813 else if (hash_mode
== 5300)
6815 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6817 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6819 int buf_len
= len
-1;
6823 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6825 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6827 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6829 snprintf (out_buf
, buf_len
, ":");
6835 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6843 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6845 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6847 if ((i
== 0) || (i
== 5))
6849 snprintf (out_buf
, buf_len
, ":");
6855 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6863 for (uint i
= 0; i
< 4; i
++)
6867 snprintf (out_buf
, buf_len
, ":");
6873 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6879 else if (hash_mode
== 5400)
6881 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6883 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6885 int buf_len
= len
-1;
6889 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6891 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6893 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6895 snprintf (out_buf
, buf_len
, ":");
6901 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6909 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6911 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6913 if ((i
== 0) || (i
== 5))
6915 snprintf (out_buf
, buf_len
, ":");
6921 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6929 for (uint i
= 0; i
< 5; i
++)
6933 snprintf (out_buf
, buf_len
, ":");
6939 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6945 else if (hash_mode
== 5500)
6947 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6949 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6951 char user_buf
[64] = { 0 };
6952 char domain_buf
[64] = { 0 };
6953 char srvchall_buf
[1024] = { 0 };
6954 char clichall_buf
[1024] = { 0 };
6956 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6958 char *ptr
= (char *) netntlm
->userdomain_buf
;
6960 user_buf
[i
] = ptr
[j
];
6963 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6965 char *ptr
= (char *) netntlm
->userdomain_buf
;
6967 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6970 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6972 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6974 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6977 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6979 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6981 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6984 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6992 byte_swap_32 (salt
.salt_buf_pc
[0]),
6993 byte_swap_32 (salt
.salt_buf_pc
[1]),
6996 else if (hash_mode
== 5600)
6998 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7000 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7002 char user_buf
[64] = { 0 };
7003 char domain_buf
[64] = { 0 };
7004 char srvchall_buf
[1024] = { 0 };
7005 char clichall_buf
[1024] = { 0 };
7007 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7009 char *ptr
= (char *) netntlm
->userdomain_buf
;
7011 user_buf
[i
] = ptr
[j
];
7014 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7016 char *ptr
= (char *) netntlm
->userdomain_buf
;
7018 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7021 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7023 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7025 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7028 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7030 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7032 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7035 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
7045 else if (hash_mode
== 5700)
7047 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7049 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7050 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7051 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7052 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7053 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7054 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7055 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7056 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7058 memcpy (tmp_buf
, digest_buf
, 32);
7060 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
7064 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
7066 else if (hash_mode
== 5800)
7068 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7069 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7070 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7071 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7072 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7074 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
7081 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
7083 snprintf (out_buf
, len
-1, "%s", hashfile
);
7085 else if (hash_mode
== 6300)
7087 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7089 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7090 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7091 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7092 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7094 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7096 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7098 else if (hash_mode
== 6400)
7100 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7102 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7104 else if (hash_mode
== 6500)
7106 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7108 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7110 else if (hash_mode
== 6600)
7112 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
7114 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
7116 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7117 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7119 uint buf_len
= len
- 1;
7121 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
7124 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
7126 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
7131 else if (hash_mode
== 6700)
7133 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7135 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7137 else if (hash_mode
== 6800)
7139 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
7141 else if (hash_mode
== 7100)
7143 uint
*ptr
= digest_buf
;
7145 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7147 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7149 uint esalt
[8] = { 0 };
7151 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7152 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7153 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7154 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7155 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7156 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7157 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7158 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7160 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",
7161 SIGNATURE_SHA512OSX
,
7163 esalt
[ 0], esalt
[ 1],
7164 esalt
[ 2], esalt
[ 3],
7165 esalt
[ 4], esalt
[ 5],
7166 esalt
[ 6], esalt
[ 7],
7174 ptr
[15], ptr
[14]);
7176 else if (hash_mode
== 7200)
7178 uint
*ptr
= digest_buf
;
7180 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7182 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7186 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7188 len_used
= strlen (out_buf
);
7190 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7192 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7194 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7197 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",
7205 ptr
[15], ptr
[14]);
7207 else if (hash_mode
== 7300)
7209 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7211 rakp_t
*rakp
= &rakps
[salt_pos
];
7213 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7215 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7218 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7225 else if (hash_mode
== 7400)
7227 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7229 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7230 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7231 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7232 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7233 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7234 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7235 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7236 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7238 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7240 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7242 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7246 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7249 else if (hash_mode
== 7500)
7251 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7253 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7255 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7256 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7258 char data
[128] = { 0 };
7260 char *ptr_data
= data
;
7262 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7264 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7267 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7269 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7274 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7276 (char *) krb5pa
->user
,
7277 (char *) krb5pa
->realm
,
7278 (char *) krb5pa
->salt
,
7281 else if (hash_mode
== 7700)
7283 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7284 (char *) salt
.salt_buf
,
7288 else if (hash_mode
== 7800)
7290 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7291 (char *) salt
.salt_buf
,
7298 else if (hash_mode
== 7900)
7300 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7304 char *tmp
= (char *) salt
.salt_buf_pc
;
7306 ptr_plain
[42] = tmp
[0];
7312 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7314 else if (hash_mode
== 8000)
7316 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7317 (unsigned char *) salt
.salt_buf
,
7327 else if (hash_mode
== 8100)
7329 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7330 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7332 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7333 (unsigned char *) salt
.salt_buf
,
7340 else if (hash_mode
== 8200)
7342 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7344 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7346 char data_buf
[4096] = { 0 };
7348 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7350 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7353 data_buf
[cloudkey
->data_len
* 2] = 0;
7355 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7356 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7357 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7358 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7359 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7360 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7361 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7362 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7364 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7365 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7366 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7367 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7369 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7385 else if (hash_mode
== 8300)
7387 char digest_buf_c
[34] = { 0 };
7389 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7390 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7391 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7392 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7393 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7395 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7397 digest_buf_c
[32] = 0;
7401 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7403 char domain_buf_c
[33] = { 0 };
7405 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7407 for (uint i
= 0; i
< salt_pc_len
; i
++)
7409 const char next
= domain_buf_c
[i
];
7411 domain_buf_c
[i
] = '.';
7416 domain_buf_c
[salt_pc_len
] = 0;
7420 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7422 else if (hash_mode
== 8500)
7424 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7426 else if (hash_mode
== 2612)
7428 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7430 (char *) salt
.salt_buf
,
7436 else if (hash_mode
== 3711)
7438 char *salt_ptr
= (char *) salt
.salt_buf
;
7440 salt_ptr
[salt
.salt_len
- 1] = 0;
7442 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7443 SIGNATURE_MEDIAWIKI_B
,
7450 else if (hash_mode
== 8800)
7452 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7454 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7456 char tmp
[3073] = { 0 };
7458 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7460 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7465 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7466 SIGNATURE_ANDROIDFDE
,
7467 byte_swap_32 (salt
.salt_buf
[0]),
7468 byte_swap_32 (salt
.salt_buf
[1]),
7469 byte_swap_32 (salt
.salt_buf
[2]),
7470 byte_swap_32 (salt
.salt_buf
[3]),
7471 byte_swap_32 (digest_buf
[0]),
7472 byte_swap_32 (digest_buf
[1]),
7473 byte_swap_32 (digest_buf
[2]),
7474 byte_swap_32 (digest_buf
[3]),
7477 else if (hash_mode
== 8900)
7479 uint N
= salt
.scrypt_N
;
7480 uint r
= salt
.scrypt_r
;
7481 uint p
= salt
.scrypt_p
;
7483 char base64_salt
[32] = { 0 };
7485 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7487 memset (tmp_buf
, 0, 46);
7489 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7490 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7491 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7492 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7493 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7494 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7495 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7496 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7497 digest_buf
[8] = 0; // needed for base64_encode ()
7499 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7501 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7509 else if (hash_mode
== 9000)
7511 snprintf (out_buf
, len
-1, "%s", hashfile
);
7513 else if (hash_mode
== 9200)
7517 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7519 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7521 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7525 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7526 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7527 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7528 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7529 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7530 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7531 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7532 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7533 digest_buf
[8] = 0; // needed for base64_encode ()
7535 char tmp_buf
[64] = { 0 };
7537 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7538 tmp_buf
[43] = 0; // cut it here
7542 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7544 else if (hash_mode
== 9300)
7546 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7547 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7548 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7549 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7550 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7551 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7552 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7553 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7554 digest_buf
[8] = 0; // needed for base64_encode ()
7556 char tmp_buf
[64] = { 0 };
7558 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7559 tmp_buf
[43] = 0; // cut it here
7561 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7563 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7565 else if (hash_mode
== 9400)
7567 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7569 office2007_t
*office2007
= &office2007s
[salt_pos
];
7571 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7572 SIGNATURE_OFFICE2007
,
7575 office2007
->keySize
,
7581 office2007
->encryptedVerifier
[0],
7582 office2007
->encryptedVerifier
[1],
7583 office2007
->encryptedVerifier
[2],
7584 office2007
->encryptedVerifier
[3],
7585 office2007
->encryptedVerifierHash
[0],
7586 office2007
->encryptedVerifierHash
[1],
7587 office2007
->encryptedVerifierHash
[2],
7588 office2007
->encryptedVerifierHash
[3],
7589 office2007
->encryptedVerifierHash
[4]);
7591 else if (hash_mode
== 9500)
7593 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7595 office2010_t
*office2010
= &office2010s
[salt_pos
];
7597 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,
7603 office2010
->encryptedVerifier
[0],
7604 office2010
->encryptedVerifier
[1],
7605 office2010
->encryptedVerifier
[2],
7606 office2010
->encryptedVerifier
[3],
7607 office2010
->encryptedVerifierHash
[0],
7608 office2010
->encryptedVerifierHash
[1],
7609 office2010
->encryptedVerifierHash
[2],
7610 office2010
->encryptedVerifierHash
[3],
7611 office2010
->encryptedVerifierHash
[4],
7612 office2010
->encryptedVerifierHash
[5],
7613 office2010
->encryptedVerifierHash
[6],
7614 office2010
->encryptedVerifierHash
[7]);
7616 else if (hash_mode
== 9600)
7618 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7620 office2013_t
*office2013
= &office2013s
[salt_pos
];
7622 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,
7628 office2013
->encryptedVerifier
[0],
7629 office2013
->encryptedVerifier
[1],
7630 office2013
->encryptedVerifier
[2],
7631 office2013
->encryptedVerifier
[3],
7632 office2013
->encryptedVerifierHash
[0],
7633 office2013
->encryptedVerifierHash
[1],
7634 office2013
->encryptedVerifierHash
[2],
7635 office2013
->encryptedVerifierHash
[3],
7636 office2013
->encryptedVerifierHash
[4],
7637 office2013
->encryptedVerifierHash
[5],
7638 office2013
->encryptedVerifierHash
[6],
7639 office2013
->encryptedVerifierHash
[7]);
7641 else if (hash_mode
== 9700)
7643 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7645 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7647 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7648 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7649 byte_swap_32 (salt
.salt_buf
[0]),
7650 byte_swap_32 (salt
.salt_buf
[1]),
7651 byte_swap_32 (salt
.salt_buf
[2]),
7652 byte_swap_32 (salt
.salt_buf
[3]),
7653 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7654 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7655 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7656 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7657 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7658 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7659 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7660 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7662 else if (hash_mode
== 9710)
7664 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7666 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7668 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7669 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7670 byte_swap_32 (salt
.salt_buf
[0]),
7671 byte_swap_32 (salt
.salt_buf
[1]),
7672 byte_swap_32 (salt
.salt_buf
[2]),
7673 byte_swap_32 (salt
.salt_buf
[3]),
7674 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7675 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7676 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7677 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7678 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7679 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7680 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7681 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7683 else if (hash_mode
== 9720)
7685 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7687 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7689 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7691 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7692 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7693 byte_swap_32 (salt
.salt_buf
[0]),
7694 byte_swap_32 (salt
.salt_buf
[1]),
7695 byte_swap_32 (salt
.salt_buf
[2]),
7696 byte_swap_32 (salt
.salt_buf
[3]),
7697 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7698 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7699 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7700 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7701 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7702 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7703 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7704 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7711 else if (hash_mode
== 9800)
7713 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7715 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7717 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7718 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7723 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7724 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7725 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7726 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7727 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7728 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7729 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7730 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7731 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7733 else if (hash_mode
== 9810)
7735 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7737 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7739 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7740 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7745 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7746 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7747 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7748 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7749 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7750 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7751 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7752 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7753 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7755 else if (hash_mode
== 9820)
7757 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7759 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7761 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7763 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7764 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7769 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7770 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7771 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7772 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7773 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7774 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7775 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7776 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7777 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7784 else if (hash_mode
== 10000)
7788 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7790 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7792 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7796 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7797 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7798 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7799 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7800 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7801 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7802 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7803 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7804 digest_buf
[8] = 0; // needed for base64_encode ()
7806 char tmp_buf
[64] = { 0 };
7808 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7812 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7814 else if (hash_mode
== 10100)
7816 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7821 byte_swap_32 (salt
.salt_buf
[0]),
7822 byte_swap_32 (salt
.salt_buf
[1]),
7823 byte_swap_32 (salt
.salt_buf
[2]),
7824 byte_swap_32 (salt
.salt_buf
[3]));
7826 else if (hash_mode
== 10200)
7828 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7830 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7834 char challenge
[100] = { 0 };
7836 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7840 char tmp_buf
[100] = { 0 };
7842 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7843 (char *) cram_md5
->user
,
7849 char response
[100] = { 0 };
7851 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7853 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7855 else if (hash_mode
== 10300)
7857 char tmp_buf
[100] = { 0 };
7859 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7860 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7862 uint tmp_len
= 20 + salt
.salt_len
;
7866 char base64_encoded
[100] = { 0 };
7868 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7870 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7872 else if (hash_mode
== 10400)
7874 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7876 pdf_t
*pdf
= &pdfs
[salt_pos
];
7878 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",
7886 byte_swap_32 (pdf
->id_buf
[0]),
7887 byte_swap_32 (pdf
->id_buf
[1]),
7888 byte_swap_32 (pdf
->id_buf
[2]),
7889 byte_swap_32 (pdf
->id_buf
[3]),
7891 byte_swap_32 (pdf
->u_buf
[0]),
7892 byte_swap_32 (pdf
->u_buf
[1]),
7893 byte_swap_32 (pdf
->u_buf
[2]),
7894 byte_swap_32 (pdf
->u_buf
[3]),
7895 byte_swap_32 (pdf
->u_buf
[4]),
7896 byte_swap_32 (pdf
->u_buf
[5]),
7897 byte_swap_32 (pdf
->u_buf
[6]),
7898 byte_swap_32 (pdf
->u_buf
[7]),
7900 byte_swap_32 (pdf
->o_buf
[0]),
7901 byte_swap_32 (pdf
->o_buf
[1]),
7902 byte_swap_32 (pdf
->o_buf
[2]),
7903 byte_swap_32 (pdf
->o_buf
[3]),
7904 byte_swap_32 (pdf
->o_buf
[4]),
7905 byte_swap_32 (pdf
->o_buf
[5]),
7906 byte_swap_32 (pdf
->o_buf
[6]),
7907 byte_swap_32 (pdf
->o_buf
[7])
7910 else if (hash_mode
== 10410)
7912 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7914 pdf_t
*pdf
= &pdfs
[salt_pos
];
7916 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",
7924 byte_swap_32 (pdf
->id_buf
[0]),
7925 byte_swap_32 (pdf
->id_buf
[1]),
7926 byte_swap_32 (pdf
->id_buf
[2]),
7927 byte_swap_32 (pdf
->id_buf
[3]),
7929 byte_swap_32 (pdf
->u_buf
[0]),
7930 byte_swap_32 (pdf
->u_buf
[1]),
7931 byte_swap_32 (pdf
->u_buf
[2]),
7932 byte_swap_32 (pdf
->u_buf
[3]),
7933 byte_swap_32 (pdf
->u_buf
[4]),
7934 byte_swap_32 (pdf
->u_buf
[5]),
7935 byte_swap_32 (pdf
->u_buf
[6]),
7936 byte_swap_32 (pdf
->u_buf
[7]),
7938 byte_swap_32 (pdf
->o_buf
[0]),
7939 byte_swap_32 (pdf
->o_buf
[1]),
7940 byte_swap_32 (pdf
->o_buf
[2]),
7941 byte_swap_32 (pdf
->o_buf
[3]),
7942 byte_swap_32 (pdf
->o_buf
[4]),
7943 byte_swap_32 (pdf
->o_buf
[5]),
7944 byte_swap_32 (pdf
->o_buf
[6]),
7945 byte_swap_32 (pdf
->o_buf
[7])
7948 else if (hash_mode
== 10420)
7950 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7952 pdf_t
*pdf
= &pdfs
[salt_pos
];
7954 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7956 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",
7964 byte_swap_32 (pdf
->id_buf
[0]),
7965 byte_swap_32 (pdf
->id_buf
[1]),
7966 byte_swap_32 (pdf
->id_buf
[2]),
7967 byte_swap_32 (pdf
->id_buf
[3]),
7969 byte_swap_32 (pdf
->u_buf
[0]),
7970 byte_swap_32 (pdf
->u_buf
[1]),
7971 byte_swap_32 (pdf
->u_buf
[2]),
7972 byte_swap_32 (pdf
->u_buf
[3]),
7973 byte_swap_32 (pdf
->u_buf
[4]),
7974 byte_swap_32 (pdf
->u_buf
[5]),
7975 byte_swap_32 (pdf
->u_buf
[6]),
7976 byte_swap_32 (pdf
->u_buf
[7]),
7978 byte_swap_32 (pdf
->o_buf
[0]),
7979 byte_swap_32 (pdf
->o_buf
[1]),
7980 byte_swap_32 (pdf
->o_buf
[2]),
7981 byte_swap_32 (pdf
->o_buf
[3]),
7982 byte_swap_32 (pdf
->o_buf
[4]),
7983 byte_swap_32 (pdf
->o_buf
[5]),
7984 byte_swap_32 (pdf
->o_buf
[6]),
7985 byte_swap_32 (pdf
->o_buf
[7]),
7993 else if (hash_mode
== 10500)
7995 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7997 pdf_t
*pdf
= &pdfs
[salt_pos
];
7999 if (pdf
->id_len
== 32)
8001 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",
8009 byte_swap_32 (pdf
->id_buf
[0]),
8010 byte_swap_32 (pdf
->id_buf
[1]),
8011 byte_swap_32 (pdf
->id_buf
[2]),
8012 byte_swap_32 (pdf
->id_buf
[3]),
8013 byte_swap_32 (pdf
->id_buf
[4]),
8014 byte_swap_32 (pdf
->id_buf
[5]),
8015 byte_swap_32 (pdf
->id_buf
[6]),
8016 byte_swap_32 (pdf
->id_buf
[7]),
8018 byte_swap_32 (pdf
->u_buf
[0]),
8019 byte_swap_32 (pdf
->u_buf
[1]),
8020 byte_swap_32 (pdf
->u_buf
[2]),
8021 byte_swap_32 (pdf
->u_buf
[3]),
8022 byte_swap_32 (pdf
->u_buf
[4]),
8023 byte_swap_32 (pdf
->u_buf
[5]),
8024 byte_swap_32 (pdf
->u_buf
[6]),
8025 byte_swap_32 (pdf
->u_buf
[7]),
8027 byte_swap_32 (pdf
->o_buf
[0]),
8028 byte_swap_32 (pdf
->o_buf
[1]),
8029 byte_swap_32 (pdf
->o_buf
[2]),
8030 byte_swap_32 (pdf
->o_buf
[3]),
8031 byte_swap_32 (pdf
->o_buf
[4]),
8032 byte_swap_32 (pdf
->o_buf
[5]),
8033 byte_swap_32 (pdf
->o_buf
[6]),
8034 byte_swap_32 (pdf
->o_buf
[7])
8039 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",
8047 byte_swap_32 (pdf
->id_buf
[0]),
8048 byte_swap_32 (pdf
->id_buf
[1]),
8049 byte_swap_32 (pdf
->id_buf
[2]),
8050 byte_swap_32 (pdf
->id_buf
[3]),
8052 byte_swap_32 (pdf
->u_buf
[0]),
8053 byte_swap_32 (pdf
->u_buf
[1]),
8054 byte_swap_32 (pdf
->u_buf
[2]),
8055 byte_swap_32 (pdf
->u_buf
[3]),
8056 byte_swap_32 (pdf
->u_buf
[4]),
8057 byte_swap_32 (pdf
->u_buf
[5]),
8058 byte_swap_32 (pdf
->u_buf
[6]),
8059 byte_swap_32 (pdf
->u_buf
[7]),
8061 byte_swap_32 (pdf
->o_buf
[0]),
8062 byte_swap_32 (pdf
->o_buf
[1]),
8063 byte_swap_32 (pdf
->o_buf
[2]),
8064 byte_swap_32 (pdf
->o_buf
[3]),
8065 byte_swap_32 (pdf
->o_buf
[4]),
8066 byte_swap_32 (pdf
->o_buf
[5]),
8067 byte_swap_32 (pdf
->o_buf
[6]),
8068 byte_swap_32 (pdf
->o_buf
[7])
8072 else if (hash_mode
== 10600)
8074 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8076 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8077 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8079 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8081 else if (hash_mode
== 10700)
8083 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8085 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8086 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8088 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8090 else if (hash_mode
== 10900)
8092 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8094 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8095 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8097 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8099 else if (hash_mode
== 11100)
8101 u32 salt_challenge
= salt
.salt_buf
[0];
8103 salt_challenge
= byte_swap_32 (salt_challenge
);
8105 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
8107 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
8108 SIGNATURE_POSTGRESQL_AUTH
,
8116 else if (hash_mode
== 11200)
8118 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
8119 SIGNATURE_MYSQL_AUTH
,
8120 (unsigned char *) salt
.salt_buf
,
8127 else if (hash_mode
== 11300)
8129 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
8131 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
8133 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
8134 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
8135 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
8137 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
8138 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
8139 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
8141 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
8143 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
8145 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
8148 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
8150 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
8152 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8155 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8157 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8159 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8162 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8163 SIGNATURE_BITCOIN_WALLET
,
8167 (unsigned char *) salt
.salt_buf
,
8175 free (cry_master_buf
);
8177 free (public_key_buf
);
8179 else if (hash_mode
== 11400)
8181 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8183 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8184 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8186 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8188 else if (hash_mode
== 11600)
8190 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8192 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8194 const uint data_len
= seven_zip
->data_len
;
8196 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8198 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8200 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8202 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8205 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8206 SIGNATURE_SEVEN_ZIP
,
8210 (char *) seven_zip
->salt_buf
,
8212 seven_zip
->iv_buf
[0],
8213 seven_zip
->iv_buf
[1],
8214 seven_zip
->iv_buf
[2],
8215 seven_zip
->iv_buf
[3],
8217 seven_zip
->data_len
,
8218 seven_zip
->unpack_size
,
8223 else if (hash_mode
== 11700)
8225 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8235 else if (hash_mode
== 11800)
8237 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8255 else if (hash_mode
== 11900)
8257 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8259 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8260 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8262 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8264 else if (hash_mode
== 12000)
8266 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8268 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8269 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8271 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8273 else if (hash_mode
== 12100)
8275 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8277 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8278 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8280 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8282 else if (hash_mode
== 12200)
8284 uint
*ptr_digest
= digest_buf
;
8285 uint
*ptr_salt
= salt
.salt_buf
;
8287 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8294 else if (hash_mode
== 12300)
8296 uint
*ptr_digest
= digest_buf
;
8297 uint
*ptr_salt
= salt
.salt_buf
;
8299 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",
8300 ptr_digest
[ 0], ptr_digest
[ 1],
8301 ptr_digest
[ 2], ptr_digest
[ 3],
8302 ptr_digest
[ 4], ptr_digest
[ 5],
8303 ptr_digest
[ 6], ptr_digest
[ 7],
8304 ptr_digest
[ 8], ptr_digest
[ 9],
8305 ptr_digest
[10], ptr_digest
[11],
8306 ptr_digest
[12], ptr_digest
[13],
8307 ptr_digest
[14], ptr_digest
[15],
8313 else if (hash_mode
== 12400)
8315 // encode iteration count
8317 char salt_iter
[5] = { 0 };
8319 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8320 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8321 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8322 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8327 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8328 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8329 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8330 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8335 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8337 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8338 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8340 memcpy (tmp_buf
, digest_buf
, 8);
8342 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8346 // fill the resulting buffer
8348 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8350 else if (hash_mode
== 12500)
8352 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8354 byte_swap_32 (salt
.salt_buf
[0]),
8355 byte_swap_32 (salt
.salt_buf
[1]),
8361 else if (hash_mode
== 12600)
8363 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8364 digest_buf
[0] + salt
.salt_buf_pc
[0],
8365 digest_buf
[1] + salt
.salt_buf_pc
[1],
8366 digest_buf
[2] + salt
.salt_buf_pc
[2],
8367 digest_buf
[3] + salt
.salt_buf_pc
[3],
8368 digest_buf
[4] + salt
.salt_buf_pc
[4],
8369 digest_buf
[5] + salt
.salt_buf_pc
[5],
8370 digest_buf
[6] + salt
.salt_buf_pc
[6],
8371 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8373 else if (hash_mode
== 12700)
8375 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8377 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8378 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8380 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8382 else if (hash_mode
== 12800)
8384 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8386 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",
8399 byte_swap_32 (digest_buf
[0]),
8400 byte_swap_32 (digest_buf
[1]),
8401 byte_swap_32 (digest_buf
[2]),
8402 byte_swap_32 (digest_buf
[3]),
8403 byte_swap_32 (digest_buf
[4]),
8404 byte_swap_32 (digest_buf
[5]),
8405 byte_swap_32 (digest_buf
[6]),
8406 byte_swap_32 (digest_buf
[7])
8409 else if (hash_mode
== 12900)
8411 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",
8420 byte_swap_32 (digest_buf
[0]),
8421 byte_swap_32 (digest_buf
[1]),
8422 byte_swap_32 (digest_buf
[2]),
8423 byte_swap_32 (digest_buf
[3]),
8424 byte_swap_32 (digest_buf
[4]),
8425 byte_swap_32 (digest_buf
[5]),
8426 byte_swap_32 (digest_buf
[6]),
8427 byte_swap_32 (digest_buf
[7]),
8434 else if (hash_mode
== 13000)
8436 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8438 rar5_t
*rar5
= &rar5s
[salt_pos
];
8440 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8450 byte_swap_32 (digest_buf
[0]),
8451 byte_swap_32 (digest_buf
[1])
8454 else if (hash_mode
== 13100)
8456 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8458 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8460 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8461 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8463 char data
[2560 * 4 * 2] = { 0 };
8465 char *ptr_data
= data
;
8467 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8468 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8473 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8474 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8476 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8478 (char *) krb5tgs
->account_info
,
8482 else if (hash_mode
== 13200)
8484 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8498 else if (hash_mode
== 13300)
8500 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8501 SIGNATURE_AXCRYPT_SHA1
,
8507 else if (hash_mode
== 13400)
8509 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8511 keepass_t
*keepass
= &keepasss
[salt_pos
];
8513 u32 version
= (u32
) keepass
->version
;
8514 u32 rounds
= salt
.salt_iter
;
8515 u32 algorithm
= (u32
) keepass
->algorithm
;
8516 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8518 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8519 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8520 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8521 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8522 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8524 /* specific to version 1 */
8528 /* specific to version 2 */
8529 u32 expected_bytes_len
;
8530 u32
*ptr_expected_bytes
;
8532 u32 final_random_seed_len
;
8533 u32 transf_random_seed_len
;
8535 u32 contents_hash_len
;
8537 transf_random_seed_len
= 8;
8539 contents_hash_len
= 8;
8540 final_random_seed_len
= 8;
8543 final_random_seed_len
= 4;
8545 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8551 char *ptr_data
= out_buf
;
8553 ptr_data
+= strlen(out_buf
);
8558 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8559 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8564 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8565 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8570 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8571 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8578 contents_len
= (u32
) keepass
->contents_len
;
8579 ptr_contents
= (u32
*) keepass
->contents
;
8581 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8582 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8594 char ptr_contents_len
[10] = { 0 };
8596 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8598 sprintf (ptr_data
, "%d", contents_len
);
8600 ptr_data
+= strlen(ptr_contents_len
);
8605 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8606 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8608 else if (version
== 2)
8610 expected_bytes_len
= 8;
8611 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8613 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8614 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8619 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8620 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8634 sprintf (ptr_data
, "%d", keyfile_len
);
8641 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8642 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8645 else if (hash_mode
== 13500)
8647 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8649 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8651 const u32 salt_len
= (pstoken
->salt_len
> 512) ? 512 : pstoken
->salt_len
;
8653 char pstoken_tmp
[1024 + 1] = { 0 };
8655 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8657 const u8
*ptr
= (const u8
*) pstoken
->salt_buf
;
8659 sprintf (pstoken_tmp
+ j
, "%02x", ptr
[i
]);
8662 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8670 else if (hash_mode
== 13600)
8672 zip2_t
*zip2s
= (zip2_t
*) data
.esalts_buf
;
8674 zip2_t
*zip2
= &zip2s
[salt_pos
];
8676 const u32 salt_len
= zip2
->salt_len
;
8678 char salt_tmp
[32 + 1] = { 0 };
8680 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8682 const u8
*ptr
= (const u8
*) zip2
->salt_buf
;
8684 sprintf (salt_tmp
+ j
, "%02x", ptr
[i
]);
8687 const u32 data_len
= zip2
->data_len
;
8689 char data_tmp
[8192 + 1] = { 0 };
8691 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8693 const u8
*ptr
= (const u8
*) zip2
->data_buf
;
8695 sprintf (data_tmp
+ j
, "%02x", ptr
[i
]);
8698 const u32 auth_len
= zip2
->auth_len
;
8700 char auth_tmp
[20 + 1] = { 0 };
8702 for (uint i
= 0, j
= 0; i
< auth_len
; i
+= 1, j
+= 2)
8704 const u8
*ptr
= (const u8
*) zip2
->auth_buf
;
8706 sprintf (auth_tmp
+ j
, "%02x", ptr
[i
]);
8709 snprintf (out_buf
, 255, "%s*%u*%u*%u*%s*%x*%u*%s*%s*%s",
8710 SIGNATURE_ZIP2_START
,
8716 zip2
->compress_length
,
8719 SIGNATURE_ZIP2_STOP
);
8721 else if ((hash_mode
>= 13700) && (hash_mode
<= 13799))
8723 snprintf (out_buf
, len
-1, "%s", hashfile
);
8727 if (hash_type
== HASH_TYPE_MD4
)
8729 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8735 else if (hash_type
== HASH_TYPE_MD5
)
8737 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8743 else if (hash_type
== HASH_TYPE_SHA1
)
8745 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8752 else if (hash_type
== HASH_TYPE_SHA256
)
8754 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8764 else if (hash_type
== HASH_TYPE_SHA384
)
8766 uint
*ptr
= digest_buf
;
8768 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8776 else if (hash_type
== HASH_TYPE_SHA512
)
8778 uint
*ptr
= digest_buf
;
8780 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8790 else if (hash_type
== HASH_TYPE_LM
)
8792 snprintf (out_buf
, len
-1, "%08x%08x",
8796 else if (hash_type
== HASH_TYPE_ORACLEH
)
8798 snprintf (out_buf
, len
-1, "%08X%08X",
8802 else if (hash_type
== HASH_TYPE_BCRYPT
)
8804 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8805 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8807 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8809 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8811 else if (hash_type
== HASH_TYPE_KECCAK
)
8813 uint
*ptr
= digest_buf
;
8815 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",
8843 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8845 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8847 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8854 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8856 digest_buf
[ 0] = digest_buf
[ 0];
8857 digest_buf
[ 1] = digest_buf
[ 1];
8858 digest_buf
[ 2] = digest_buf
[ 2];
8859 digest_buf
[ 3] = digest_buf
[ 3];
8860 digest_buf
[ 4] = digest_buf
[ 4];
8861 digest_buf
[ 5] = digest_buf
[ 5];
8862 digest_buf
[ 6] = digest_buf
[ 6];
8863 digest_buf
[ 7] = digest_buf
[ 7];
8864 digest_buf
[ 8] = digest_buf
[ 8];
8865 digest_buf
[ 9] = digest_buf
[ 9];
8866 digest_buf
[10] = digest_buf
[10];
8867 digest_buf
[11] = digest_buf
[11];
8868 digest_buf
[12] = digest_buf
[12];
8869 digest_buf
[13] = digest_buf
[13];
8870 digest_buf
[14] = digest_buf
[14];
8871 digest_buf
[15] = digest_buf
[15];
8873 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8891 else if (hash_type
== HASH_TYPE_GOST
)
8893 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8903 else if (hash_type
== HASH_TYPE_MYSQL
)
8905 snprintf (out_buf
, len
-1, "%08x%08x",
8909 else if (hash_type
== HASH_TYPE_LOTUS5
)
8911 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8917 else if (hash_type
== HASH_TYPE_LOTUS6
)
8919 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8920 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8921 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8922 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8924 char buf
[16] = { 0 };
8926 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8927 memcpy (buf
+ 5, digest_buf
, 9);
8931 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8933 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8936 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8938 else if (hash_type
== HASH_TYPE_LOTUS8
)
8940 char buf
[52] = { 0 };
8944 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8950 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8954 buf
[26] = salt
.salt_buf_pc
[0];
8955 buf
[27] = salt
.salt_buf_pc
[1];
8959 memcpy (buf
+ 28, digest_buf
, 8);
8961 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8965 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8967 else if (hash_type
== HASH_TYPE_CRC32
)
8969 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8973 if (salt_type
== SALT_TYPE_INTERN
)
8975 size_t pos
= strlen (out_buf
);
8977 out_buf
[pos
] = data
.separator
;
8979 char *ptr
= (char *) salt
.salt_buf
;
8981 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8983 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8987 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8989 memset (hccap
, 0, sizeof (hccap_t
));
8991 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8993 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8995 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8996 wpa_t
*wpa
= &wpas
[salt_pos
];
8998 hccap
->keyver
= wpa
->keyver
;
9000 hccap
->eapol_size
= wpa
->eapol_size
;
9002 if (wpa
->keyver
!= 1)
9004 uint eapol_tmp
[64] = { 0 };
9006 for (uint i
= 0; i
< 64; i
++)
9008 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9011 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
9015 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
9018 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
9019 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
9020 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
9021 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
9023 char *digests_buf_ptr
= (char *) data
.digests_buf
;
9025 uint dgst_size
= data
.dgst_size
;
9027 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
9029 if (wpa
->keyver
!= 1)
9031 uint digest_tmp
[4] = { 0 };
9033 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
9034 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
9035 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
9036 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
9038 memcpy (hccap
->keymic
, digest_tmp
, 16);
9042 memcpy (hccap
->keymic
, digest_ptr
, 16);
9046 void SuspendThreads ()
9048 if (data
.devices_status
== STATUS_RUNNING
)
9050 hc_timer_set (&data
.timer_paused
);
9052 data
.devices_status
= STATUS_PAUSED
;
9054 log_info ("Paused");
9058 void ResumeThreads ()
9060 if (data
.devices_status
== STATUS_PAUSED
)
9064 hc_timer_get (data
.timer_paused
, ms_paused
);
9066 data
.ms_paused
+= ms_paused
;
9068 data
.devices_status
= STATUS_RUNNING
;
9070 log_info ("Resumed");
9076 if (data
.devices_status
!= STATUS_RUNNING
) return;
9078 data
.devices_status
= STATUS_BYPASS
;
9080 log_info ("Next dictionary / mask in queue selected, bypassing current one");
9083 void stop_at_checkpoint ()
9085 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9087 if (data
.devices_status
!= STATUS_RUNNING
) return;
9090 // this feature only makes sense if --restore-disable was not specified
9092 if (data
.restore_disable
== 1)
9094 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
9099 // check if monitoring of Restore Point updates should be enabled or disabled
9101 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9103 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
9105 // save the current restore point value
9107 data
.checkpoint_cur_words
= get_lowest_words_done ();
9109 log_info ("Checkpoint enabled: will quit at next Restore Point update");
9113 data
.devices_status
= STATUS_RUNNING
;
9115 // reset the global value for checkpoint checks
9117 data
.checkpoint_cur_words
= 0;
9119 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
9125 if (data
.devices_status
== STATUS_INIT
) return;
9126 if (data
.devices_status
== STATUS_STARTING
) return;
9128 data
.devices_status
= STATUS_ABORTED
;
9133 if (data
.devices_status
== STATUS_INIT
) return;
9134 if (data
.devices_status
== STATUS_STARTING
) return;
9136 data
.devices_status
= STATUS_QUIT
;
9139 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
9141 FILE *fp
= fopen (kernel_file
, "rb");
9147 memset (&st
, 0, sizeof (st
));
9149 stat (kernel_file
, &st
);
9151 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
9153 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
9155 if (num_read
!= (size_t) st
.st_size
)
9157 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9164 buf
[st
.st_size
] = 0;
9166 for (int i
= 0; i
< num_devices
; i
++)
9168 kernel_lengths
[i
] = (size_t) st
.st_size
;
9170 kernel_sources
[i
] = buf
;
9175 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9183 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
9185 if (binary_size
> 0)
9187 FILE *fp
= fopen (dst
, "wb");
9190 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
9201 restore_data_t
*init_restore (int argc
, char **argv
)
9203 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
9205 if (data
.restore_disable
== 0)
9207 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
9211 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
9215 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
9224 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9226 int pidbin_len
= -1;
9229 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9231 FILE *fd
= fopen (pidbin
, "rb");
9235 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9237 pidbin
[pidbin_len
] = 0;
9241 char *argv0_r
= strrchr (argv
[0], '/');
9243 char *pidbin_r
= strrchr (pidbin
, '/');
9245 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9247 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9249 if (strcmp (argv0_r
, pidbin_r
) == 0)
9251 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
9258 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9260 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9262 int pidbin2_len
= -1;
9264 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9265 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9267 pidbin
[pidbin_len
] = 0;
9268 pidbin2
[pidbin2_len
] = 0;
9272 if (strcmp (pidbin
, pidbin2
) == 0)
9274 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9287 if (rd
->version_bin
< RESTORE_MIN
)
9289 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9296 memset (rd
, 0, sizeof (restore_data_t
));
9298 rd
->version_bin
= VERSION_BIN
;
9301 rd
->pid
= getpid ();
9303 rd
->pid
= GetCurrentProcessId ();
9306 if (getcwd (rd
->cwd
, 255) == NULL
)
9319 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9321 FILE *fp
= fopen (eff_restore_file
, "rb");
9325 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
9330 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9332 log_error ("ERROR: cannot read %s", eff_restore_file
);
9337 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9339 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9341 for (uint i
= 0; i
< rd
->argc
; i
++)
9343 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9345 log_error ("ERROR: cannot read %s", eff_restore_file
);
9350 size_t len
= strlen (buf
);
9352 if (len
) buf
[len
- 1] = 0;
9354 rd
->argv
[i
] = mystrdup (buf
);
9361 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9363 if (chdir (rd
->cwd
))
9365 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9366 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9367 " https://github.com/philsmd/analyze_hc_restore\n"
9368 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9374 u64
get_lowest_words_done ()
9378 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9380 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9382 if (device_param
->skipped
) continue;
9384 const u64 words_done
= device_param
->words_done
;
9386 if (words_done
< words_cur
) words_cur
= words_done
;
9389 // It's possible that a device's workload isn't finished right after a restore-case.
9390 // In that case, this function would return 0 and overwrite the real restore point
9391 // There's also data.words_cur which is set to rd->words_cur but it changes while
9392 // the attack is running therefore we should stick to rd->words_cur.
9393 // Note that -s influences rd->words_cur we should keep a close look on that.
9395 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9400 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9402 u64 words_cur
= get_lowest_words_done ();
9404 rd
->words_cur
= words_cur
;
9406 FILE *fp
= fopen (new_restore_file
, "wb");
9410 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9415 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9417 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9422 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9424 for (uint i
= 0; i
< rd
->argc
; i
++)
9426 fprintf (fp
, "%s", rd
->argv
[i
]);
9432 fsync (fileno (fp
));
9437 void cycle_restore ()
9439 const char *eff_restore_file
= data
.eff_restore_file
;
9440 const char *new_restore_file
= data
.new_restore_file
;
9442 restore_data_t
*rd
= data
.rd
;
9444 write_restore (new_restore_file
, rd
);
9448 memset (&st
, 0, sizeof(st
));
9450 if (stat (eff_restore_file
, &st
) == 0)
9452 if (unlink (eff_restore_file
))
9454 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9458 if (rename (new_restore_file
, eff_restore_file
))
9460 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9464 void check_checkpoint ()
9466 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9468 u64 words_cur
= get_lowest_words_done ();
9470 if (words_cur
!= data
.checkpoint_cur_words
)
9480 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9484 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9486 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9488 myfree (alias
->device_name
);
9489 myfree (alias
->alias_name
);
9492 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9494 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9496 myfree (entry
->device_name
);
9499 myfree (tuning_db
->alias_buf
);
9500 myfree (tuning_db
->entry_buf
);
9505 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9507 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9509 int num_lines
= count_lines (fp
);
9511 // a bit over-allocated
9513 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9514 tuning_db
->alias_cnt
= 0;
9516 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9517 tuning_db
->entry_cnt
= 0;
9522 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9524 FILE *fp
= fopen (tuning_db_file
, "rb");
9528 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9533 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9539 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9543 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9545 if (line_buf
== NULL
) break;
9549 const int line_len
= in_superchop (line_buf
);
9551 if (line_len
== 0) continue;
9553 if (line_buf
[0] == '#') continue;
9557 char *token_ptr
[7] = { NULL
};
9561 char *next
= strtok (line_buf
, "\t ");
9563 token_ptr
[token_cnt
] = next
;
9567 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9569 token_ptr
[token_cnt
] = next
;
9576 char *device_name
= token_ptr
[0];
9577 char *alias_name
= token_ptr
[1];
9579 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9581 alias
->device_name
= mystrdup (device_name
);
9582 alias
->alias_name
= mystrdup (alias_name
);
9584 tuning_db
->alias_cnt
++;
9586 else if (token_cnt
== 6)
9588 if ((token_ptr
[1][0] != '0') &&
9589 (token_ptr
[1][0] != '1') &&
9590 (token_ptr
[1][0] != '3') &&
9591 (token_ptr
[1][0] != '*'))
9593 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9598 if ((token_ptr
[3][0] != '1') &&
9599 (token_ptr
[3][0] != '2') &&
9600 (token_ptr
[3][0] != '4') &&
9601 (token_ptr
[3][0] != '8') &&
9602 (token_ptr
[3][0] != 'N'))
9604 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9609 char *device_name
= token_ptr
[0];
9611 int attack_mode
= -1;
9613 int vector_width
= -1;
9614 int kernel_accel
= -1;
9615 int kernel_loops
= -1;
9617 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9618 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9619 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9621 if (token_ptr
[4][0] != 'A')
9623 kernel_accel
= atoi (token_ptr
[4]);
9625 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9627 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9637 if (token_ptr
[5][0] != 'A')
9639 kernel_loops
= atoi (token_ptr
[5]);
9641 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9643 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9653 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9655 entry
->device_name
= mystrdup (device_name
);
9656 entry
->attack_mode
= attack_mode
;
9657 entry
->hash_type
= hash_type
;
9658 entry
->vector_width
= vector_width
;
9659 entry
->kernel_accel
= kernel_accel
;
9660 entry
->kernel_loops
= kernel_loops
;
9662 tuning_db
->entry_cnt
++;
9666 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9676 // todo: print loaded 'cnt' message
9678 // sort the database
9680 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9681 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9686 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9688 static tuning_db_entry_t s
;
9690 // first we need to convert all spaces in the device_name to underscore
9692 char *device_name_nospace
= strdup (device_param
->device_name
);
9694 int device_name_length
= strlen (device_name_nospace
);
9698 for (i
= 0; i
< device_name_length
; i
++)
9700 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9703 // find out if there's an alias configured
9705 tuning_db_alias_t a
;
9707 a
.device_name
= device_name_nospace
;
9709 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
);
9711 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9713 // attack-mode 6 and 7 are attack-mode 1 basically
9715 if (attack_mode
== 6) attack_mode
= 1;
9716 if (attack_mode
== 7) attack_mode
= 1;
9718 // bsearch is not ideal but fast enough
9720 s
.device_name
= device_name_nospace
;
9721 s
.attack_mode
= attack_mode
;
9722 s
.hash_type
= hash_type
;
9724 tuning_db_entry_t
*entry
= NULL
;
9726 // this will produce all 2^3 combinations required
9728 for (i
= 0; i
< 8; i
++)
9730 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9731 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9732 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9734 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9736 if (entry
!= NULL
) break;
9738 // in non-wildcard mode do some additional checks:
9742 // in case we have an alias-name
9744 if (alias_name
!= NULL
)
9746 s
.device_name
= alias_name
;
9748 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9750 if (entry
!= NULL
) break;
9753 // or by device type
9755 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9757 s
.device_name
= "DEVICE_TYPE_CPU";
9759 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9761 s
.device_name
= "DEVICE_TYPE_GPU";
9763 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9765 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9768 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9770 if (entry
!= NULL
) break;
9774 // free converted device_name
9776 myfree (device_name_nospace
);
9785 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9787 u8 tmp
[256] = { 0 };
9789 if (salt_len
> sizeof (tmp
))
9794 memcpy (tmp
, in
, salt_len
);
9796 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9798 if ((salt_len
% 2) == 0)
9800 u32 new_salt_len
= salt_len
/ 2;
9802 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9807 tmp
[i
] = hex_convert (p1
) << 0;
9808 tmp
[i
] |= hex_convert (p0
) << 4;
9811 salt_len
= new_salt_len
;
9818 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9820 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9823 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9825 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9829 u32
*tmp_uint
= (u32
*) tmp
;
9831 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9832 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9833 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9834 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9835 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9836 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9837 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9838 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9839 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9840 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9842 salt_len
= salt_len
* 2;
9850 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9852 lowercase (tmp
, salt_len
);
9855 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9857 uppercase (tmp
, salt_len
);
9862 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9867 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9872 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9874 u32
*tmp_uint
= (uint
*) tmp
;
9880 for (u32 i
= 0; i
< max
; i
++)
9882 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9885 // Important: we may need to increase the length of memcpy since
9886 // we don't want to "loose" some swapped bytes (could happen if
9887 // they do not perfectly fit in the 4-byte blocks)
9888 // Memcpy does always copy the bytes in the BE order, but since
9889 // we swapped them, some important bytes could be in positions
9890 // we normally skip with the original len
9892 if (len
% 4) len
+= 4 - (len
% 4);
9895 memcpy (out
, tmp
, len
);
9900 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9902 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9904 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9906 u32
*digest
= (u32
*) hash_buf
->digest
;
9908 salt_t
*salt
= hash_buf
->salt
;
9910 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9912 char *iter_pos
= input_buf
+ 4;
9914 salt
->salt_iter
= 1 << atoi (iter_pos
);
9916 char *salt_pos
= strchr (iter_pos
, '$');
9918 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9924 salt
->salt_len
= salt_len
;
9926 u8 tmp_buf
[100] = { 0 };
9928 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9930 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9932 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9934 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9935 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9936 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9937 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9939 char *hash_pos
= salt_pos
+ 22;
9941 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9943 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9945 memcpy (digest
, tmp_buf
, 24);
9947 digest
[0] = byte_swap_32 (digest
[0]);
9948 digest
[1] = byte_swap_32 (digest
[1]);
9949 digest
[2] = byte_swap_32 (digest
[2]);
9950 digest
[3] = byte_swap_32 (digest
[3]);
9951 digest
[4] = byte_swap_32 (digest
[4]);
9952 digest
[5] = byte_swap_32 (digest
[5]);
9954 digest
[5] &= ~0xff; // its just 23 not 24 !
9959 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9961 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9963 u32
*digest
= (u32
*) hash_buf
->digest
;
9965 u8 tmp_buf
[100] = { 0 };
9967 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9969 memcpy (digest
, tmp_buf
, 32);
9971 digest
[0] = byte_swap_32 (digest
[0]);
9972 digest
[1] = byte_swap_32 (digest
[1]);
9973 digest
[2] = byte_swap_32 (digest
[2]);
9974 digest
[3] = byte_swap_32 (digest
[3]);
9975 digest
[4] = byte_swap_32 (digest
[4]);
9976 digest
[5] = byte_swap_32 (digest
[5]);
9977 digest
[6] = byte_swap_32 (digest
[6]);
9978 digest
[7] = byte_swap_32 (digest
[7]);
9980 digest
[0] -= SHA256M_A
;
9981 digest
[1] -= SHA256M_B
;
9982 digest
[2] -= SHA256M_C
;
9983 digest
[3] -= SHA256M_D
;
9984 digest
[4] -= SHA256M_E
;
9985 digest
[5] -= SHA256M_F
;
9986 digest
[6] -= SHA256M_G
;
9987 digest
[7] -= SHA256M_H
;
9992 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9994 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9996 u32
*digest
= (u32
*) hash_buf
->digest
;
9998 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9999 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10001 digest
[0] = byte_swap_32 (digest
[0]);
10002 digest
[1] = byte_swap_32 (digest
[1]);
10006 IP (digest
[0], digest
[1], tt
);
10008 digest
[0] = digest
[0];
10009 digest
[1] = digest
[1];
10013 return (PARSER_OK
);
10016 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10018 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
10020 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
10022 u32
*digest
= (u32
*) hash_buf
->digest
;
10024 salt_t
*salt
= hash_buf
->salt
;
10026 char *hash_pos
= input_buf
+ 10;
10028 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10029 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10030 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10031 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10032 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10034 digest
[0] -= SHA1M_A
;
10035 digest
[1] -= SHA1M_B
;
10036 digest
[2] -= SHA1M_C
;
10037 digest
[3] -= SHA1M_D
;
10038 digest
[4] -= SHA1M_E
;
10040 uint salt_len
= 10;
10042 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10044 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10046 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10048 salt
->salt_len
= salt_len
;
10050 return (PARSER_OK
);
10053 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10055 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
10057 u32
*digest
= (u32
*) hash_buf
->digest
;
10059 salt_t
*salt
= hash_buf
->salt
;
10061 char *hash_pos
= input_buf
+ 8;
10063 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10064 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10065 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10066 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10067 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10069 digest
[0] -= SHA1M_A
;
10070 digest
[1] -= SHA1M_B
;
10071 digest
[2] -= SHA1M_C
;
10072 digest
[3] -= SHA1M_D
;
10073 digest
[4] -= SHA1M_E
;
10077 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10079 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10081 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10083 salt
->salt_len
= salt_len
;
10085 return (PARSER_OK
);
10088 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10090 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
10092 u64
*digest
= (u64
*) hash_buf
->digest
;
10094 salt_t
*salt
= hash_buf
->salt
;
10096 char *hash_pos
= input_buf
+ 8;
10098 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
10099 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
10100 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
10101 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
10102 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
10103 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
10104 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
10105 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
10107 digest
[0] -= SHA512M_A
;
10108 digest
[1] -= SHA512M_B
;
10109 digest
[2] -= SHA512M_C
;
10110 digest
[3] -= SHA512M_D
;
10111 digest
[4] -= SHA512M_E
;
10112 digest
[5] -= SHA512M_F
;
10113 digest
[6] -= SHA512M_G
;
10114 digest
[7] -= SHA512M_H
;
10118 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10120 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10122 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10124 salt
->salt_len
= salt_len
;
10126 return (PARSER_OK
);
10129 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10131 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10133 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
10137 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
10140 u32
*digest
= (u32
*) hash_buf
->digest
;
10142 salt_t
*salt
= hash_buf
->salt
;
10144 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10145 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10146 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10147 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10149 digest
[0] = byte_swap_32 (digest
[0]);
10150 digest
[1] = byte_swap_32 (digest
[1]);
10151 digest
[2] = byte_swap_32 (digest
[2]);
10152 digest
[3] = byte_swap_32 (digest
[3]);
10154 digest
[0] -= MD5M_A
;
10155 digest
[1] -= MD5M_B
;
10156 digest
[2] -= MD5M_C
;
10157 digest
[3] -= MD5M_D
;
10159 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10161 uint salt_len
= input_len
- 32 - 1;
10163 char *salt_buf
= input_buf
+ 32 + 1;
10165 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10167 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10169 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10171 salt
->salt_len
= salt_len
;
10173 return (PARSER_OK
);
10176 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10178 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10180 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
10184 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
10189 char clean_input_buf
[32] = { 0 };
10191 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
10192 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
10194 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
10198 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
10204 clean_input_buf
[k
] = input_buf
[i
];
10212 u32
*digest
= (u32
*) hash_buf
->digest
;
10214 salt_t
*salt
= hash_buf
->salt
;
10216 u32 a
, b
, c
, d
, e
, f
;
10218 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10219 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10220 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10221 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10222 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10223 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10225 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10226 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10228 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10229 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10230 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10231 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10232 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10233 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10235 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10236 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10238 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10239 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10240 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10241 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10242 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10243 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10245 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10246 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10248 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10249 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10250 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10251 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10252 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10253 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10255 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10256 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10258 digest
[0] = byte_swap_32 (digest
[0]);
10259 digest
[1] = byte_swap_32 (digest
[1]);
10260 digest
[2] = byte_swap_32 (digest
[2]);
10261 digest
[3] = byte_swap_32 (digest
[3]);
10263 digest
[0] -= MD5M_A
;
10264 digest
[1] -= MD5M_B
;
10265 digest
[2] -= MD5M_C
;
10266 digest
[3] -= MD5M_D
;
10268 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10270 uint salt_len
= input_len
- 30 - 1;
10272 char *salt_buf
= input_buf
+ 30 + 1;
10274 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10276 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10278 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10279 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10281 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10283 salt
->salt_len
= salt_len
;
10285 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10287 salt
->salt_len
+= 22;
10289 return (PARSER_OK
);
10292 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10294 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10296 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10300 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10303 u32
*digest
= (u32
*) hash_buf
->digest
;
10305 salt_t
*salt
= hash_buf
->salt
;
10307 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10308 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10309 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10310 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10311 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10313 digest
[0] -= SHA1M_A
;
10314 digest
[1] -= SHA1M_B
;
10315 digest
[2] -= SHA1M_C
;
10316 digest
[3] -= SHA1M_D
;
10317 digest
[4] -= SHA1M_E
;
10319 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10321 uint salt_len
= input_len
- 40 - 1;
10323 char *salt_buf
= input_buf
+ 40 + 1;
10325 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10327 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10329 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10331 salt
->salt_len
= salt_len
;
10333 return (PARSER_OK
);
10336 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10338 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10340 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10344 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10347 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10349 char *iter_pos
= input_buf
+ 6;
10351 salt_t
*salt
= hash_buf
->salt
;
10353 uint iter
= atoi (iter_pos
);
10357 iter
= ROUNDS_DCC2
;
10360 salt
->salt_iter
= iter
- 1;
10362 char *salt_pos
= strchr (iter_pos
, '#');
10364 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10368 char *digest_pos
= strchr (salt_pos
, '#');
10370 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10374 uint salt_len
= digest_pos
- salt_pos
- 1;
10376 u32
*digest
= (u32
*) hash_buf
->digest
;
10378 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10379 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10380 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10381 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10383 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10385 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10387 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10389 salt
->salt_len
= salt_len
;
10391 return (PARSER_OK
);
10394 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10396 u32
*digest
= (u32
*) hash_buf
->digest
;
10398 salt_t
*salt
= hash_buf
->salt
;
10400 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10404 memcpy (&in
, input_buf
, input_len
);
10406 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10408 memcpy (digest
, in
.keymic
, 16);
10411 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10412 The phrase "Pairwise key expansion"
10413 Access Point Address (referred to as Authenticator Address AA)
10414 Supplicant Address (referred to as Supplicant Address SA)
10415 Access Point Nonce (referred to as Authenticator Anonce)
10416 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10419 uint salt_len
= strlen (in
.essid
);
10423 log_info ("WARNING: the length of the ESSID is too long. The hccap file may be invalid or corrupted");
10425 return (PARSER_SALT_LENGTH
);
10428 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10430 salt
->salt_len
= salt_len
;
10432 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10434 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10436 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10438 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10440 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10441 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10445 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10446 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10449 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10451 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10452 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10456 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10457 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10460 for (int i
= 0; i
< 25; i
++)
10462 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10465 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10466 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10467 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10468 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10470 wpa
->keyver
= in
.keyver
;
10472 if (wpa
->keyver
> 255)
10474 log_info ("ATTENTION!");
10475 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10476 log_info (" This could be due to a recent aircrack-ng bug.");
10477 log_info (" The key version was automatically reset to a reasonable value.");
10480 wpa
->keyver
&= 0xff;
10483 wpa
->eapol_size
= in
.eapol_size
;
10485 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10487 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10489 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10491 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10493 if (wpa
->keyver
== 1)
10499 digest
[0] = byte_swap_32 (digest
[0]);
10500 digest
[1] = byte_swap_32 (digest
[1]);
10501 digest
[2] = byte_swap_32 (digest
[2]);
10502 digest
[3] = byte_swap_32 (digest
[3]);
10504 for (int i
= 0; i
< 64; i
++)
10506 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10510 uint32_t *p0
= (uint32_t *) in
.essid
;
10514 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10515 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10517 salt
->salt_buf
[10] = c0
;
10518 salt
->salt_buf
[11] = c1
;
10520 return (PARSER_OK
);
10523 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10525 u32
*digest
= (u32
*) hash_buf
->digest
;
10527 salt_t
*salt
= hash_buf
->salt
;
10529 if (input_len
== 0)
10531 log_error ("Password Safe v2 container not specified");
10536 FILE *fp
= fopen (input_buf
, "rb");
10540 log_error ("%s: %s", input_buf
, strerror (errno
));
10547 memset (&buf
, 0, sizeof (psafe2_hdr
));
10549 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10553 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10555 salt
->salt_buf
[0] = buf
.random
[0];
10556 salt
->salt_buf
[1] = buf
.random
[1];
10558 salt
->salt_len
= 8;
10559 salt
->salt_iter
= 1000;
10561 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10562 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10563 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10564 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10565 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10567 return (PARSER_OK
);
10570 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10572 u32
*digest
= (u32
*) hash_buf
->digest
;
10574 salt_t
*salt
= hash_buf
->salt
;
10576 if (input_len
== 0)
10578 log_error (".psafe3 not specified");
10583 FILE *fp
= fopen (input_buf
, "rb");
10587 log_error ("%s: %s", input_buf
, strerror (errno
));
10594 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10598 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10600 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10602 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10604 salt
->salt_iter
= in
.iterations
+ 1;
10606 salt
->salt_buf
[0] = in
.salt_buf
[0];
10607 salt
->salt_buf
[1] = in
.salt_buf
[1];
10608 salt
->salt_buf
[2] = in
.salt_buf
[2];
10609 salt
->salt_buf
[3] = in
.salt_buf
[3];
10610 salt
->salt_buf
[4] = in
.salt_buf
[4];
10611 salt
->salt_buf
[5] = in
.salt_buf
[5];
10612 salt
->salt_buf
[6] = in
.salt_buf
[6];
10613 salt
->salt_buf
[7] = in
.salt_buf
[7];
10615 salt
->salt_len
= 32;
10617 digest
[0] = in
.hash_buf
[0];
10618 digest
[1] = in
.hash_buf
[1];
10619 digest
[2] = in
.hash_buf
[2];
10620 digest
[3] = in
.hash_buf
[3];
10621 digest
[4] = in
.hash_buf
[4];
10622 digest
[5] = in
.hash_buf
[5];
10623 digest
[6] = in
.hash_buf
[6];
10624 digest
[7] = in
.hash_buf
[7];
10626 digest
[0] = byte_swap_32 (digest
[0]);
10627 digest
[1] = byte_swap_32 (digest
[1]);
10628 digest
[2] = byte_swap_32 (digest
[2]);
10629 digest
[3] = byte_swap_32 (digest
[3]);
10630 digest
[4] = byte_swap_32 (digest
[4]);
10631 digest
[5] = byte_swap_32 (digest
[5]);
10632 digest
[6] = byte_swap_32 (digest
[6]);
10633 digest
[7] = byte_swap_32 (digest
[7]);
10635 return (PARSER_OK
);
10638 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10640 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10642 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10644 u32
*digest
= (u32
*) hash_buf
->digest
;
10646 salt_t
*salt
= hash_buf
->salt
;
10648 char *iter_pos
= input_buf
+ 3;
10650 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10652 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10654 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10656 salt
->salt_iter
= salt_iter
;
10658 char *salt_pos
= iter_pos
+ 1;
10662 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10664 salt
->salt_len
= salt_len
;
10666 char *hash_pos
= salt_pos
+ salt_len
;
10668 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10670 return (PARSER_OK
);
10673 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10675 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10677 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10679 u32
*digest
= (u32
*) hash_buf
->digest
;
10681 salt_t
*salt
= hash_buf
->salt
;
10683 char *salt_pos
= input_buf
+ 3;
10685 uint iterations_len
= 0;
10687 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10691 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10693 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10694 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10698 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10702 iterations_len
+= 8;
10706 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10709 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10711 char *hash_pos
= strchr (salt_pos
, '$');
10713 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10715 uint salt_len
= hash_pos
- salt_pos
;
10717 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10719 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10721 salt
->salt_len
= salt_len
;
10725 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10727 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10729 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10731 return (PARSER_OK
);
10734 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10736 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10738 u32
*digest
= (u32
*) hash_buf
->digest
;
10740 salt_t
*salt
= hash_buf
->salt
;
10742 char *salt_pos
= input_buf
+ 6;
10744 uint iterations_len
= 0;
10746 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10750 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10752 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10753 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10757 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10761 iterations_len
+= 8;
10765 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10768 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10770 char *hash_pos
= strchr (salt_pos
, '$');
10772 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10774 uint salt_len
= hash_pos
- salt_pos
;
10776 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10778 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10780 salt
->salt_len
= salt_len
;
10784 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10786 return (PARSER_OK
);
10789 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10791 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10793 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10795 u32
*digest
= (u32
*) hash_buf
->digest
;
10797 salt_t
*salt
= hash_buf
->salt
;
10799 char *salt_pos
= input_buf
+ 14;
10801 char *hash_pos
= strchr (salt_pos
, '*');
10803 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10807 uint salt_len
= hash_pos
- salt_pos
- 1;
10809 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10811 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10813 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10815 salt
->salt_len
= salt_len
;
10817 u8 tmp_buf
[100] = { 0 };
10819 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10821 memcpy (digest
, tmp_buf
, 20);
10823 digest
[0] = byte_swap_32 (digest
[0]);
10824 digest
[1] = byte_swap_32 (digest
[1]);
10825 digest
[2] = byte_swap_32 (digest
[2]);
10826 digest
[3] = byte_swap_32 (digest
[3]);
10827 digest
[4] = byte_swap_32 (digest
[4]);
10829 digest
[0] -= SHA1M_A
;
10830 digest
[1] -= SHA1M_B
;
10831 digest
[2] -= SHA1M_C
;
10832 digest
[3] -= SHA1M_D
;
10833 digest
[4] -= SHA1M_E
;
10835 return (PARSER_OK
);
10838 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10840 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10842 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10844 if (c12
& 3) return (PARSER_HASH_VALUE
);
10846 u32
*digest
= (u32
*) hash_buf
->digest
;
10848 salt_t
*salt
= hash_buf
->salt
;
10850 // for ascii_digest
10851 salt
->salt_sign
[0] = input_buf
[0];
10852 salt
->salt_sign
[1] = input_buf
[1];
10854 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10855 | itoa64_to_int (input_buf
[1]) << 6;
10857 salt
->salt_len
= 2;
10859 u8 tmp_buf
[100] = { 0 };
10861 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10863 memcpy (digest
, tmp_buf
, 8);
10867 IP (digest
[0], digest
[1], tt
);
10872 return (PARSER_OK
);
10875 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10877 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10879 u32
*digest
= (u32
*) hash_buf
->digest
;
10881 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10882 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10883 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10884 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10886 digest
[0] = byte_swap_32 (digest
[0]);
10887 digest
[1] = byte_swap_32 (digest
[1]);
10888 digest
[2] = byte_swap_32 (digest
[2]);
10889 digest
[3] = byte_swap_32 (digest
[3]);
10891 digest
[0] -= MD4M_A
;
10892 digest
[1] -= MD4M_B
;
10893 digest
[2] -= MD4M_C
;
10894 digest
[3] -= MD4M_D
;
10896 return (PARSER_OK
);
10899 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10901 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10903 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10907 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10910 u32
*digest
= (u32
*) hash_buf
->digest
;
10912 salt_t
*salt
= hash_buf
->salt
;
10914 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10915 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10916 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10917 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10919 digest
[0] = byte_swap_32 (digest
[0]);
10920 digest
[1] = byte_swap_32 (digest
[1]);
10921 digest
[2] = byte_swap_32 (digest
[2]);
10922 digest
[3] = byte_swap_32 (digest
[3]);
10924 digest
[0] -= MD4M_A
;
10925 digest
[1] -= MD4M_B
;
10926 digest
[2] -= MD4M_C
;
10927 digest
[3] -= MD4M_D
;
10929 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10931 uint salt_len
= input_len
- 32 - 1;
10933 char *salt_buf
= input_buf
+ 32 + 1;
10935 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10937 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10939 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10941 salt
->salt_len
= salt_len
;
10943 return (PARSER_OK
);
10946 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10948 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) 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] -= MD5M_A
;
10963 digest
[1] -= MD5M_B
;
10964 digest
[2] -= MD5M_C
;
10965 digest
[3] -= MD5M_D
;
10967 return (PARSER_OK
);
10970 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10972 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10974 u32
*digest
= (u32
*) hash_buf
->digest
;
10976 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10977 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10981 digest
[0] = byte_swap_32 (digest
[0]);
10982 digest
[1] = byte_swap_32 (digest
[1]);
10984 return (PARSER_OK
);
10987 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10989 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10991 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10995 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10998 u32
*digest
= (u32
*) hash_buf
->digest
;
11000 salt_t
*salt
= hash_buf
->salt
;
11002 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11003 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11004 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11005 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11007 digest
[0] = byte_swap_32 (digest
[0]);
11008 digest
[1] = byte_swap_32 (digest
[1]);
11009 digest
[2] = byte_swap_32 (digest
[2]);
11010 digest
[3] = byte_swap_32 (digest
[3]);
11012 digest
[0] -= MD5M_A
;
11013 digest
[1] -= MD5M_B
;
11014 digest
[2] -= MD5M_C
;
11015 digest
[3] -= MD5M_D
;
11017 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11019 uint salt_len
= input_len
- 32 - 1;
11021 char *salt_buf
= input_buf
+ 32 + 1;
11023 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11025 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11027 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11029 salt
->salt_len
= salt_len
;
11031 return (PARSER_OK
);
11034 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11036 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
11038 u32
*digest
= (u32
*) hash_buf
->digest
;
11040 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11041 | itoa64_to_int (input_buf
[ 1]) << 6
11042 | itoa64_to_int (input_buf
[ 2]) << 12
11043 | itoa64_to_int (input_buf
[ 3]) << 18;
11044 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11045 | itoa64_to_int (input_buf
[ 5]) << 6
11046 | itoa64_to_int (input_buf
[ 6]) << 12
11047 | itoa64_to_int (input_buf
[ 7]) << 18;
11048 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11049 | itoa64_to_int (input_buf
[ 9]) << 6
11050 | itoa64_to_int (input_buf
[10]) << 12
11051 | itoa64_to_int (input_buf
[11]) << 18;
11052 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11053 | itoa64_to_int (input_buf
[13]) << 6
11054 | itoa64_to_int (input_buf
[14]) << 12
11055 | itoa64_to_int (input_buf
[15]) << 18;
11057 digest
[0] -= MD5M_A
;
11058 digest
[1] -= MD5M_B
;
11059 digest
[2] -= MD5M_C
;
11060 digest
[3] -= MD5M_D
;
11062 digest
[0] &= 0x00ffffff;
11063 digest
[1] &= 0x00ffffff;
11064 digest
[2] &= 0x00ffffff;
11065 digest
[3] &= 0x00ffffff;
11067 return (PARSER_OK
);
11070 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11072 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11074 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
11078 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
11081 u32
*digest
= (u32
*) hash_buf
->digest
;
11083 salt_t
*salt
= hash_buf
->salt
;
11085 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11086 | itoa64_to_int (input_buf
[ 1]) << 6
11087 | itoa64_to_int (input_buf
[ 2]) << 12
11088 | itoa64_to_int (input_buf
[ 3]) << 18;
11089 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11090 | itoa64_to_int (input_buf
[ 5]) << 6
11091 | itoa64_to_int (input_buf
[ 6]) << 12
11092 | itoa64_to_int (input_buf
[ 7]) << 18;
11093 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11094 | itoa64_to_int (input_buf
[ 9]) << 6
11095 | itoa64_to_int (input_buf
[10]) << 12
11096 | itoa64_to_int (input_buf
[11]) << 18;
11097 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11098 | itoa64_to_int (input_buf
[13]) << 6
11099 | itoa64_to_int (input_buf
[14]) << 12
11100 | itoa64_to_int (input_buf
[15]) << 18;
11102 digest
[0] -= MD5M_A
;
11103 digest
[1] -= MD5M_B
;
11104 digest
[2] -= MD5M_C
;
11105 digest
[3] -= MD5M_D
;
11107 digest
[0] &= 0x00ffffff;
11108 digest
[1] &= 0x00ffffff;
11109 digest
[2] &= 0x00ffffff;
11110 digest
[3] &= 0x00ffffff;
11112 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11114 uint salt_len
= input_len
- 16 - 1;
11116 char *salt_buf
= input_buf
+ 16 + 1;
11118 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11120 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11122 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11124 salt
->salt_len
= salt_len
;
11126 return (PARSER_OK
);
11129 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
11131 key
[0] = (nthash
[0] >> 0);
11132 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
11133 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
11134 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
11135 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
11136 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
11137 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
11138 key
[7] = (nthash
[6] << 1);
11150 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11152 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
11154 u32
*digest
= (u32
*) hash_buf
->digest
;
11156 salt_t
*salt
= hash_buf
->salt
;
11158 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11164 char *user_pos
= input_buf
;
11166 char *unused_pos
= strchr (user_pos
, ':');
11168 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11170 uint user_len
= unused_pos
- user_pos
;
11172 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11176 char *domain_pos
= strchr (unused_pos
, ':');
11178 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11180 uint unused_len
= domain_pos
- unused_pos
;
11182 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11186 char *srvchall_pos
= strchr (domain_pos
, ':');
11188 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11190 uint domain_len
= srvchall_pos
- domain_pos
;
11192 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11196 char *hash_pos
= strchr (srvchall_pos
, ':');
11198 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11200 uint srvchall_len
= hash_pos
- srvchall_pos
;
11202 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
11206 char *clichall_pos
= strchr (hash_pos
, ':');
11208 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11210 uint hash_len
= clichall_pos
- hash_pos
;
11212 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11216 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11218 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11221 * store some data for later use
11224 netntlm
->user_len
= user_len
* 2;
11225 netntlm
->domain_len
= domain_len
* 2;
11226 netntlm
->srvchall_len
= srvchall_len
/ 2;
11227 netntlm
->clichall_len
= clichall_len
/ 2;
11229 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11230 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11233 * handle username and domainname
11236 for (uint i
= 0; i
< user_len
; i
++)
11238 *userdomain_ptr
++ = user_pos
[i
];
11239 *userdomain_ptr
++ = 0;
11242 for (uint i
= 0; i
< domain_len
; i
++)
11244 *userdomain_ptr
++ = domain_pos
[i
];
11245 *userdomain_ptr
++ = 0;
11249 * handle server challenge encoding
11252 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11254 const char p0
= srvchall_pos
[i
+ 0];
11255 const char p1
= srvchall_pos
[i
+ 1];
11257 *chall_ptr
++ = hex_convert (p1
) << 0
11258 | hex_convert (p0
) << 4;
11262 * handle client challenge encoding
11265 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11267 const char p0
= clichall_pos
[i
+ 0];
11268 const char p1
= clichall_pos
[i
+ 1];
11270 *chall_ptr
++ = hex_convert (p1
) << 0
11271 | hex_convert (p0
) << 4;
11278 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11280 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11282 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11284 salt
->salt_len
= salt_len
;
11286 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11287 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11288 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11289 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11291 digest
[0] = byte_swap_32 (digest
[0]);
11292 digest
[1] = byte_swap_32 (digest
[1]);
11293 digest
[2] = byte_swap_32 (digest
[2]);
11294 digest
[3] = byte_swap_32 (digest
[3]);
11296 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11298 uint digest_tmp
[2] = { 0 };
11300 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11301 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11303 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11304 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11306 /* special case 2: ESS */
11308 if (srvchall_len
== 48)
11310 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11312 uint w
[16] = { 0 };
11314 w
[ 0] = netntlm
->chall_buf
[6];
11315 w
[ 1] = netntlm
->chall_buf
[7];
11316 w
[ 2] = netntlm
->chall_buf
[0];
11317 w
[ 3] = netntlm
->chall_buf
[1];
11321 uint dgst
[4] = { 0 };
11330 salt
->salt_buf
[0] = dgst
[0];
11331 salt
->salt_buf
[1] = dgst
[1];
11335 /* precompute netntlmv1 exploit start */
11337 for (uint i
= 0; i
< 0x10000; i
++)
11339 uint key_md4
[2] = { i
, 0 };
11340 uint key_des
[2] = { 0, 0 };
11342 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11344 uint Kc
[16] = { 0 };
11345 uint Kd
[16] = { 0 };
11347 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11349 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11351 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11353 if (data3
[0] != digest_tmp
[0]) continue;
11354 if (data3
[1] != digest_tmp
[1]) continue;
11356 salt
->salt_buf
[2] = i
;
11358 salt
->salt_len
= 24;
11363 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11364 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11366 /* precompute netntlmv1 exploit stop */
11370 IP (digest
[0], digest
[1], tt
);
11371 IP (digest
[2], digest
[3], tt
);
11373 digest
[0] = rotr32 (digest
[0], 29);
11374 digest
[1] = rotr32 (digest
[1], 29);
11375 digest
[2] = rotr32 (digest
[2], 29);
11376 digest
[3] = rotr32 (digest
[3], 29);
11378 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11380 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11381 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11383 return (PARSER_OK
);
11386 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11388 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11390 u32
*digest
= (u32
*) hash_buf
->digest
;
11392 salt_t
*salt
= hash_buf
->salt
;
11394 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11400 char *user_pos
= input_buf
;
11402 char *unused_pos
= strchr (user_pos
, ':');
11404 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11406 uint user_len
= unused_pos
- user_pos
;
11408 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11412 char *domain_pos
= strchr (unused_pos
, ':');
11414 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11416 uint unused_len
= domain_pos
- unused_pos
;
11418 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11422 char *srvchall_pos
= strchr (domain_pos
, ':');
11424 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11426 uint domain_len
= srvchall_pos
- domain_pos
;
11428 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11432 char *hash_pos
= strchr (srvchall_pos
, ':');
11434 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11436 uint srvchall_len
= hash_pos
- srvchall_pos
;
11438 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11442 char *clichall_pos
= strchr (hash_pos
, ':');
11444 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11446 uint hash_len
= clichall_pos
- hash_pos
;
11448 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11452 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11454 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11456 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11459 * store some data for later use
11462 netntlm
->user_len
= user_len
* 2;
11463 netntlm
->domain_len
= domain_len
* 2;
11464 netntlm
->srvchall_len
= srvchall_len
/ 2;
11465 netntlm
->clichall_len
= clichall_len
/ 2;
11467 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11468 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11471 * handle username and domainname
11474 for (uint i
= 0; i
< user_len
; i
++)
11476 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11477 *userdomain_ptr
++ = 0;
11480 for (uint i
= 0; i
< domain_len
; i
++)
11482 *userdomain_ptr
++ = domain_pos
[i
];
11483 *userdomain_ptr
++ = 0;
11486 *userdomain_ptr
++ = 0x80;
11489 * handle server challenge encoding
11492 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11494 const char p0
= srvchall_pos
[i
+ 0];
11495 const char p1
= srvchall_pos
[i
+ 1];
11497 *chall_ptr
++ = hex_convert (p1
) << 0
11498 | hex_convert (p0
) << 4;
11502 * handle client challenge encoding
11505 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11507 const char p0
= clichall_pos
[i
+ 0];
11508 const char p1
= clichall_pos
[i
+ 1];
11510 *chall_ptr
++ = hex_convert (p1
) << 0
11511 | hex_convert (p0
) << 4;
11514 *chall_ptr
++ = 0x80;
11517 * handle hash itself
11520 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11521 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11522 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11523 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11525 digest
[0] = byte_swap_32 (digest
[0]);
11526 digest
[1] = byte_swap_32 (digest
[1]);
11527 digest
[2] = byte_swap_32 (digest
[2]);
11528 digest
[3] = byte_swap_32 (digest
[3]);
11531 * reuse challange data as salt_buf, its the buffer that is most likely unique
11534 salt
->salt_buf
[0] = 0;
11535 salt
->salt_buf
[1] = 0;
11536 salt
->salt_buf
[2] = 0;
11537 salt
->salt_buf
[3] = 0;
11538 salt
->salt_buf
[4] = 0;
11539 salt
->salt_buf
[5] = 0;
11540 salt
->salt_buf
[6] = 0;
11541 salt
->salt_buf
[7] = 0;
11545 uptr
= (uint
*) netntlm
->userdomain_buf
;
11547 for (uint i
= 0; i
< 16; i
+= 16)
11549 md5_64 (uptr
, salt
->salt_buf
);
11552 uptr
= (uint
*) netntlm
->chall_buf
;
11554 for (uint i
= 0; i
< 256; i
+= 16)
11556 md5_64 (uptr
, salt
->salt_buf
);
11559 salt
->salt_len
= 16;
11561 return (PARSER_OK
);
11564 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11566 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11568 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11572 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11575 u32
*digest
= (u32
*) hash_buf
->digest
;
11577 salt_t
*salt
= hash_buf
->salt
;
11579 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11580 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11581 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11582 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11584 digest
[0] = byte_swap_32 (digest
[0]);
11585 digest
[1] = byte_swap_32 (digest
[1]);
11586 digest
[2] = byte_swap_32 (digest
[2]);
11587 digest
[3] = byte_swap_32 (digest
[3]);
11589 digest
[0] -= MD5M_A
;
11590 digest
[1] -= MD5M_B
;
11591 digest
[2] -= MD5M_C
;
11592 digest
[3] -= MD5M_D
;
11594 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11596 uint salt_len
= input_len
- 32 - 1;
11598 char *salt_buf
= input_buf
+ 32 + 1;
11600 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11602 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11604 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11606 salt
->salt_len
= salt_len
;
11608 return (PARSER_OK
);
11611 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11613 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11615 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11619 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11622 u32
*digest
= (u32
*) hash_buf
->digest
;
11624 salt_t
*salt
= hash_buf
->salt
;
11626 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11627 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11628 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11629 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11631 digest
[0] = byte_swap_32 (digest
[0]);
11632 digest
[1] = byte_swap_32 (digest
[1]);
11633 digest
[2] = byte_swap_32 (digest
[2]);
11634 digest
[3] = byte_swap_32 (digest
[3]);
11636 digest
[0] -= MD5M_A
;
11637 digest
[1] -= MD5M_B
;
11638 digest
[2] -= MD5M_C
;
11639 digest
[3] -= MD5M_D
;
11641 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11643 uint salt_len
= input_len
- 32 - 1;
11645 char *salt_buf
= input_buf
+ 32 + 1;
11647 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11649 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11651 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11653 salt
->salt_len
= salt_len
;
11655 return (PARSER_OK
);
11658 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11660 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11662 u32
*digest
= (u32
*) hash_buf
->digest
;
11664 salt_t
*salt
= hash_buf
->salt
;
11666 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11667 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11668 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11669 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11671 digest
[0] = byte_swap_32 (digest
[0]);
11672 digest
[1] = byte_swap_32 (digest
[1]);
11673 digest
[2] = byte_swap_32 (digest
[2]);
11674 digest
[3] = byte_swap_32 (digest
[3]);
11676 digest
[0] -= MD5M_A
;
11677 digest
[1] -= MD5M_B
;
11678 digest
[2] -= MD5M_C
;
11679 digest
[3] -= MD5M_D
;
11682 * This is a virtual salt. While the algorithm is basically not salted
11683 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11684 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11687 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11689 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11691 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11693 salt
->salt_len
= salt_len
;
11695 return (PARSER_OK
);
11698 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11700 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11702 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11706 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11709 u32
*digest
= (u32
*) hash_buf
->digest
;
11711 salt_t
*salt
= hash_buf
->salt
;
11713 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11714 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11715 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11716 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11718 digest
[0] = byte_swap_32 (digest
[0]);
11719 digest
[1] = byte_swap_32 (digest
[1]);
11720 digest
[2] = byte_swap_32 (digest
[2]);
11721 digest
[3] = byte_swap_32 (digest
[3]);
11723 digest
[0] -= MD5M_A
;
11724 digest
[1] -= MD5M_B
;
11725 digest
[2] -= MD5M_C
;
11726 digest
[3] -= MD5M_D
;
11728 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11730 uint salt_len
= input_len
- 32 - 1;
11732 char *salt_buf
= input_buf
+ 32 + 1;
11734 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11736 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11738 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11740 salt
->salt_len
= salt_len
;
11742 return (PARSER_OK
);
11745 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11747 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11749 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11753 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11756 u32
*digest
= (u32
*) hash_buf
->digest
;
11758 salt_t
*salt
= hash_buf
->salt
;
11760 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11761 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11762 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11763 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11765 digest
[0] = byte_swap_32 (digest
[0]);
11766 digest
[1] = byte_swap_32 (digest
[1]);
11767 digest
[2] = byte_swap_32 (digest
[2]);
11768 digest
[3] = byte_swap_32 (digest
[3]);
11770 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11772 uint salt_len
= input_len
- 32 - 1;
11774 char *salt_buf
= input_buf
+ 32 + 1;
11776 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11778 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11780 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11782 salt
->salt_len
= salt_len
;
11784 return (PARSER_OK
);
11787 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11789 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11791 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11795 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11798 u32
*digest
= (u32
*) hash_buf
->digest
;
11800 salt_t
*salt
= hash_buf
->salt
;
11802 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11803 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11804 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11805 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11807 digest
[0] = byte_swap_32 (digest
[0]);
11808 digest
[1] = byte_swap_32 (digest
[1]);
11809 digest
[2] = byte_swap_32 (digest
[2]);
11810 digest
[3] = byte_swap_32 (digest
[3]);
11812 digest
[0] -= MD4M_A
;
11813 digest
[1] -= MD4M_B
;
11814 digest
[2] -= MD4M_C
;
11815 digest
[3] -= MD4M_D
;
11817 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11819 uint salt_len
= input_len
- 32 - 1;
11821 char *salt_buf
= input_buf
+ 32 + 1;
11823 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11825 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11827 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11829 salt
->salt_len
= salt_len
;
11831 return (PARSER_OK
);
11834 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11836 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11838 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11842 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11845 u32
*digest
= (u32
*) hash_buf
->digest
;
11847 salt_t
*salt
= hash_buf
->salt
;
11849 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11850 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11851 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11852 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11854 digest
[0] = byte_swap_32 (digest
[0]);
11855 digest
[1] = byte_swap_32 (digest
[1]);
11856 digest
[2] = byte_swap_32 (digest
[2]);
11857 digest
[3] = byte_swap_32 (digest
[3]);
11859 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11861 uint salt_len
= input_len
- 32 - 1;
11863 char *salt_buf
= input_buf
+ 32 + 1;
11865 uint salt_pc_block
[16] = { 0 };
11867 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11869 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11871 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11873 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11875 salt_pc_block
[14] = salt_len
* 8;
11877 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11879 md5_64 (salt_pc_block
, salt_pc_digest
);
11881 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11882 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11883 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11884 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11886 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11888 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11890 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11892 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11893 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11894 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11895 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11897 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11899 return (PARSER_OK
);
11902 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11904 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11906 u32
*digest
= (u32
*) hash_buf
->digest
;
11908 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11909 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11910 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11911 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11912 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11914 digest
[0] -= SHA1M_A
;
11915 digest
[1] -= SHA1M_B
;
11916 digest
[2] -= SHA1M_C
;
11917 digest
[3] -= SHA1M_D
;
11918 digest
[4] -= SHA1M_E
;
11920 return (PARSER_OK
);
11923 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11925 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11927 u32
*digest
= (u32
*) hash_buf
->digest
;
11929 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11930 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11931 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11932 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11933 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11935 return (PARSER_OK
);
11938 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11940 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
11942 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
11944 u32
*digest
= (u32
*) hash_buf
->digest
;
11948 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11949 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11950 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11951 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11952 digest
[4] = 0x00000000;
11954 return (PARSER_OK
);
11957 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11959 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11961 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11965 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11968 u32
*digest
= (u32
*) hash_buf
->digest
;
11970 salt_t
*salt
= hash_buf
->salt
;
11972 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11973 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11974 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11975 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11976 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11978 digest
[0] -= SHA1M_A
;
11979 digest
[1] -= SHA1M_B
;
11980 digest
[2] -= SHA1M_C
;
11981 digest
[3] -= SHA1M_D
;
11982 digest
[4] -= SHA1M_E
;
11984 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11986 uint salt_len
= input_len
- 40 - 1;
11988 char *salt_buf
= input_buf
+ 40 + 1;
11990 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11992 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11994 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11996 salt
->salt_len
= salt_len
;
11998 return (PARSER_OK
);
12001 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12003 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
12005 u32
*digest
= (u32
*) hash_buf
->digest
;
12007 salt_t
*salt
= hash_buf
->salt
;
12009 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
12011 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12012 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12013 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12014 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12015 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12017 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12019 uint salt_len
= input_len
- 40 - 1;
12021 char *salt_buf
= input_buf
+ 40 + 1;
12023 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
12025 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
12027 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
12029 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
12032 pstoken
->salt_len
= salt_len
/ 2;
12034 /* some fake salt for the sorting mechanisms */
12036 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
12037 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
12038 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
12039 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
12040 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
12041 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
12042 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
12043 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
12045 salt
->salt_len
= 32;
12047 /* we need to check if we can precompute some of the data --
12048 this is possible since the scheme is badly designed */
12050 pstoken
->pc_digest
[0] = SHA1M_A
;
12051 pstoken
->pc_digest
[1] = SHA1M_B
;
12052 pstoken
->pc_digest
[2] = SHA1M_C
;
12053 pstoken
->pc_digest
[3] = SHA1M_D
;
12054 pstoken
->pc_digest
[4] = SHA1M_E
;
12056 pstoken
->pc_offset
= 0;
12058 for (int i
= 0; i
< (int) pstoken
->salt_len
- 64; i
+= 64)
12062 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
12063 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
12064 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
12065 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
12066 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
12067 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
12068 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
12069 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
12070 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
12071 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
12072 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
12073 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
12074 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
12075 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
12076 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
12077 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
12079 sha1_64 (w
, pstoken
->pc_digest
);
12081 pstoken
->pc_offset
+= 16;
12084 return (PARSER_OK
);
12087 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12089 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
12091 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
12093 u32
*digest
= (u32
*) hash_buf
->digest
;
12095 u8 tmp_buf
[100] = { 0 };
12097 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
12099 memcpy (digest
, tmp_buf
, 20);
12101 digest
[0] = byte_swap_32 (digest
[0]);
12102 digest
[1] = byte_swap_32 (digest
[1]);
12103 digest
[2] = byte_swap_32 (digest
[2]);
12104 digest
[3] = byte_swap_32 (digest
[3]);
12105 digest
[4] = byte_swap_32 (digest
[4]);
12107 digest
[0] -= SHA1M_A
;
12108 digest
[1] -= SHA1M_B
;
12109 digest
[2] -= SHA1M_C
;
12110 digest
[3] -= SHA1M_D
;
12111 digest
[4] -= SHA1M_E
;
12113 return (PARSER_OK
);
12116 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12118 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
12120 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12122 u32
*digest
= (u32
*) hash_buf
->digest
;
12124 salt_t
*salt
= hash_buf
->salt
;
12126 u8 tmp_buf
[100] = { 0 };
12128 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
12130 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
12132 memcpy (digest
, tmp_buf
, 20);
12134 int salt_len
= tmp_len
- 20;
12136 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
12138 salt
->salt_len
= salt_len
;
12140 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
12142 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12144 char *ptr
= (char *) salt
->salt_buf
;
12146 ptr
[salt
->salt_len
] = 0x80;
12149 digest
[0] = byte_swap_32 (digest
[0]);
12150 digest
[1] = byte_swap_32 (digest
[1]);
12151 digest
[2] = byte_swap_32 (digest
[2]);
12152 digest
[3] = byte_swap_32 (digest
[3]);
12153 digest
[4] = byte_swap_32 (digest
[4]);
12155 digest
[0] -= SHA1M_A
;
12156 digest
[1] -= SHA1M_B
;
12157 digest
[2] -= SHA1M_C
;
12158 digest
[3] -= SHA1M_D
;
12159 digest
[4] -= SHA1M_E
;
12161 return (PARSER_OK
);
12164 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12166 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
12168 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12170 u32
*digest
= (u32
*) hash_buf
->digest
;
12172 salt_t
*salt
= hash_buf
->salt
;
12174 char *salt_buf
= input_buf
+ 6;
12178 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12180 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12182 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12184 salt
->salt_len
= salt_len
;
12186 char *hash_pos
= input_buf
+ 6 + 8 + 40;
12188 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12189 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12190 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12191 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12192 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12194 digest
[0] -= SHA1M_A
;
12195 digest
[1] -= SHA1M_B
;
12196 digest
[2] -= SHA1M_C
;
12197 digest
[3] -= SHA1M_D
;
12198 digest
[4] -= SHA1M_E
;
12200 return (PARSER_OK
);
12203 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12205 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
12207 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12209 u32
*digest
= (u32
*) hash_buf
->digest
;
12211 salt_t
*salt
= hash_buf
->salt
;
12213 char *salt_buf
= input_buf
+ 6;
12217 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12219 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12221 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12223 salt
->salt_len
= salt_len
;
12225 char *hash_pos
= input_buf
+ 6 + 8;
12227 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12228 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12229 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12230 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12231 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12233 digest
[0] -= SHA1M_A
;
12234 digest
[1] -= SHA1M_B
;
12235 digest
[2] -= SHA1M_C
;
12236 digest
[3] -= SHA1M_D
;
12237 digest
[4] -= SHA1M_E
;
12239 return (PARSER_OK
);
12242 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12244 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12246 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12248 u64
*digest
= (u64
*) hash_buf
->digest
;
12250 salt_t
*salt
= hash_buf
->salt
;
12252 char *salt_buf
= input_buf
+ 6;
12256 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12258 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12260 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12262 salt
->salt_len
= salt_len
;
12264 char *hash_pos
= input_buf
+ 6 + 8;
12266 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12267 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12268 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12269 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12270 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12271 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12272 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12273 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12275 digest
[0] -= SHA512M_A
;
12276 digest
[1] -= SHA512M_B
;
12277 digest
[2] -= SHA512M_C
;
12278 digest
[3] -= SHA512M_D
;
12279 digest
[4] -= SHA512M_E
;
12280 digest
[5] -= SHA512M_F
;
12281 digest
[6] -= SHA512M_G
;
12282 digest
[7] -= SHA512M_H
;
12284 return (PARSER_OK
);
12287 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12289 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12291 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12295 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12298 u32
*digest
= (u32
*) hash_buf
->digest
;
12300 salt_t
*salt
= hash_buf
->salt
;
12302 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12303 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12307 digest
[0] = byte_swap_32 (digest
[0]);
12308 digest
[1] = byte_swap_32 (digest
[1]);
12310 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12312 uint salt_len
= input_len
- 16 - 1;
12314 char *salt_buf
= input_buf
+ 16 + 1;
12316 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12318 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12320 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12322 salt
->salt_len
= salt_len
;
12324 return (PARSER_OK
);
12327 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12329 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12331 u32
*digest
= (u32
*) hash_buf
->digest
;
12333 salt_t
*salt
= hash_buf
->salt
;
12335 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12336 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12337 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12338 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12339 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12341 digest
[0] -= SHA1M_A
;
12342 digest
[1] -= SHA1M_B
;
12343 digest
[2] -= SHA1M_C
;
12344 digest
[3] -= SHA1M_D
;
12345 digest
[4] -= SHA1M_E
;
12347 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12349 uint salt_len
= input_len
- 40 - 1;
12351 char *salt_buf
= input_buf
+ 40 + 1;
12353 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12355 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12357 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12359 salt
->salt_len
= salt_len
;
12361 return (PARSER_OK
);
12364 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12366 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12368 u32
*digest
= (u32
*) hash_buf
->digest
;
12370 salt_t
*salt
= hash_buf
->salt
;
12372 char *hash_pos
= input_buf
;
12374 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12375 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12376 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12377 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12378 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12379 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12380 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12381 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12382 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12383 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12384 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12385 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12386 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12387 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12388 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12389 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12391 char *salt_pos
= input_buf
+ 128;
12393 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12394 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12395 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12396 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12398 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12399 salt
->salt_len
= 16;
12401 return (PARSER_OK
);
12404 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12406 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12408 u32
*digest
= (u32
*) hash_buf
->digest
;
12410 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12411 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12412 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12413 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12414 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12415 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12416 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12417 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12419 digest
[0] -= SHA256M_A
;
12420 digest
[1] -= SHA256M_B
;
12421 digest
[2] -= SHA256M_C
;
12422 digest
[3] -= SHA256M_D
;
12423 digest
[4] -= SHA256M_E
;
12424 digest
[5] -= SHA256M_F
;
12425 digest
[6] -= SHA256M_G
;
12426 digest
[7] -= SHA256M_H
;
12428 return (PARSER_OK
);
12431 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12433 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12435 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12439 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12442 u32
*digest
= (u32
*) hash_buf
->digest
;
12444 salt_t
*salt
= hash_buf
->salt
;
12446 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12447 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12448 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12449 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12450 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12451 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12452 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12453 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12455 digest
[0] -= SHA256M_A
;
12456 digest
[1] -= SHA256M_B
;
12457 digest
[2] -= SHA256M_C
;
12458 digest
[3] -= SHA256M_D
;
12459 digest
[4] -= SHA256M_E
;
12460 digest
[5] -= SHA256M_F
;
12461 digest
[6] -= SHA256M_G
;
12462 digest
[7] -= SHA256M_H
;
12464 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12466 uint salt_len
= input_len
- 64 - 1;
12468 char *salt_buf
= input_buf
+ 64 + 1;
12470 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12472 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12474 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12476 salt
->salt_len
= salt_len
;
12478 return (PARSER_OK
);
12481 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12483 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12485 u64
*digest
= (u64
*) hash_buf
->digest
;
12487 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12488 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12489 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12490 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12491 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12492 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12496 digest
[0] -= SHA384M_A
;
12497 digest
[1] -= SHA384M_B
;
12498 digest
[2] -= SHA384M_C
;
12499 digest
[3] -= SHA384M_D
;
12500 digest
[4] -= SHA384M_E
;
12501 digest
[5] -= SHA384M_F
;
12505 return (PARSER_OK
);
12508 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12510 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12512 u64
*digest
= (u64
*) hash_buf
->digest
;
12514 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12515 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12516 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12517 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12518 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12519 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12520 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12521 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12523 digest
[0] -= SHA512M_A
;
12524 digest
[1] -= SHA512M_B
;
12525 digest
[2] -= SHA512M_C
;
12526 digest
[3] -= SHA512M_D
;
12527 digest
[4] -= SHA512M_E
;
12528 digest
[5] -= SHA512M_F
;
12529 digest
[6] -= SHA512M_G
;
12530 digest
[7] -= SHA512M_H
;
12532 return (PARSER_OK
);
12535 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12537 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12539 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12543 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12546 u64
*digest
= (u64
*) hash_buf
->digest
;
12548 salt_t
*salt
= hash_buf
->salt
;
12550 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12551 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12552 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12553 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12554 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12555 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12556 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12557 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12559 digest
[0] -= SHA512M_A
;
12560 digest
[1] -= SHA512M_B
;
12561 digest
[2] -= SHA512M_C
;
12562 digest
[3] -= SHA512M_D
;
12563 digest
[4] -= SHA512M_E
;
12564 digest
[5] -= SHA512M_F
;
12565 digest
[6] -= SHA512M_G
;
12566 digest
[7] -= SHA512M_H
;
12568 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12570 uint salt_len
= input_len
- 128 - 1;
12572 char *salt_buf
= input_buf
+ 128 + 1;
12574 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12576 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12578 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12580 salt
->salt_len
= salt_len
;
12582 return (PARSER_OK
);
12585 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12587 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12589 u64
*digest
= (u64
*) hash_buf
->digest
;
12591 salt_t
*salt
= hash_buf
->salt
;
12593 char *salt_pos
= input_buf
+ 3;
12595 uint iterations_len
= 0;
12597 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12601 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12603 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12604 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12608 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12612 iterations_len
+= 8;
12616 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12619 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12621 char *hash_pos
= strchr (salt_pos
, '$');
12623 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12625 uint salt_len
= hash_pos
- salt_pos
;
12627 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12629 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12631 salt
->salt_len
= salt_len
;
12635 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12637 return (PARSER_OK
);
12640 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12642 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12644 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12646 u64
*digest
= (u64
*) hash_buf
->digest
;
12648 salt_t
*salt
= hash_buf
->salt
;
12650 uint keccak_mdlen
= input_len
/ 2;
12652 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12654 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12656 digest
[i
] = byte_swap_64 (digest
[i
]);
12659 salt
->keccak_mdlen
= keccak_mdlen
;
12661 return (PARSER_OK
);
12664 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12666 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12668 u32
*digest
= (u32
*) hash_buf
->digest
;
12670 salt_t
*salt
= hash_buf
->salt
;
12672 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12675 * Parse that strange long line
12680 size_t in_len
[9] = { 0 };
12682 in_off
[0] = strtok (input_buf
, ":");
12684 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12686 in_len
[0] = strlen (in_off
[0]);
12690 for (i
= 1; i
< 9; i
++)
12692 in_off
[i
] = strtok (NULL
, ":");
12694 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12696 in_len
[i
] = strlen (in_off
[i
]);
12699 char *ptr
= (char *) ikepsk
->msg_buf
;
12701 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12702 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12703 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12704 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12705 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12706 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12710 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12712 ptr
= (char *) ikepsk
->nr_buf
;
12714 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12715 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12719 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12722 * Store to database
12727 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12728 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12729 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12730 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12732 digest
[0] = byte_swap_32 (digest
[0]);
12733 digest
[1] = byte_swap_32 (digest
[1]);
12734 digest
[2] = byte_swap_32 (digest
[2]);
12735 digest
[3] = byte_swap_32 (digest
[3]);
12737 salt
->salt_len
= 32;
12739 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12740 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12741 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12742 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12743 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12744 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12745 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12746 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12748 return (PARSER_OK
);
12751 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12753 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12755 u32
*digest
= (u32
*) hash_buf
->digest
;
12757 salt_t
*salt
= hash_buf
->salt
;
12759 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12762 * Parse that strange long line
12767 size_t in_len
[9] = { 0 };
12769 in_off
[0] = strtok (input_buf
, ":");
12771 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12773 in_len
[0] = strlen (in_off
[0]);
12777 for (i
= 1; i
< 9; i
++)
12779 in_off
[i
] = strtok (NULL
, ":");
12781 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12783 in_len
[i
] = strlen (in_off
[i
]);
12786 char *ptr
= (char *) ikepsk
->msg_buf
;
12788 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12789 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12790 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12791 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12792 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12793 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12797 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12799 ptr
= (char *) ikepsk
->nr_buf
;
12801 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12802 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12806 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12809 * Store to database
12814 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12815 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12816 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12817 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12818 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12820 salt
->salt_len
= 32;
12822 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12823 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12824 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12825 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12826 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12827 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12828 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12829 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12831 return (PARSER_OK
);
12834 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12836 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12838 u32
*digest
= (u32
*) hash_buf
->digest
;
12840 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12841 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12842 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12843 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12844 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12846 digest
[0] = byte_swap_32 (digest
[0]);
12847 digest
[1] = byte_swap_32 (digest
[1]);
12848 digest
[2] = byte_swap_32 (digest
[2]);
12849 digest
[3] = byte_swap_32 (digest
[3]);
12850 digest
[4] = byte_swap_32 (digest
[4]);
12852 return (PARSER_OK
);
12855 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12857 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12859 u32
*digest
= (u32
*) hash_buf
->digest
;
12861 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12862 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12863 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12864 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12865 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12866 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12867 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12868 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12869 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12870 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12871 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12872 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12873 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12874 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12875 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12876 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12878 return (PARSER_OK
);
12881 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12883 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12885 u32
*digest
= (u32
*) hash_buf
->digest
;
12887 salt_t
*salt
= hash_buf
->salt
;
12889 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12890 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12891 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12892 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12893 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12895 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12897 uint salt_len
= input_len
- 40 - 1;
12899 char *salt_buf
= input_buf
+ 40 + 1;
12901 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12903 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12905 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12907 salt
->salt_len
= salt_len
;
12909 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12911 return (PARSER_OK
);
12914 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12916 u32
*digest
= (u32
*) hash_buf
->digest
;
12918 salt_t
*salt
= hash_buf
->salt
;
12920 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12922 if (input_len
== 0)
12924 log_error ("TrueCrypt container not specified");
12929 FILE *fp
= fopen (input_buf
, "rb");
12933 log_error ("%s: %s", input_buf
, strerror (errno
));
12938 char buf
[512] = { 0 };
12940 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12944 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12946 memcpy (tc
->salt_buf
, buf
, 64);
12948 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12950 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12952 salt
->salt_len
= 4;
12954 salt
->salt_iter
= ROUNDS_TRUECRYPT_1K
- 1;
12956 tc
->signature
= 0x45555254; // "TRUE"
12958 digest
[0] = tc
->data_buf
[0];
12960 return (PARSER_OK
);
12963 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12965 u32
*digest
= (u32
*) hash_buf
->digest
;
12967 salt_t
*salt
= hash_buf
->salt
;
12969 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12971 if (input_len
== 0)
12973 log_error ("TrueCrypt container not specified");
12978 FILE *fp
= fopen (input_buf
, "rb");
12982 log_error ("%s: %s", input_buf
, strerror (errno
));
12987 char buf
[512] = { 0 };
12989 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12993 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12995 memcpy (tc
->salt_buf
, buf
, 64);
12997 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12999 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13001 salt
->salt_len
= 4;
13003 salt
->salt_iter
= ROUNDS_TRUECRYPT_2K
- 1;
13005 tc
->signature
= 0x45555254; // "TRUE"
13007 digest
[0] = tc
->data_buf
[0];
13009 return (PARSER_OK
);
13012 int veracrypt_parse_hash_200000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13014 u32
*digest
= (u32
*) hash_buf
->digest
;
13016 salt_t
*salt
= hash_buf
->salt
;
13018 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13020 if (input_len
== 0)
13022 log_error ("VeraCrypt container not specified");
13027 FILE *fp
= fopen (input_buf
, "rb");
13031 log_error ("%s: %s", input_buf
, strerror (errno
));
13036 char buf
[512] = { 0 };
13038 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13042 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13044 memcpy (tc
->salt_buf
, buf
, 64);
13046 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13048 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13050 salt
->salt_len
= 4;
13052 salt
->salt_iter
= ROUNDS_VERACRYPT_200000
- 1;
13054 tc
->signature
= 0x41524556; // "VERA"
13056 digest
[0] = tc
->data_buf
[0];
13058 return (PARSER_OK
);
13061 int veracrypt_parse_hash_500000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13063 u32
*digest
= (u32
*) hash_buf
->digest
;
13065 salt_t
*salt
= hash_buf
->salt
;
13067 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13069 if (input_len
== 0)
13071 log_error ("VeraCrypt container not specified");
13076 FILE *fp
= fopen (input_buf
, "rb");
13080 log_error ("%s: %s", input_buf
, strerror (errno
));
13085 char buf
[512] = { 0 };
13087 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13091 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13093 memcpy (tc
->salt_buf
, buf
, 64);
13095 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13097 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13099 salt
->salt_len
= 4;
13101 salt
->salt_iter
= ROUNDS_VERACRYPT_500000
- 1;
13103 tc
->signature
= 0x41524556; // "VERA"
13105 digest
[0] = tc
->data_buf
[0];
13107 return (PARSER_OK
);
13110 int veracrypt_parse_hash_327661 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13112 u32
*digest
= (u32
*) hash_buf
->digest
;
13114 salt_t
*salt
= hash_buf
->salt
;
13116 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13118 if (input_len
== 0)
13120 log_error ("VeraCrypt container not specified");
13125 FILE *fp
= fopen (input_buf
, "rb");
13129 log_error ("%s: %s", input_buf
, strerror (errno
));
13134 char buf
[512] = { 0 };
13136 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13140 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13142 memcpy (tc
->salt_buf
, buf
, 64);
13144 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13146 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13148 salt
->salt_len
= 4;
13150 salt
->salt_iter
= ROUNDS_VERACRYPT_327661
- 1;
13152 tc
->signature
= 0x41524556; // "VERA"
13154 digest
[0] = tc
->data_buf
[0];
13156 return (PARSER_OK
);
13159 int veracrypt_parse_hash_655331 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13161 u32
*digest
= (u32
*) hash_buf
->digest
;
13163 salt_t
*salt
= hash_buf
->salt
;
13165 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13167 if (input_len
== 0)
13169 log_error ("VeraCrypt container not specified");
13174 FILE *fp
= fopen (input_buf
, "rb");
13178 log_error ("%s: %s", input_buf
, strerror (errno
));
13183 char buf
[512] = { 0 };
13185 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13189 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13191 memcpy (tc
->salt_buf
, buf
, 64);
13193 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13195 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13197 salt
->salt_len
= 4;
13199 salt
->salt_iter
= ROUNDS_VERACRYPT_655331
- 1;
13201 tc
->signature
= 0x41524556; // "VERA"
13203 digest
[0] = tc
->data_buf
[0];
13205 return (PARSER_OK
);
13208 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13210 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
13212 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13214 u32
*digest
= (u32
*) hash_buf
->digest
;
13216 salt_t
*salt
= hash_buf
->salt
;
13218 char *salt_pos
= input_buf
+ 6;
13220 char *hash_pos
= strchr (salt_pos
, '$');
13222 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13224 uint salt_len
= hash_pos
- salt_pos
;
13226 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
13228 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13230 salt
->salt_len
= salt_len
;
13232 salt
->salt_iter
= 1000;
13236 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13238 return (PARSER_OK
);
13241 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13243 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
13245 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
13247 u32
*digest
= (u32
*) hash_buf
->digest
;
13249 salt_t
*salt
= hash_buf
->salt
;
13251 char *iter_pos
= input_buf
+ 7;
13253 char *salt_pos
= strchr (iter_pos
, '$');
13255 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13259 char *hash_pos
= strchr (salt_pos
, '$');
13261 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13263 uint salt_len
= hash_pos
- salt_pos
;
13265 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13267 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13269 salt
->salt_len
= salt_len
;
13271 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13273 salt
->salt_sign
[0] = atoi (salt_iter
);
13275 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13279 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13281 digest
[0] = byte_swap_32 (digest
[0]);
13282 digest
[1] = byte_swap_32 (digest
[1]);
13283 digest
[2] = byte_swap_32 (digest
[2]);
13284 digest
[3] = byte_swap_32 (digest
[3]);
13285 digest
[4] = byte_swap_32 (digest
[4]);
13287 return (PARSER_OK
);
13290 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13292 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
13294 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13296 u32
*digest
= (u32
*) hash_buf
->digest
;
13298 salt_t
*salt
= hash_buf
->salt
;
13300 char *iter_pos
= input_buf
+ 9;
13302 char *salt_pos
= strchr (iter_pos
, '$');
13304 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13308 char *hash_pos
= strchr (salt_pos
, '$');
13310 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13312 uint salt_len
= hash_pos
- salt_pos
;
13314 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13316 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13318 salt
->salt_len
= salt_len
;
13320 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13322 salt
->salt_sign
[0] = atoi (salt_iter
);
13324 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13328 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13330 digest
[0] = byte_swap_32 (digest
[0]);
13331 digest
[1] = byte_swap_32 (digest
[1]);
13332 digest
[2] = byte_swap_32 (digest
[2]);
13333 digest
[3] = byte_swap_32 (digest
[3]);
13334 digest
[4] = byte_swap_32 (digest
[4]);
13335 digest
[5] = byte_swap_32 (digest
[5]);
13336 digest
[6] = byte_swap_32 (digest
[6]);
13337 digest
[7] = byte_swap_32 (digest
[7]);
13339 return (PARSER_OK
);
13342 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13344 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
13346 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13348 u64
*digest
= (u64
*) hash_buf
->digest
;
13350 salt_t
*salt
= hash_buf
->salt
;
13352 char *iter_pos
= input_buf
+ 9;
13354 char *salt_pos
= strchr (iter_pos
, '$');
13356 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13360 char *hash_pos
= strchr (salt_pos
, '$');
13362 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13364 uint salt_len
= hash_pos
- salt_pos
;
13366 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13368 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13370 salt
->salt_len
= salt_len
;
13372 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13374 salt
->salt_sign
[0] = atoi (salt_iter
);
13376 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13380 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13382 digest
[0] = byte_swap_64 (digest
[0]);
13383 digest
[1] = byte_swap_64 (digest
[1]);
13384 digest
[2] = byte_swap_64 (digest
[2]);
13385 digest
[3] = byte_swap_64 (digest
[3]);
13386 digest
[4] = byte_swap_64 (digest
[4]);
13387 digest
[5] = byte_swap_64 (digest
[5]);
13388 digest
[6] = byte_swap_64 (digest
[6]);
13389 digest
[7] = byte_swap_64 (digest
[7]);
13391 return (PARSER_OK
);
13394 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13396 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
13398 u32
*digest
= (u32
*) hash_buf
->digest
;
13400 salt_t
*salt
= hash_buf
->salt
;
13402 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
13408 char *iterations_pos
= input_buf
;
13410 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13412 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13414 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13416 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13420 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13422 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13424 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13426 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13428 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13430 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13435 * pbkdf2 iterations
13438 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13441 * handle salt encoding
13444 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13446 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13448 const char p0
= saltbuf_pos
[i
+ 0];
13449 const char p1
= saltbuf_pos
[i
+ 1];
13451 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13452 | hex_convert (p0
) << 4;
13455 salt
->salt_len
= saltbuf_len
/ 2;
13458 * handle cipher encoding
13461 uint
*tmp
= (uint
*) mymalloc (32);
13463 char *cipherbuf_ptr
= (char *) tmp
;
13465 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13467 const char p0
= cipherbuf_pos
[i
+ 0];
13468 const char p1
= cipherbuf_pos
[i
+ 1];
13470 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13471 | hex_convert (p0
) << 4;
13474 // iv is stored at salt_buf 4 (length 16)
13475 // data is stored at salt_buf 8 (length 16)
13477 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13478 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13479 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13480 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13482 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13483 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13484 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13485 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13489 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13491 const char p0
= cipherbuf_pos
[j
+ 0];
13492 const char p1
= cipherbuf_pos
[j
+ 1];
13494 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13495 | hex_convert (p0
) << 4;
13502 digest
[0] = 0x10101010;
13503 digest
[1] = 0x10101010;
13504 digest
[2] = 0x10101010;
13505 digest
[3] = 0x10101010;
13507 return (PARSER_OK
);
13510 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13512 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13514 u32
*digest
= (u32
*) hash_buf
->digest
;
13516 salt_t
*salt
= hash_buf
->salt
;
13518 char *hashbuf_pos
= input_buf
;
13520 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13522 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13524 uint hash_len
= iterations_pos
- hashbuf_pos
;
13526 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13530 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13532 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13534 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13538 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13540 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13542 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13544 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13546 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13548 salt
->salt_len
= salt_len
;
13550 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13552 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13553 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13554 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13555 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13557 return (PARSER_OK
);
13560 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13562 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13564 u32
*digest
= (u32
*) hash_buf
->digest
;
13566 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13567 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13568 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13569 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13570 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13571 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13572 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13573 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13575 digest
[0] = byte_swap_32 (digest
[0]);
13576 digest
[1] = byte_swap_32 (digest
[1]);
13577 digest
[2] = byte_swap_32 (digest
[2]);
13578 digest
[3] = byte_swap_32 (digest
[3]);
13579 digest
[4] = byte_swap_32 (digest
[4]);
13580 digest
[5] = byte_swap_32 (digest
[5]);
13581 digest
[6] = byte_swap_32 (digest
[6]);
13582 digest
[7] = byte_swap_32 (digest
[7]);
13584 return (PARSER_OK
);
13587 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13589 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13591 u32
*digest
= (u32
*) hash_buf
->digest
;
13593 salt_t
*salt
= hash_buf
->salt
;
13595 char *salt_pos
= input_buf
+ 3;
13597 uint iterations_len
= 0;
13599 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13603 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13605 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13606 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13610 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13614 iterations_len
+= 8;
13618 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13621 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13623 char *hash_pos
= strchr (salt_pos
, '$');
13625 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13627 uint salt_len
= hash_pos
- salt_pos
;
13629 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13631 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13633 salt
->salt_len
= salt_len
;
13637 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13639 return (PARSER_OK
);
13642 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13644 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13646 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13648 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13650 u64
*digest
= (u64
*) hash_buf
->digest
;
13652 salt_t
*salt
= hash_buf
->salt
;
13654 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13656 char *iter_pos
= input_buf
+ 4;
13658 char *salt_pos
= strchr (iter_pos
, '$');
13660 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13664 char *hash_pos
= strchr (salt_pos
, '$');
13666 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13668 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13672 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13673 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13674 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13675 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13676 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13677 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13678 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13679 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13681 uint salt_len
= hash_pos
- salt_pos
- 1;
13683 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13685 salt
->salt_len
= salt_len
/ 2;
13687 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13688 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13689 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13690 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13691 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13692 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13693 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13694 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13696 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13697 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13698 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13699 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13700 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13701 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13702 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13703 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13704 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13705 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13707 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13709 salt
->salt_iter
= atoi (iter_pos
) - 1;
13711 return (PARSER_OK
);
13714 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13716 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13718 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13720 u32
*digest
= (u32
*) hash_buf
->digest
;
13722 salt_t
*salt
= hash_buf
->salt
;
13724 char *salt_pos
= input_buf
+ 14;
13726 char *hash_pos
= strchr (salt_pos
, '*');
13728 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13732 uint salt_len
= hash_pos
- salt_pos
- 1;
13734 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13736 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13738 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13740 salt
->salt_len
= salt_len
;
13742 u8 tmp_buf
[100] = { 0 };
13744 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13746 memcpy (digest
, tmp_buf
, 32);
13748 digest
[0] = byte_swap_32 (digest
[0]);
13749 digest
[1] = byte_swap_32 (digest
[1]);
13750 digest
[2] = byte_swap_32 (digest
[2]);
13751 digest
[3] = byte_swap_32 (digest
[3]);
13752 digest
[4] = byte_swap_32 (digest
[4]);
13753 digest
[5] = byte_swap_32 (digest
[5]);
13754 digest
[6] = byte_swap_32 (digest
[6]);
13755 digest
[7] = byte_swap_32 (digest
[7]);
13757 digest
[0] -= SHA256M_A
;
13758 digest
[1] -= SHA256M_B
;
13759 digest
[2] -= SHA256M_C
;
13760 digest
[3] -= SHA256M_D
;
13761 digest
[4] -= SHA256M_E
;
13762 digest
[5] -= SHA256M_F
;
13763 digest
[6] -= SHA256M_G
;
13764 digest
[7] -= SHA256M_H
;
13766 return (PARSER_OK
);
13769 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13771 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13773 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13775 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13777 u64
*digest
= (u64
*) hash_buf
->digest
;
13779 salt_t
*salt
= hash_buf
->salt
;
13781 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13783 char *iter_pos
= input_buf
+ 19;
13785 char *salt_pos
= strchr (iter_pos
, '.');
13787 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13791 char *hash_pos
= strchr (salt_pos
, '.');
13793 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13795 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13799 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13800 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13801 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13802 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13803 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13804 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13805 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13806 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13808 uint salt_len
= hash_pos
- salt_pos
- 1;
13812 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13816 for (i
= 0; i
< salt_len
; i
++)
13818 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13821 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13822 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13824 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13826 salt
->salt_len
= salt_len
;
13828 salt
->salt_iter
= atoi (iter_pos
) - 1;
13830 return (PARSER_OK
);
13833 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13835 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13837 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13839 u64
*digest
= (u64
*) hash_buf
->digest
;
13841 salt_t
*salt
= hash_buf
->salt
;
13843 u8 tmp_buf
[120] = { 0 };
13845 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13847 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13849 memcpy (digest
, tmp_buf
, 64);
13851 digest
[0] = byte_swap_64 (digest
[0]);
13852 digest
[1] = byte_swap_64 (digest
[1]);
13853 digest
[2] = byte_swap_64 (digest
[2]);
13854 digest
[3] = byte_swap_64 (digest
[3]);
13855 digest
[4] = byte_swap_64 (digest
[4]);
13856 digest
[5] = byte_swap_64 (digest
[5]);
13857 digest
[6] = byte_swap_64 (digest
[6]);
13858 digest
[7] = byte_swap_64 (digest
[7]);
13860 digest
[0] -= SHA512M_A
;
13861 digest
[1] -= SHA512M_B
;
13862 digest
[2] -= SHA512M_C
;
13863 digest
[3] -= SHA512M_D
;
13864 digest
[4] -= SHA512M_E
;
13865 digest
[5] -= SHA512M_F
;
13866 digest
[6] -= SHA512M_G
;
13867 digest
[7] -= SHA512M_H
;
13869 int salt_len
= tmp_len
- 64;
13871 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13873 salt
->salt_len
= salt_len
;
13875 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13877 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13879 char *ptr
= (char *) salt
->salt_buf
;
13881 ptr
[salt
->salt_len
] = 0x80;
13884 return (PARSER_OK
);
13887 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13889 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13891 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13895 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13898 u32
*digest
= (u32
*) hash_buf
->digest
;
13900 salt_t
*salt
= hash_buf
->salt
;
13902 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13903 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13904 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13905 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13907 digest
[0] = byte_swap_32 (digest
[0]);
13908 digest
[1] = byte_swap_32 (digest
[1]);
13909 digest
[2] = byte_swap_32 (digest
[2]);
13910 digest
[3] = byte_swap_32 (digest
[3]);
13912 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13914 uint salt_len
= input_len
- 32 - 1;
13916 char *salt_buf
= input_buf
+ 32 + 1;
13918 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13920 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13922 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13924 salt
->salt_len
= salt_len
;
13926 return (PARSER_OK
);
13929 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13931 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13933 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13937 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13940 u32
*digest
= (u32
*) hash_buf
->digest
;
13942 salt_t
*salt
= hash_buf
->salt
;
13944 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13945 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13946 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13947 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13948 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13950 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13952 uint salt_len
= input_len
- 40 - 1;
13954 char *salt_buf
= input_buf
+ 40 + 1;
13956 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13958 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13960 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13962 salt
->salt_len
= salt_len
;
13964 return (PARSER_OK
);
13967 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13969 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13971 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13975 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13978 u32
*digest
= (u32
*) hash_buf
->digest
;
13980 salt_t
*salt
= hash_buf
->salt
;
13982 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13983 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13984 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13985 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13986 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13987 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13988 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13989 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13991 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13993 uint salt_len
= input_len
- 64 - 1;
13995 char *salt_buf
= input_buf
+ 64 + 1;
13997 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13999 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14001 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14003 salt
->salt_len
= salt_len
;
14005 return (PARSER_OK
);
14008 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14010 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14012 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
14016 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
14019 u64
*digest
= (u64
*) hash_buf
->digest
;
14021 salt_t
*salt
= hash_buf
->salt
;
14023 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
14024 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
14025 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
14026 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
14027 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
14028 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
14029 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
14030 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
14032 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14034 uint salt_len
= input_len
- 128 - 1;
14036 char *salt_buf
= input_buf
+ 128 + 1;
14038 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14040 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14042 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14044 salt
->salt_len
= salt_len
;
14046 return (PARSER_OK
);
14049 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14051 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
14053 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
14055 u32
*digest
= (u32
*) hash_buf
->digest
;
14057 salt_t
*salt
= hash_buf
->salt
;
14059 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
14065 char *user_pos
= input_buf
+ 10 + 1;
14067 char *realm_pos
= strchr (user_pos
, '$');
14069 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14071 uint user_len
= realm_pos
- user_pos
;
14073 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
14077 char *salt_pos
= strchr (realm_pos
, '$');
14079 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14081 uint realm_len
= salt_pos
- realm_pos
;
14083 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
14087 char *data_pos
= strchr (salt_pos
, '$');
14089 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14091 uint salt_len
= data_pos
- salt_pos
;
14093 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
14097 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
14099 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
14105 memcpy (krb5pa
->user
, user_pos
, user_len
);
14106 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
14107 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
14109 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
14111 for (uint i
= 0; i
< (36 * 2); i
+= 2)
14113 const char p0
= data_pos
[i
+ 0];
14114 const char p1
= data_pos
[i
+ 1];
14116 *timestamp_ptr
++ = hex_convert (p1
) << 0
14117 | hex_convert (p0
) << 4;
14120 char *checksum_ptr
= (char *) krb5pa
->checksum
;
14122 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
14124 const char p0
= data_pos
[i
+ 0];
14125 const char p1
= data_pos
[i
+ 1];
14127 *checksum_ptr
++ = hex_convert (p1
) << 0
14128 | hex_convert (p0
) << 4;
14132 * copy some data to generic buffers to make sorting happy
14135 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
14136 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
14137 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
14138 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
14139 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
14140 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
14141 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
14142 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
14143 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
14145 salt
->salt_len
= 36;
14147 digest
[0] = krb5pa
->checksum
[0];
14148 digest
[1] = krb5pa
->checksum
[1];
14149 digest
[2] = krb5pa
->checksum
[2];
14150 digest
[3] = krb5pa
->checksum
[3];
14152 return (PARSER_OK
);
14155 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14157 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
14159 u32
*digest
= (u32
*) hash_buf
->digest
;
14161 salt_t
*salt
= hash_buf
->salt
;
14167 char *salt_pos
= input_buf
;
14169 char *hash_pos
= strchr (salt_pos
, '$');
14171 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14173 uint salt_len
= hash_pos
- salt_pos
;
14175 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14179 uint hash_len
= input_len
- 1 - salt_len
;
14181 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14189 for (uint i
= 0; i
< salt_len
; i
++)
14191 if (salt_pos
[i
] == ' ') continue;
14196 // SAP user names cannot be longer than 12 characters
14197 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14199 // SAP user name cannot start with ! or ?
14200 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14206 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14208 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14210 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14212 salt
->salt_len
= salt_len
;
14214 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
14215 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
14219 digest
[0] = byte_swap_32 (digest
[0]);
14220 digest
[1] = byte_swap_32 (digest
[1]);
14222 return (PARSER_OK
);
14225 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14227 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
14229 u32
*digest
= (u32
*) hash_buf
->digest
;
14231 salt_t
*salt
= hash_buf
->salt
;
14237 char *salt_pos
= input_buf
;
14239 char *hash_pos
= strchr (salt_pos
, '$');
14241 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14243 uint salt_len
= hash_pos
- salt_pos
;
14245 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14249 uint hash_len
= input_len
- 1 - salt_len
;
14251 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
14259 for (uint i
= 0; i
< salt_len
; i
++)
14261 if (salt_pos
[i
] == ' ') continue;
14266 // SAP user names cannot be longer than 12 characters
14267 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
14268 // so far nobody complained so we stay with this because it helps in optimization
14269 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
14271 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14273 // SAP user name cannot start with ! or ?
14274 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14280 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14282 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14284 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14286 salt
->salt_len
= salt_len
;
14288 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14289 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14290 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14291 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14292 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14294 return (PARSER_OK
);
14297 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14299 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
14301 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14303 u64
*digest
= (u64
*) hash_buf
->digest
;
14305 salt_t
*salt
= hash_buf
->salt
;
14307 char *iter_pos
= input_buf
+ 3;
14309 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
14311 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
14313 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
14315 salt
->salt_iter
= salt_iter
;
14317 char *salt_pos
= iter_pos
+ 1;
14321 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
14323 salt
->salt_len
= salt_len
;
14325 char *hash_pos
= salt_pos
+ salt_len
;
14327 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14331 char *tmp
= (char *) salt
->salt_buf_pc
;
14333 tmp
[0] = hash_pos
[42];
14337 digest
[ 0] = byte_swap_64 (digest
[ 0]);
14338 digest
[ 1] = byte_swap_64 (digest
[ 1]);
14339 digest
[ 2] = byte_swap_64 (digest
[ 2]);
14340 digest
[ 3] = byte_swap_64 (digest
[ 3]);
14346 return (PARSER_OK
);
14349 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14351 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
14353 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14355 u32
*digest
= (u32
*) hash_buf
->digest
;
14357 salt_t
*salt
= hash_buf
->salt
;
14359 char *salt_buf
= input_buf
+ 6;
14361 uint salt_len
= 16;
14363 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14365 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14367 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14369 salt
->salt_len
= salt_len
;
14371 char *hash_pos
= input_buf
+ 6 + 16;
14373 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14374 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14375 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14376 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14377 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14378 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
14379 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
14380 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
14382 return (PARSER_OK
);
14385 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14387 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
14389 u32
*digest
= (u32
*) hash_buf
->digest
;
14391 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14392 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14396 return (PARSER_OK
);
14399 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14401 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
14403 u32
*digest
= (u32
*) hash_buf
->digest
;
14405 salt_t
*salt
= hash_buf
->salt
;
14407 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
14409 char *saltbuf_pos
= input_buf
;
14411 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
14413 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14415 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14417 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14418 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14420 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14424 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14426 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14428 char *salt_ptr
= (char *) saltbuf_pos
;
14429 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14434 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14436 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14439 rakp_ptr
[j
] = 0x80;
14441 rakp
->salt_len
= j
;
14443 for (i
= 0; i
< 64; i
++)
14445 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14448 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14449 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14450 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14451 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14452 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14453 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14454 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14455 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14457 salt
->salt_len
= 32; // muss min. 32 haben
14459 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14460 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14461 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14462 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14463 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14465 return (PARSER_OK
);
14468 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14470 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14472 u32
*digest
= (u32
*) hash_buf
->digest
;
14474 salt_t
*salt
= hash_buf
->salt
;
14476 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14478 char *salt_pos
= input_buf
+ 1;
14480 memcpy (salt
->salt_buf
, salt_pos
, 8);
14482 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14483 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14485 salt
->salt_len
= 8;
14487 char *hash_pos
= salt_pos
+ 8;
14489 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14490 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14491 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14492 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14493 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14495 digest
[0] -= SHA1M_A
;
14496 digest
[1] -= SHA1M_B
;
14497 digest
[2] -= SHA1M_C
;
14498 digest
[3] -= SHA1M_D
;
14499 digest
[4] -= SHA1M_E
;
14501 return (PARSER_OK
);
14504 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14506 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14508 u32
*digest
= (u32
*) hash_buf
->digest
;
14510 salt_t
*salt
= hash_buf
->salt
;
14512 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14513 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14514 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14515 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14517 digest
[0] = byte_swap_32 (digest
[0]);
14518 digest
[1] = byte_swap_32 (digest
[1]);
14519 digest
[2] = byte_swap_32 (digest
[2]);
14520 digest
[3] = byte_swap_32 (digest
[3]);
14522 digest
[0] -= MD5M_A
;
14523 digest
[1] -= MD5M_B
;
14524 digest
[2] -= MD5M_C
;
14525 digest
[3] -= MD5M_D
;
14527 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14529 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14531 u32
*salt_buf
= salt
->salt_buf
;
14533 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14534 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14535 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14536 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14538 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14539 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14540 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14541 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14543 salt
->salt_len
= 16 + 1;
14545 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14547 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14549 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14551 return (PARSER_OK
);
14554 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14556 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14558 u32
*digest
= (u32
*) hash_buf
->digest
;
14560 salt_t
*salt
= hash_buf
->salt
;
14562 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14568 char *hashbuf_pos
= input_buf
;
14570 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14572 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14574 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14576 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14580 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14582 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14584 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14586 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14590 char *databuf_pos
= strchr (iteration_pos
, ':');
14592 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14594 const uint iteration_len
= databuf_pos
- iteration_pos
;
14596 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14597 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14599 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14601 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14602 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14608 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14609 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14610 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14611 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14612 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14613 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14614 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14615 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14619 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14621 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14623 const char p0
= saltbuf_pos
[i
+ 0];
14624 const char p1
= saltbuf_pos
[i
+ 1];
14626 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14627 | hex_convert (p0
) << 4;
14630 salt
->salt_buf
[4] = 0x01000000;
14631 salt
->salt_buf
[5] = 0x80;
14633 salt
->salt_len
= saltbuf_len
/ 2;
14637 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14641 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14643 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14645 const char p0
= databuf_pos
[i
+ 0];
14646 const char p1
= databuf_pos
[i
+ 1];
14648 *databuf_ptr
++ = hex_convert (p1
) << 0
14649 | hex_convert (p0
) << 4;
14652 *databuf_ptr
++ = 0x80;
14654 for (uint i
= 0; i
< 512; i
++)
14656 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14659 cloudkey
->data_len
= databuf_len
/ 2;
14661 return (PARSER_OK
);
14664 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14666 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14668 u32
*digest
= (u32
*) hash_buf
->digest
;
14670 salt_t
*salt
= hash_buf
->salt
;
14676 char *hashbuf_pos
= input_buf
;
14678 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14680 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14682 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14684 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14688 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14690 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14692 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14694 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14696 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14700 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14702 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14704 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14706 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14708 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14712 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14714 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14715 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14717 // ok, the plan for this algorithm is the following:
14718 // we have 2 salts here, the domain-name and a random salt
14719 // while both are used in the initial transformation,
14720 // only the random salt is used in the following iterations
14721 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14722 // and one that includes only the real salt (stored into salt_buf[]).
14723 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14725 u8 tmp_buf
[100] = { 0 };
14727 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14729 memcpy (digest
, tmp_buf
, 20);
14731 digest
[0] = byte_swap_32 (digest
[0]);
14732 digest
[1] = byte_swap_32 (digest
[1]);
14733 digest
[2] = byte_swap_32 (digest
[2]);
14734 digest
[3] = byte_swap_32 (digest
[3]);
14735 digest
[4] = byte_swap_32 (digest
[4]);
14739 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14741 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14743 char *len_ptr
= NULL
;
14745 for (uint i
= 0; i
< domainbuf_len
; i
++)
14747 if (salt_buf_pc_ptr
[i
] == '.')
14749 len_ptr
= &salt_buf_pc_ptr
[i
];
14759 salt
->salt_buf_pc
[7] = domainbuf_len
;
14763 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14765 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14767 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14769 salt
->salt_len
= salt_len
;
14773 salt
->salt_iter
= atoi (iteration_pos
);
14775 return (PARSER_OK
);
14778 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14780 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14782 u32
*digest
= (u32
*) hash_buf
->digest
;
14784 salt_t
*salt
= hash_buf
->salt
;
14786 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14787 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14788 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14789 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14790 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14792 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14794 uint salt_len
= input_len
- 40 - 1;
14796 char *salt_buf
= input_buf
+ 40 + 1;
14798 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14800 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14802 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14804 salt
->salt_len
= salt_len
;
14806 return (PARSER_OK
);
14809 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14811 const u8 ascii_to_ebcdic
[] =
14813 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14814 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14815 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14816 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14817 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14818 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14819 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14820 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14821 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14822 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14823 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14824 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14825 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14826 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14827 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14828 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14831 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14833 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14835 u32
*digest
= (u32
*) hash_buf
->digest
;
14837 salt_t
*salt
= hash_buf
->salt
;
14839 char *salt_pos
= input_buf
+ 6 + 1;
14841 char *digest_pos
= strchr (salt_pos
, '*');
14843 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14845 uint salt_len
= digest_pos
- salt_pos
;
14847 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14849 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14851 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14855 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14856 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14858 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14860 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14862 salt
->salt_len
= salt_len
;
14864 for (uint i
= 0; i
< salt_len
; i
++)
14866 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14868 for (uint i
= salt_len
; i
< 8; i
++)
14870 salt_buf_pc_ptr
[i
] = 0x40;
14875 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14877 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14878 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14880 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14881 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14883 digest
[0] = byte_swap_32 (digest
[0]);
14884 digest
[1] = byte_swap_32 (digest
[1]);
14886 IP (digest
[0], digest
[1], tt
);
14888 digest
[0] = rotr32 (digest
[0], 29);
14889 digest
[1] = rotr32 (digest
[1], 29);
14893 return (PARSER_OK
);
14896 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14898 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14900 u32
*digest
= (u32
*) hash_buf
->digest
;
14902 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14903 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14904 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14905 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14907 digest
[0] = byte_swap_32 (digest
[0]);
14908 digest
[1] = byte_swap_32 (digest
[1]);
14909 digest
[2] = byte_swap_32 (digest
[2]);
14910 digest
[3] = byte_swap_32 (digest
[3]);
14912 return (PARSER_OK
);
14915 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14917 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14919 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14921 u32
*digest
= (u32
*) hash_buf
->digest
;
14923 salt_t
*salt
= hash_buf
->salt
;
14925 u8 tmp_buf
[120] = { 0 };
14927 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14929 tmp_buf
[3] += -4; // dont ask!
14931 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14933 salt
->salt_len
= 5;
14935 memcpy (digest
, tmp_buf
+ 5, 9);
14937 // yes, only 9 byte are needed to crack, but 10 to display
14939 salt
->salt_buf_pc
[7] = input_buf
[20];
14941 return (PARSER_OK
);
14944 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14946 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14948 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14950 u32
*digest
= (u32
*) hash_buf
->digest
;
14952 salt_t
*salt
= hash_buf
->salt
;
14954 u8 tmp_buf
[120] = { 0 };
14956 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14958 tmp_buf
[3] += -4; // dont ask!
14962 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14964 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)
14968 char tmp_iter_buf
[11] = { 0 };
14970 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14972 tmp_iter_buf
[10] = 0;
14974 salt
->salt_iter
= atoi (tmp_iter_buf
);
14976 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14978 return (PARSER_SALT_ITERATION
);
14981 salt
->salt_iter
--; // first round in init
14983 // 2 additional bytes for display only
14985 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14986 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14990 memcpy (digest
, tmp_buf
+ 28, 8);
14992 digest
[0] = byte_swap_32 (digest
[0]);
14993 digest
[1] = byte_swap_32 (digest
[1]);
14997 return (PARSER_OK
);
15000 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15002 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
15004 u32
*digest
= (u32
*) hash_buf
->digest
;
15006 salt_t
*salt
= hash_buf
->salt
;
15008 char *salt_buf_pos
= input_buf
;
15010 char *hash_buf_pos
= salt_buf_pos
+ 6;
15012 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
15013 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
15014 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
15015 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
15016 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
15017 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
15018 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
15019 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
15021 digest
[0] -= SHA256M_A
;
15022 digest
[1] -= SHA256M_B
;
15023 digest
[2] -= SHA256M_C
;
15024 digest
[3] -= SHA256M_D
;
15025 digest
[4] -= SHA256M_E
;
15026 digest
[5] -= SHA256M_F
;
15027 digest
[6] -= SHA256M_G
;
15028 digest
[7] -= SHA256M_H
;
15030 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15032 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
15034 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15036 salt
->salt_len
= salt_len
;
15038 return (PARSER_OK
);
15041 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15043 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
15045 u32
*digest
= (u32
*) hash_buf
->digest
;
15047 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15049 salt_t
*salt
= hash_buf
->salt
;
15051 char *salt_buf
= input_buf
+ 6;
15053 char *digest_buf
= strchr (salt_buf
, '$');
15055 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15057 uint salt_len
= digest_buf
- salt_buf
;
15059 digest_buf
++; // skip the '$' symbol
15061 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15063 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15065 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15067 salt
->salt_len
= salt_len
;
15069 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15070 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15071 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15072 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15074 digest
[0] = byte_swap_32 (digest
[0]);
15075 digest
[1] = byte_swap_32 (digest
[1]);
15076 digest
[2] = byte_swap_32 (digest
[2]);
15077 digest
[3] = byte_swap_32 (digest
[3]);
15079 digest
[0] -= MD5M_A
;
15080 digest
[1] -= MD5M_B
;
15081 digest
[2] -= MD5M_C
;
15082 digest
[3] -= MD5M_D
;
15084 return (PARSER_OK
);
15087 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15089 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
15091 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15093 u32
*digest
= (u32
*) hash_buf
->digest
;
15095 salt_t
*salt
= hash_buf
->salt
;
15097 char *salt_buf
= input_buf
+ 3;
15099 char *digest_buf
= strchr (salt_buf
, '$');
15101 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15103 uint salt_len
= digest_buf
- salt_buf
;
15105 digest_buf
++; // skip the '$' symbol
15107 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15109 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15111 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15113 salt_buf_ptr
[salt_len
] = 0x2d;
15115 salt
->salt_len
= salt_len
+ 1;
15117 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15118 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15119 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15120 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15122 digest
[0] = byte_swap_32 (digest
[0]);
15123 digest
[1] = byte_swap_32 (digest
[1]);
15124 digest
[2] = byte_swap_32 (digest
[2]);
15125 digest
[3] = byte_swap_32 (digest
[3]);
15127 digest
[0] -= MD5M_A
;
15128 digest
[1] -= MD5M_B
;
15129 digest
[2] -= MD5M_C
;
15130 digest
[3] -= MD5M_D
;
15132 return (PARSER_OK
);
15135 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15137 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
15139 u32
*digest
= (u32
*) hash_buf
->digest
;
15141 salt_t
*salt
= hash_buf
->salt
;
15143 u8 tmp_buf
[100] = { 0 };
15145 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
15147 memcpy (digest
, tmp_buf
, 20);
15149 digest
[0] = byte_swap_32 (digest
[0]);
15150 digest
[1] = byte_swap_32 (digest
[1]);
15151 digest
[2] = byte_swap_32 (digest
[2]);
15152 digest
[3] = byte_swap_32 (digest
[3]);
15153 digest
[4] = byte_swap_32 (digest
[4]);
15155 digest
[0] -= SHA1M_A
;
15156 digest
[1] -= SHA1M_B
;
15157 digest
[2] -= SHA1M_C
;
15158 digest
[3] -= SHA1M_D
;
15159 digest
[4] -= SHA1M_E
;
15161 salt
->salt_buf
[0] = 0x80;
15163 salt
->salt_len
= 0;
15165 return (PARSER_OK
);
15168 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15170 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
15172 u32
*digest
= (u32
*) hash_buf
->digest
;
15174 salt_t
*salt
= hash_buf
->salt
;
15176 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15177 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15178 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15179 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15181 digest
[0] = byte_swap_32 (digest
[0]);
15182 digest
[1] = byte_swap_32 (digest
[1]);
15183 digest
[2] = byte_swap_32 (digest
[2]);
15184 digest
[3] = byte_swap_32 (digest
[3]);
15186 digest
[0] -= MD5M_A
;
15187 digest
[1] -= MD5M_B
;
15188 digest
[2] -= MD5M_C
;
15189 digest
[3] -= MD5M_D
;
15191 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15193 uint salt_len
= input_len
- 32 - 1;
15195 char *salt_buf
= input_buf
+ 32 + 1;
15197 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15199 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15201 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15204 * add static "salt" part
15207 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
15211 salt
->salt_len
= salt_len
;
15213 return (PARSER_OK
);
15216 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15218 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
15220 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
15222 u32
*digest
= (u32
*) hash_buf
->digest
;
15224 salt_t
*salt
= hash_buf
->salt
;
15226 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
15232 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
15234 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
15236 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15238 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
15240 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
15244 char *keylen_pos
= strchr (saltbuf_pos
, '$');
15246 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15248 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
15250 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15254 char *keybuf_pos
= strchr (keylen_pos
, '$');
15256 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15258 uint keylen_len
= keybuf_pos
- keylen_pos
;
15260 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
15264 char *databuf_pos
= strchr (keybuf_pos
, '$');
15266 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15268 uint keybuf_len
= databuf_pos
- keybuf_pos
;
15270 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15274 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
15276 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
15282 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
15283 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
15284 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
15285 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
15287 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
15288 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
15289 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
15290 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
15292 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15293 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15294 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15295 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15297 salt
->salt_len
= 16;
15298 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
15300 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
15302 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
15305 return (PARSER_OK
);
15308 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15310 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
15312 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15314 u32
*digest
= (u32
*) hash_buf
->digest
;
15316 salt_t
*salt
= hash_buf
->salt
;
15322 // first is the N salt parameter
15324 char *N_pos
= input_buf
+ 6;
15326 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15330 salt
->scrypt_N
= atoi (N_pos
);
15334 char *r_pos
= strchr (N_pos
, ':');
15336 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15340 salt
->scrypt_r
= atoi (r_pos
);
15344 char *p_pos
= strchr (r_pos
, ':');
15346 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15350 salt
->scrypt_p
= atoi (p_pos
);
15354 char *saltbuf_pos
= strchr (p_pos
, ':');
15356 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15360 char *hash_pos
= strchr (saltbuf_pos
, ':');
15362 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15368 int salt_len_base64
= hash_pos
- saltbuf_pos
;
15370 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
15372 u8 tmp_buf
[33] = { 0 };
15374 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
15376 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15378 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
15380 salt
->salt_len
= tmp_len
;
15381 salt
->salt_iter
= 1;
15383 // digest - base64 decode
15385 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15387 tmp_len
= input_len
- (hash_pos
- input_buf
);
15389 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
15391 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
15393 memcpy (digest
, tmp_buf
, 32);
15395 return (PARSER_OK
);
15398 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15400 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
15402 u32
*digest
= (u32
*) hash_buf
->digest
;
15404 salt_t
*salt
= hash_buf
->salt
;
15410 char decrypted
[76] = { 0 }; // iv + hash
15412 juniper_decrypt_hash (input_buf
, decrypted
);
15414 char *md5crypt_hash
= decrypted
+ 12;
15416 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15418 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15420 char *salt_pos
= md5crypt_hash
+ 3;
15422 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15424 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15426 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15430 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15432 return (PARSER_OK
);
15435 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15437 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15439 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15441 u32
*digest
= (u32
*) hash_buf
->digest
;
15443 salt_t
*salt
= hash_buf
->salt
;
15445 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15451 // first is *raw* salt
15453 char *salt_pos
= input_buf
+ 3;
15455 char *hash_pos
= strchr (salt_pos
, '$');
15457 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15459 uint salt_len
= hash_pos
- salt_pos
;
15461 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15465 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15467 memcpy (salt_buf_ptr
, salt_pos
, 14);
15469 salt_buf_ptr
[17] = 0x01;
15470 salt_buf_ptr
[18] = 0x80;
15472 // add some stuff to normal salt to make sorted happy
15474 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15475 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15476 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15477 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15479 salt
->salt_len
= salt_len
;
15480 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15482 // base64 decode hash
15484 u8 tmp_buf
[100] = { 0 };
15486 uint hash_len
= input_len
- 3 - salt_len
- 1;
15488 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15490 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15492 memcpy (digest
, tmp_buf
, 32);
15494 digest
[0] = byte_swap_32 (digest
[0]);
15495 digest
[1] = byte_swap_32 (digest
[1]);
15496 digest
[2] = byte_swap_32 (digest
[2]);
15497 digest
[3] = byte_swap_32 (digest
[3]);
15498 digest
[4] = byte_swap_32 (digest
[4]);
15499 digest
[5] = byte_swap_32 (digest
[5]);
15500 digest
[6] = byte_swap_32 (digest
[6]);
15501 digest
[7] = byte_swap_32 (digest
[7]);
15503 return (PARSER_OK
);
15506 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15508 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15510 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15512 u32
*digest
= (u32
*) hash_buf
->digest
;
15514 salt_t
*salt
= hash_buf
->salt
;
15520 // first is *raw* salt
15522 char *salt_pos
= input_buf
+ 3;
15524 char *hash_pos
= strchr (salt_pos
, '$');
15526 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15528 uint salt_len
= hash_pos
- salt_pos
;
15530 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15532 salt
->salt_len
= salt_len
;
15535 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15537 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15538 salt_buf_ptr
[salt_len
] = 0;
15540 // base64 decode hash
15542 u8 tmp_buf
[100] = { 0 };
15544 uint hash_len
= input_len
- 3 - salt_len
- 1;
15546 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15548 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15550 memcpy (digest
, tmp_buf
, 32);
15553 salt
->scrypt_N
= 16384;
15554 salt
->scrypt_r
= 1;
15555 salt
->scrypt_p
= 1;
15556 salt
->salt_iter
= 1;
15558 return (PARSER_OK
);
15561 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15563 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15565 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15567 u32
*digest
= (u32
*) hash_buf
->digest
;
15569 salt_t
*salt
= hash_buf
->salt
;
15571 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15577 char *version_pos
= input_buf
+ 8 + 1;
15579 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15581 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15583 u32 version_len
= verifierHashSize_pos
- version_pos
;
15585 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15587 verifierHashSize_pos
++;
15589 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15591 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15593 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15595 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15599 char *saltSize_pos
= strchr (keySize_pos
, '*');
15601 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15603 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15605 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15609 char *osalt_pos
= strchr (saltSize_pos
, '*');
15611 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15613 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15615 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15619 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15621 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15623 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15625 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15627 encryptedVerifier_pos
++;
15629 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15631 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15633 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15635 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15637 encryptedVerifierHash_pos
++;
15639 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;
15641 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15643 const uint version
= atoi (version_pos
);
15645 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15647 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15649 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15651 const uint keySize
= atoi (keySize_pos
);
15653 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15655 office2007
->keySize
= keySize
;
15657 const uint saltSize
= atoi (saltSize_pos
);
15659 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15665 salt
->salt_len
= 16;
15666 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15668 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15669 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15670 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15671 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15677 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15678 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15679 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15680 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15682 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15683 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15684 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15685 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15686 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15692 digest
[0] = office2007
->encryptedVerifierHash
[0];
15693 digest
[1] = office2007
->encryptedVerifierHash
[1];
15694 digest
[2] = office2007
->encryptedVerifierHash
[2];
15695 digest
[3] = office2007
->encryptedVerifierHash
[3];
15697 return (PARSER_OK
);
15700 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15702 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15704 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15706 u32
*digest
= (u32
*) hash_buf
->digest
;
15708 salt_t
*salt
= hash_buf
->salt
;
15710 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15716 char *version_pos
= input_buf
+ 8 + 1;
15718 char *spinCount_pos
= strchr (version_pos
, '*');
15720 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15722 u32 version_len
= spinCount_pos
- version_pos
;
15724 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15728 char *keySize_pos
= strchr (spinCount_pos
, '*');
15730 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15732 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15734 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15738 char *saltSize_pos
= strchr (keySize_pos
, '*');
15740 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15742 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15744 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15748 char *osalt_pos
= strchr (saltSize_pos
, '*');
15750 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15752 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15754 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15758 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15760 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15762 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15764 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15766 encryptedVerifier_pos
++;
15768 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15770 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15772 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15774 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15776 encryptedVerifierHash_pos
++;
15778 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;
15780 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15782 const uint version
= atoi (version_pos
);
15784 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15786 const uint spinCount
= atoi (spinCount_pos
);
15788 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15790 const uint keySize
= atoi (keySize_pos
);
15792 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15794 const uint saltSize
= atoi (saltSize_pos
);
15796 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15802 salt
->salt_len
= 16;
15803 salt
->salt_iter
= spinCount
;
15805 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15806 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15807 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15808 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15814 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15815 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15816 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15817 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15819 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15820 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15821 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15822 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15823 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15824 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15825 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15826 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15832 digest
[0] = office2010
->encryptedVerifierHash
[0];
15833 digest
[1] = office2010
->encryptedVerifierHash
[1];
15834 digest
[2] = office2010
->encryptedVerifierHash
[2];
15835 digest
[3] = office2010
->encryptedVerifierHash
[3];
15837 return (PARSER_OK
);
15840 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15842 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15844 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15846 u32
*digest
= (u32
*) hash_buf
->digest
;
15848 salt_t
*salt
= hash_buf
->salt
;
15850 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15856 char *version_pos
= input_buf
+ 8 + 1;
15858 char *spinCount_pos
= strchr (version_pos
, '*');
15860 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15862 u32 version_len
= spinCount_pos
- version_pos
;
15864 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15868 char *keySize_pos
= strchr (spinCount_pos
, '*');
15870 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15872 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15874 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15878 char *saltSize_pos
= strchr (keySize_pos
, '*');
15880 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15882 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15884 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15888 char *osalt_pos
= strchr (saltSize_pos
, '*');
15890 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15892 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15894 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15898 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15900 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15902 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15904 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15906 encryptedVerifier_pos
++;
15908 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15910 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15912 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15914 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15916 encryptedVerifierHash_pos
++;
15918 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;
15920 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15922 const uint version
= atoi (version_pos
);
15924 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15926 const uint spinCount
= atoi (spinCount_pos
);
15928 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15930 const uint keySize
= atoi (keySize_pos
);
15932 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15934 const uint saltSize
= atoi (saltSize_pos
);
15936 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15942 salt
->salt_len
= 16;
15943 salt
->salt_iter
= spinCount
;
15945 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15946 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15947 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15948 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15954 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15955 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15956 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15957 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15959 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15960 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15961 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15962 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15963 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15964 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15965 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15966 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15972 digest
[0] = office2013
->encryptedVerifierHash
[0];
15973 digest
[1] = office2013
->encryptedVerifierHash
[1];
15974 digest
[2] = office2013
->encryptedVerifierHash
[2];
15975 digest
[3] = office2013
->encryptedVerifierHash
[3];
15977 return (PARSER_OK
);
15980 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15982 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15984 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15986 u32
*digest
= (u32
*) hash_buf
->digest
;
15988 salt_t
*salt
= hash_buf
->salt
;
15990 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15996 char *version_pos
= input_buf
+ 11;
15998 char *osalt_pos
= strchr (version_pos
, '*');
16000 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16002 u32 version_len
= osalt_pos
- version_pos
;
16004 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16008 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16010 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16012 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16014 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16016 encryptedVerifier_pos
++;
16018 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16020 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16022 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16024 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16026 encryptedVerifierHash_pos
++;
16028 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16030 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16032 const uint version
= *version_pos
- 0x30;
16034 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16040 oldoffice01
->version
= version
;
16042 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16043 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16044 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16045 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16047 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16048 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16049 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16050 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16052 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16053 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16054 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16055 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16057 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16058 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16059 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16060 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16066 salt
->salt_len
= 16;
16068 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16069 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16070 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16071 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16073 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16074 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16075 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16076 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16078 // this is a workaround as office produces multiple documents with the same salt
16080 salt
->salt_len
+= 32;
16082 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16083 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16084 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16085 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16086 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16087 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16088 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16089 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16095 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
16096 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
16097 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
16098 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
16100 return (PARSER_OK
);
16103 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16105 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
16108 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16110 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
16112 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16114 u32
*digest
= (u32
*) hash_buf
->digest
;
16116 salt_t
*salt
= hash_buf
->salt
;
16118 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16124 char *version_pos
= input_buf
+ 11;
16126 char *osalt_pos
= strchr (version_pos
, '*');
16128 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16130 u32 version_len
= osalt_pos
- version_pos
;
16132 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16136 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16138 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16140 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16142 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16144 encryptedVerifier_pos
++;
16146 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16148 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16150 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16152 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16154 encryptedVerifierHash_pos
++;
16156 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16158 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16160 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16162 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16166 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16168 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16170 const uint version
= *version_pos
- 0x30;
16172 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16178 oldoffice01
->version
= version
;
16180 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16181 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16182 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16183 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16185 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16186 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16187 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16188 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16190 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16191 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16192 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16193 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16195 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16196 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16197 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16198 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16200 oldoffice01
->rc4key
[1] = 0;
16201 oldoffice01
->rc4key
[0] = 0;
16203 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16204 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16205 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16206 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16207 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16208 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16209 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16210 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16211 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16212 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16214 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
16215 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
16221 salt
->salt_len
= 16;
16223 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16224 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16225 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16226 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16228 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16229 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16230 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16231 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16233 // this is a workaround as office produces multiple documents with the same salt
16235 salt
->salt_len
+= 32;
16237 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16238 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16239 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16240 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16241 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16242 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16243 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16244 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16250 digest
[0] = oldoffice01
->rc4key
[0];
16251 digest
[1] = oldoffice01
->rc4key
[1];
16255 return (PARSER_OK
);
16258 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16260 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
16262 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16264 u32
*digest
= (u32
*) hash_buf
->digest
;
16266 salt_t
*salt
= hash_buf
->salt
;
16268 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16274 char *version_pos
= input_buf
+ 11;
16276 char *osalt_pos
= strchr (version_pos
, '*');
16278 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16280 u32 version_len
= osalt_pos
- version_pos
;
16282 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16286 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16288 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16290 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16292 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16294 encryptedVerifier_pos
++;
16296 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16298 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16300 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16302 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16304 encryptedVerifierHash_pos
++;
16306 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16308 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16310 const uint version
= *version_pos
- 0x30;
16312 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16318 oldoffice34
->version
= version
;
16320 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16321 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16322 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16323 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16325 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16326 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16327 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16328 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16330 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16331 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16332 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16333 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16334 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16336 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16337 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16338 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16339 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16340 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16346 salt
->salt_len
= 16;
16348 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16349 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16350 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16351 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16353 // this is a workaround as office produces multiple documents with the same salt
16355 salt
->salt_len
+= 32;
16357 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16358 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16359 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16360 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16361 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16362 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16363 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16364 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16370 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
16371 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
16372 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
16373 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
16375 return (PARSER_OK
);
16378 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16380 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16382 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
16385 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16387 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
16389 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16391 u32
*digest
= (u32
*) hash_buf
->digest
;
16393 salt_t
*salt
= hash_buf
->salt
;
16395 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16401 char *version_pos
= input_buf
+ 11;
16403 char *osalt_pos
= strchr (version_pos
, '*');
16405 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16407 u32 version_len
= osalt_pos
- version_pos
;
16409 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16413 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16415 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16417 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16419 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16421 encryptedVerifier_pos
++;
16423 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16425 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16427 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16429 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16431 encryptedVerifierHash_pos
++;
16433 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16435 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16437 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16439 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16443 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16445 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16447 const uint version
= *version_pos
- 0x30;
16449 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16455 oldoffice34
->version
= version
;
16457 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16458 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16459 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16460 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16462 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16463 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16464 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16465 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16467 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16468 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16469 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16470 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16471 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16473 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16474 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16475 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16476 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16477 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16479 oldoffice34
->rc4key
[1] = 0;
16480 oldoffice34
->rc4key
[0] = 0;
16482 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16483 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16484 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16485 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16486 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16487 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16488 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16489 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16490 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16491 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16493 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16494 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16500 salt
->salt_len
= 16;
16502 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16503 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16504 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16505 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16507 // this is a workaround as office produces multiple documents with the same salt
16509 salt
->salt_len
+= 32;
16511 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16512 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16513 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16514 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16515 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16516 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16517 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16518 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16524 digest
[0] = oldoffice34
->rc4key
[0];
16525 digest
[1] = oldoffice34
->rc4key
[1];
16529 return (PARSER_OK
);
16532 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16534 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16536 u32
*digest
= (u32
*) hash_buf
->digest
;
16538 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16539 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16540 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16541 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16543 digest
[0] = byte_swap_32 (digest
[0]);
16544 digest
[1] = byte_swap_32 (digest
[1]);
16545 digest
[2] = byte_swap_32 (digest
[2]);
16546 digest
[3] = byte_swap_32 (digest
[3]);
16548 return (PARSER_OK
);
16551 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16553 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16555 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16557 u32
*digest
= (u32
*) hash_buf
->digest
;
16559 salt_t
*salt
= hash_buf
->salt
;
16561 char *signature_pos
= input_buf
;
16563 char *salt_pos
= strchr (signature_pos
, '$');
16565 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16567 u32 signature_len
= salt_pos
- signature_pos
;
16569 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16573 char *hash_pos
= strchr (salt_pos
, '$');
16575 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16577 u32 salt_len
= hash_pos
- salt_pos
;
16579 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16583 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16585 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16587 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16588 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16589 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16590 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16591 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16593 digest
[0] -= SHA1M_A
;
16594 digest
[1] -= SHA1M_B
;
16595 digest
[2] -= SHA1M_C
;
16596 digest
[3] -= SHA1M_D
;
16597 digest
[4] -= SHA1M_E
;
16599 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16601 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16603 salt
->salt_len
= salt_len
;
16605 return (PARSER_OK
);
16608 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16610 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16612 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16614 u32
*digest
= (u32
*) hash_buf
->digest
;
16616 salt_t
*salt
= hash_buf
->salt
;
16618 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16624 char *iter_pos
= input_buf
+ 14;
16626 const int iter
= atoi (iter_pos
);
16628 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16630 salt
->salt_iter
= iter
- 1;
16632 char *salt_pos
= strchr (iter_pos
, '$');
16634 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16638 char *hash_pos
= strchr (salt_pos
, '$');
16640 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16642 const uint salt_len
= hash_pos
- salt_pos
;
16646 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16648 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16650 salt
->salt_len
= salt_len
;
16652 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16653 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16655 // add some stuff to normal salt to make sorted happy
16657 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16658 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16659 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16660 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16661 salt
->salt_buf
[4] = salt
->salt_iter
;
16663 // base64 decode hash
16665 u8 tmp_buf
[100] = { 0 };
16667 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16669 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16671 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16673 memcpy (digest
, tmp_buf
, 32);
16675 digest
[0] = byte_swap_32 (digest
[0]);
16676 digest
[1] = byte_swap_32 (digest
[1]);
16677 digest
[2] = byte_swap_32 (digest
[2]);
16678 digest
[3] = byte_swap_32 (digest
[3]);
16679 digest
[4] = byte_swap_32 (digest
[4]);
16680 digest
[5] = byte_swap_32 (digest
[5]);
16681 digest
[6] = byte_swap_32 (digest
[6]);
16682 digest
[7] = byte_swap_32 (digest
[7]);
16684 return (PARSER_OK
);
16687 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16689 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16691 u32
*digest
= (u32
*) hash_buf
->digest
;
16693 salt_t
*salt
= hash_buf
->salt
;
16695 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16696 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16700 digest
[0] = byte_swap_32 (digest
[0]);
16701 digest
[1] = byte_swap_32 (digest
[1]);
16703 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16704 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16705 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16707 char iter_c
= input_buf
[17];
16708 char iter_d
= input_buf
[19];
16710 // atm only defaults, let's see if there's more request
16711 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16712 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16714 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16716 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16717 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16718 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16719 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16721 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16722 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16723 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16724 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16726 salt
->salt_len
= 16;
16728 return (PARSER_OK
);
16731 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16733 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16735 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16737 u32
*digest
= (u32
*) hash_buf
->digest
;
16739 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16741 salt_t
*salt
= hash_buf
->salt
;
16743 char *salt_pos
= input_buf
+ 10;
16745 char *hash_pos
= strchr (salt_pos
, '$');
16747 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16749 uint salt_len
= hash_pos
- salt_pos
;
16753 uint hash_len
= input_len
- 10 - salt_len
- 1;
16755 // base64 decode salt
16757 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16759 u8 tmp_buf
[100] = { 0 };
16761 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16763 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16765 tmp_buf
[salt_len
] = 0x80;
16767 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16769 salt
->salt_len
= salt_len
;
16771 // base64 decode hash
16773 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16775 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16777 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16779 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16781 uint user_len
= hash_len
- 32;
16783 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16785 user_len
--; // skip the trailing space
16787 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16788 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16789 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16790 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16792 digest
[0] = byte_swap_32 (digest
[0]);
16793 digest
[1] = byte_swap_32 (digest
[1]);
16794 digest
[2] = byte_swap_32 (digest
[2]);
16795 digest
[3] = byte_swap_32 (digest
[3]);
16797 // store username for host only (output hash if cracked)
16799 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16800 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16802 return (PARSER_OK
);
16805 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16807 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16809 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16811 u32
*digest
= (u32
*) hash_buf
->digest
;
16813 salt_t
*salt
= hash_buf
->salt
;
16815 char *iter_pos
= input_buf
+ 10;
16817 u32 iter
= atoi (iter_pos
);
16821 return (PARSER_SALT_ITERATION
);
16824 iter
--; // first iteration is special
16826 salt
->salt_iter
= iter
;
16828 char *base64_pos
= strchr (iter_pos
, '}');
16830 if (base64_pos
== NULL
)
16832 return (PARSER_SIGNATURE_UNMATCHED
);
16837 // base64 decode salt
16839 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16841 u8 tmp_buf
[100] = { 0 };
16843 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16845 if (decoded_len
< 24)
16847 return (PARSER_SALT_LENGTH
);
16852 uint salt_len
= decoded_len
- 20;
16854 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16855 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16857 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16859 salt
->salt_len
= salt_len
;
16863 u32
*digest_ptr
= (u32
*) tmp_buf
;
16865 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16866 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16867 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16868 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16869 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16871 return (PARSER_OK
);
16874 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16876 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16878 u32
*digest
= (u32
*) hash_buf
->digest
;
16880 salt_t
*salt
= hash_buf
->salt
;
16882 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16883 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16884 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16885 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16886 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16888 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16890 uint salt_len
= input_len
- 40 - 1;
16892 char *salt_buf
= input_buf
+ 40 + 1;
16894 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16896 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16898 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16900 salt
->salt_len
= salt_len
;
16902 return (PARSER_OK
);
16905 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16907 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16909 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16911 u32
*digest
= (u32
*) hash_buf
->digest
;
16913 salt_t
*salt
= hash_buf
->salt
;
16915 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16921 char *V_pos
= input_buf
+ 5;
16923 char *R_pos
= strchr (V_pos
, '*');
16925 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16927 u32 V_len
= R_pos
- V_pos
;
16931 char *bits_pos
= strchr (R_pos
, '*');
16933 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16935 u32 R_len
= bits_pos
- R_pos
;
16939 char *P_pos
= strchr (bits_pos
, '*');
16941 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16943 u32 bits_len
= P_pos
- bits_pos
;
16947 char *enc_md_pos
= strchr (P_pos
, '*');
16949 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16951 u32 P_len
= enc_md_pos
- P_pos
;
16955 char *id_len_pos
= strchr (enc_md_pos
, '*');
16957 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16959 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16963 char *id_buf_pos
= strchr (id_len_pos
, '*');
16965 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16967 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16971 char *u_len_pos
= strchr (id_buf_pos
, '*');
16973 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16975 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16977 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16981 char *u_buf_pos
= strchr (u_len_pos
, '*');
16983 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16985 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16989 char *o_len_pos
= strchr (u_buf_pos
, '*');
16991 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16993 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16995 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16999 char *o_buf_pos
= strchr (o_len_pos
, '*');
17001 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17003 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17007 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;
17009 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17013 const int V
= atoi (V_pos
);
17014 const int R
= atoi (R_pos
);
17015 const int P
= atoi (P_pos
);
17017 if (V
!= 1) return (PARSER_SALT_VALUE
);
17018 if (R
!= 2) return (PARSER_SALT_VALUE
);
17020 const int enc_md
= atoi (enc_md_pos
);
17022 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17024 const int id_len
= atoi (id_len_pos
);
17025 const int u_len
= atoi (u_len_pos
);
17026 const int o_len
= atoi (o_len_pos
);
17028 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17029 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17030 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17032 const int bits
= atoi (bits_pos
);
17034 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17036 // copy data to esalt
17042 pdf
->enc_md
= enc_md
;
17044 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17045 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17046 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17047 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17048 pdf
->id_len
= id_len
;
17050 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17051 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17052 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17053 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17054 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17055 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17056 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17057 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17058 pdf
->u_len
= u_len
;
17060 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17061 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17062 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17063 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17064 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17065 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17066 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17067 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17068 pdf
->o_len
= o_len
;
17070 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17071 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17072 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17073 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17075 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17076 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17077 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17078 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17079 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17080 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17081 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17082 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17084 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17085 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17086 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17087 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17088 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17089 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17090 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17091 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17093 // we use ID for salt, maybe needs to change, we will see...
17095 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17096 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17097 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17098 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17099 salt
->salt_len
= pdf
->id_len
;
17101 digest
[0] = pdf
->u_buf
[0];
17102 digest
[1] = pdf
->u_buf
[1];
17103 digest
[2] = pdf
->u_buf
[2];
17104 digest
[3] = pdf
->u_buf
[3];
17106 return (PARSER_OK
);
17109 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17111 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
17114 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17116 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
17118 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17120 u32
*digest
= (u32
*) hash_buf
->digest
;
17122 salt_t
*salt
= hash_buf
->salt
;
17124 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17130 char *V_pos
= input_buf
+ 5;
17132 char *R_pos
= strchr (V_pos
, '*');
17134 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17136 u32 V_len
= R_pos
- V_pos
;
17140 char *bits_pos
= strchr (R_pos
, '*');
17142 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17144 u32 R_len
= bits_pos
- R_pos
;
17148 char *P_pos
= strchr (bits_pos
, '*');
17150 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17152 u32 bits_len
= P_pos
- bits_pos
;
17156 char *enc_md_pos
= strchr (P_pos
, '*');
17158 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17160 u32 P_len
= enc_md_pos
- P_pos
;
17164 char *id_len_pos
= strchr (enc_md_pos
, '*');
17166 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17168 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17172 char *id_buf_pos
= strchr (id_len_pos
, '*');
17174 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17176 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17180 char *u_len_pos
= strchr (id_buf_pos
, '*');
17182 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17184 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17186 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17190 char *u_buf_pos
= strchr (u_len_pos
, '*');
17192 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17194 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17198 char *o_len_pos
= strchr (u_buf_pos
, '*');
17200 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17202 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17204 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17208 char *o_buf_pos
= strchr (o_len_pos
, '*');
17210 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17212 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17216 char *rc4key_pos
= strchr (o_buf_pos
, ':');
17218 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17220 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
17222 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17226 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;
17228 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
17232 const int V
= atoi (V_pos
);
17233 const int R
= atoi (R_pos
);
17234 const int P
= atoi (P_pos
);
17236 if (V
!= 1) return (PARSER_SALT_VALUE
);
17237 if (R
!= 2) return (PARSER_SALT_VALUE
);
17239 const int enc_md
= atoi (enc_md_pos
);
17241 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17243 const int id_len
= atoi (id_len_pos
);
17244 const int u_len
= atoi (u_len_pos
);
17245 const int o_len
= atoi (o_len_pos
);
17247 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17248 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17249 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17251 const int bits
= atoi (bits_pos
);
17253 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17255 // copy data to esalt
17261 pdf
->enc_md
= enc_md
;
17263 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17264 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17265 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17266 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17267 pdf
->id_len
= id_len
;
17269 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17270 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17271 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17272 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17273 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17274 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17275 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17276 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17277 pdf
->u_len
= u_len
;
17279 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17280 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17281 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17282 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17283 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17284 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17285 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17286 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17287 pdf
->o_len
= o_len
;
17289 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17290 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17291 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17292 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17294 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17295 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17296 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17297 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17298 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17299 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17300 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17301 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17303 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17304 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17305 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17306 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17307 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17308 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17309 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17310 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17312 pdf
->rc4key
[1] = 0;
17313 pdf
->rc4key
[0] = 0;
17315 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
17316 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
17317 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
17318 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
17319 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
17320 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
17321 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
17322 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
17323 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
17324 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
17326 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
17327 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
17329 // we use ID for salt, maybe needs to change, we will see...
17331 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17332 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17333 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17334 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17335 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17336 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17337 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17338 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17339 salt
->salt_len
= pdf
->id_len
+ 16;
17341 digest
[0] = pdf
->rc4key
[0];
17342 digest
[1] = pdf
->rc4key
[1];
17346 return (PARSER_OK
);
17349 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17351 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
17353 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17355 u32
*digest
= (u32
*) hash_buf
->digest
;
17357 salt_t
*salt
= hash_buf
->salt
;
17359 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17365 char *V_pos
= input_buf
+ 5;
17367 char *R_pos
= strchr (V_pos
, '*');
17369 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17371 u32 V_len
= R_pos
- V_pos
;
17375 char *bits_pos
= strchr (R_pos
, '*');
17377 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17379 u32 R_len
= bits_pos
- R_pos
;
17383 char *P_pos
= strchr (bits_pos
, '*');
17385 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17387 u32 bits_len
= P_pos
- bits_pos
;
17391 char *enc_md_pos
= strchr (P_pos
, '*');
17393 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17395 u32 P_len
= enc_md_pos
- P_pos
;
17399 char *id_len_pos
= strchr (enc_md_pos
, '*');
17401 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17403 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17407 char *id_buf_pos
= strchr (id_len_pos
, '*');
17409 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17411 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17415 char *u_len_pos
= strchr (id_buf_pos
, '*');
17417 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17419 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17421 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17425 char *u_buf_pos
= strchr (u_len_pos
, '*');
17427 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17429 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17433 char *o_len_pos
= strchr (u_buf_pos
, '*');
17435 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17437 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17439 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17443 char *o_buf_pos
= strchr (o_len_pos
, '*');
17445 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17447 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17451 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;
17453 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17457 const int V
= atoi (V_pos
);
17458 const int R
= atoi (R_pos
);
17459 const int P
= atoi (P_pos
);
17463 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17464 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17466 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17468 const int id_len
= atoi (id_len_pos
);
17469 const int u_len
= atoi (u_len_pos
);
17470 const int o_len
= atoi (o_len_pos
);
17472 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17474 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17475 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17477 const int bits
= atoi (bits_pos
);
17479 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17485 enc_md
= atoi (enc_md_pos
);
17488 // copy data to esalt
17494 pdf
->enc_md
= enc_md
;
17496 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17497 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17498 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17499 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17503 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17504 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17505 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17506 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17509 pdf
->id_len
= id_len
;
17511 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17512 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17513 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17514 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17515 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17516 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17517 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17518 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17519 pdf
->u_len
= u_len
;
17521 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17522 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17523 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17524 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17525 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17526 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17527 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17528 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17529 pdf
->o_len
= o_len
;
17531 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17532 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17533 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17534 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17538 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17539 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17540 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17541 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17544 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17545 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17546 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17547 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17548 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17549 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17550 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17551 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17553 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17554 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17555 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17556 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17557 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17558 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17559 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17560 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17562 // precompute rc4 data for later use
17578 uint salt_pc_block
[32] = { 0 };
17580 char *salt_pc_ptr
= (char *) salt_pc_block
;
17582 memcpy (salt_pc_ptr
, padding
, 32);
17583 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17585 uint salt_pc_digest
[4] = { 0 };
17587 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17589 pdf
->rc4data
[0] = salt_pc_digest
[0];
17590 pdf
->rc4data
[1] = salt_pc_digest
[1];
17592 // we use ID for salt, maybe needs to change, we will see...
17594 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17595 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17596 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17597 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17598 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17599 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17600 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17601 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17602 salt
->salt_len
= pdf
->id_len
+ 16;
17604 salt
->salt_iter
= ROUNDS_PDF14
;
17606 digest
[0] = pdf
->u_buf
[0];
17607 digest
[1] = pdf
->u_buf
[1];
17611 return (PARSER_OK
);
17614 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17616 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17618 if (ret
!= PARSER_OK
)
17623 u32
*digest
= (u32
*) hash_buf
->digest
;
17625 salt_t
*salt
= hash_buf
->salt
;
17627 digest
[0] -= SHA256M_A
;
17628 digest
[1] -= SHA256M_B
;
17629 digest
[2] -= SHA256M_C
;
17630 digest
[3] -= SHA256M_D
;
17631 digest
[4] -= SHA256M_E
;
17632 digest
[5] -= SHA256M_F
;
17633 digest
[6] -= SHA256M_G
;
17634 digest
[7] -= SHA256M_H
;
17636 salt
->salt_buf
[2] = 0x80;
17638 return (PARSER_OK
);
17641 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17643 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17645 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17647 u32
*digest
= (u32
*) hash_buf
->digest
;
17649 salt_t
*salt
= hash_buf
->salt
;
17651 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17657 char *V_pos
= input_buf
+ 5;
17659 char *R_pos
= strchr (V_pos
, '*');
17661 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17663 u32 V_len
= R_pos
- V_pos
;
17667 char *bits_pos
= strchr (R_pos
, '*');
17669 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17671 u32 R_len
= bits_pos
- R_pos
;
17675 char *P_pos
= strchr (bits_pos
, '*');
17677 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17679 u32 bits_len
= P_pos
- bits_pos
;
17683 char *enc_md_pos
= strchr (P_pos
, '*');
17685 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17687 u32 P_len
= enc_md_pos
- P_pos
;
17691 char *id_len_pos
= strchr (enc_md_pos
, '*');
17693 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17695 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17699 char *id_buf_pos
= strchr (id_len_pos
, '*');
17701 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17703 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17707 char *u_len_pos
= strchr (id_buf_pos
, '*');
17709 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17711 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17715 char *u_buf_pos
= strchr (u_len_pos
, '*');
17717 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17719 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17723 char *o_len_pos
= strchr (u_buf_pos
, '*');
17725 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17727 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17731 char *o_buf_pos
= strchr (o_len_pos
, '*');
17733 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17735 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17739 char *last
= strchr (o_buf_pos
, '*');
17741 if (last
== NULL
) last
= input_buf
+ input_len
;
17743 u32 o_buf_len
= last
- o_buf_pos
;
17747 const int V
= atoi (V_pos
);
17748 const int R
= atoi (R_pos
);
17752 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17753 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17755 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17757 const int bits
= atoi (bits_pos
);
17759 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17761 int enc_md
= atoi (enc_md_pos
);
17763 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17765 const uint id_len
= atoi (id_len_pos
);
17766 const uint u_len
= atoi (u_len_pos
);
17767 const uint o_len
= atoi (o_len_pos
);
17769 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17770 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17771 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17772 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17773 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17774 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17775 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17776 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17778 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17779 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17780 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17782 // copy data to esalt
17784 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17786 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17788 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17791 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17792 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17794 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17795 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17797 salt
->salt_len
= 8;
17798 salt
->salt_iter
= ROUNDS_PDF17L8
;
17800 digest
[0] = pdf
->u_buf
[0];
17801 digest
[1] = pdf
->u_buf
[1];
17802 digest
[2] = pdf
->u_buf
[2];
17803 digest
[3] = pdf
->u_buf
[3];
17804 digest
[4] = pdf
->u_buf
[4];
17805 digest
[5] = pdf
->u_buf
[5];
17806 digest
[6] = pdf
->u_buf
[6];
17807 digest
[7] = pdf
->u_buf
[7];
17809 return (PARSER_OK
);
17812 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17814 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17816 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17818 u32
*digest
= (u32
*) hash_buf
->digest
;
17820 salt_t
*salt
= hash_buf
->salt
;
17822 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17830 char *iter_pos
= input_buf
+ 7;
17832 u32 iter
= atoi (iter_pos
);
17834 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17835 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17837 // first is *raw* salt
17839 char *salt_pos
= strchr (iter_pos
, ':');
17841 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17845 char *hash_pos
= strchr (salt_pos
, ':');
17847 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17849 u32 salt_len
= hash_pos
- salt_pos
;
17851 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17855 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17857 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17861 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17863 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17865 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17867 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17868 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17870 salt
->salt_len
= salt_len
;
17871 salt
->salt_iter
= iter
- 1;
17875 u8 tmp_buf
[100] = { 0 };
17877 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17879 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17881 memcpy (digest
, tmp_buf
, 16);
17883 digest
[0] = byte_swap_32 (digest
[0]);
17884 digest
[1] = byte_swap_32 (digest
[1]);
17885 digest
[2] = byte_swap_32 (digest
[2]);
17886 digest
[3] = byte_swap_32 (digest
[3]);
17888 // add some stuff to normal salt to make sorted happy
17890 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17891 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17892 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17893 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17894 salt
->salt_buf
[4] = salt
->salt_iter
;
17896 return (PARSER_OK
);
17899 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17901 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17903 u32
*digest
= (u32
*) hash_buf
->digest
;
17905 salt_t
*salt
= hash_buf
->salt
;
17907 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17908 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17909 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17910 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17912 digest
[0] = byte_swap_32 (digest
[0]);
17913 digest
[1] = byte_swap_32 (digest
[1]);
17914 digest
[2] = byte_swap_32 (digest
[2]);
17915 digest
[3] = byte_swap_32 (digest
[3]);
17917 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17919 uint salt_len
= input_len
- 32 - 1;
17921 char *salt_buf
= input_buf
+ 32 + 1;
17923 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17925 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17927 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17929 salt
->salt_len
= salt_len
;
17931 return (PARSER_OK
);
17934 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17936 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17938 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17940 u32
*digest
= (u32
*) hash_buf
->digest
;
17942 salt_t
*salt
= hash_buf
->salt
;
17944 char *user_pos
= input_buf
+ 10;
17946 char *salt_pos
= strchr (user_pos
, '*');
17948 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17952 char *hash_pos
= strchr (salt_pos
, '*');
17956 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17958 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17960 uint user_len
= salt_pos
- user_pos
- 1;
17962 uint salt_len
= hash_pos
- salt_pos
- 1;
17964 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17970 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17971 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17972 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17973 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17975 digest
[0] = byte_swap_32 (digest
[0]);
17976 digest
[1] = byte_swap_32 (digest
[1]);
17977 digest
[2] = byte_swap_32 (digest
[2]);
17978 digest
[3] = byte_swap_32 (digest
[3]);
17980 digest
[0] -= MD5M_A
;
17981 digest
[1] -= MD5M_B
;
17982 digest
[2] -= MD5M_C
;
17983 digest
[3] -= MD5M_D
;
17989 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17991 // first 4 bytes are the "challenge"
17993 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17994 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17995 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17996 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17998 // append the user name
18000 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
18002 salt
->salt_len
= 4 + user_len
;
18004 return (PARSER_OK
);
18007 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18009 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
18011 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18013 u32
*digest
= (u32
*) hash_buf
->digest
;
18015 salt_t
*salt
= hash_buf
->salt
;
18017 char *salt_pos
= input_buf
+ 9;
18019 char *hash_pos
= strchr (salt_pos
, '*');
18021 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18025 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18027 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
18029 uint salt_len
= hash_pos
- salt_pos
- 1;
18031 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
18037 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18038 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18039 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18040 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18041 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18047 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18049 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18051 salt
->salt_len
= salt_len
;
18053 return (PARSER_OK
);
18056 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18058 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
18060 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18062 u32
*digest
= (u32
*) hash_buf
->digest
;
18064 salt_t
*salt
= hash_buf
->salt
;
18066 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
18072 char *cry_master_len_pos
= input_buf
+ 9;
18074 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
18076 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18078 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
18080 cry_master_buf_pos
++;
18082 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
18084 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18086 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
18088 cry_salt_len_pos
++;
18090 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
18092 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18094 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
18096 cry_salt_buf_pos
++;
18098 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
18100 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18102 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
18106 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
18108 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18110 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
18114 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
18116 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18118 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
18122 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
18124 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18126 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
18128 public_key_len_pos
++;
18130 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
18132 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18134 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
18136 public_key_buf_pos
++;
18138 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;
18140 const uint cry_master_len
= atoi (cry_master_len_pos
);
18141 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
18142 const uint ckey_len
= atoi (ckey_len_pos
);
18143 const uint public_key_len
= atoi (public_key_len_pos
);
18145 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
18146 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
18147 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
18148 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
18150 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
18152 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
18154 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
18157 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
18159 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
18161 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
18164 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
18166 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
18168 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
18171 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
18172 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
18173 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
18176 * store digest (should be unique enought, hopefully)
18179 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
18180 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
18181 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
18182 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
18188 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
18190 const uint cry_rounds
= atoi (cry_rounds_pos
);
18192 salt
->salt_iter
= cry_rounds
- 1;
18194 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18196 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
18198 salt
->salt_len
= salt_len
;
18200 return (PARSER_OK
);
18203 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18205 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
18207 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18209 u32
*digest
= (u32
*) hash_buf
->digest
;
18211 salt_t
*salt
= hash_buf
->salt
;
18213 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
18215 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
18217 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
18219 memcpy (temp_input_buf
, input_buf
, input_len
);
18223 char *URI_server_pos
= temp_input_buf
+ 6;
18225 char *URI_client_pos
= strchr (URI_server_pos
, '*');
18227 if (URI_client_pos
== NULL
)
18229 myfree (temp_input_buf
);
18231 return (PARSER_SEPARATOR_UNMATCHED
);
18234 URI_client_pos
[0] = 0;
18237 uint URI_server_len
= strlen (URI_server_pos
);
18239 if (URI_server_len
> 512)
18241 myfree (temp_input_buf
);
18243 return (PARSER_SALT_LENGTH
);
18248 char *user_pos
= strchr (URI_client_pos
, '*');
18250 if (user_pos
== NULL
)
18252 myfree (temp_input_buf
);
18254 return (PARSER_SEPARATOR_UNMATCHED
);
18260 uint URI_client_len
= strlen (URI_client_pos
);
18262 if (URI_client_len
> 512)
18264 myfree (temp_input_buf
);
18266 return (PARSER_SALT_LENGTH
);
18271 char *realm_pos
= strchr (user_pos
, '*');
18273 if (realm_pos
== NULL
)
18275 myfree (temp_input_buf
);
18277 return (PARSER_SEPARATOR_UNMATCHED
);
18283 uint user_len
= strlen (user_pos
);
18285 if (user_len
> 116)
18287 myfree (temp_input_buf
);
18289 return (PARSER_SALT_LENGTH
);
18294 char *method_pos
= strchr (realm_pos
, '*');
18296 if (method_pos
== NULL
)
18298 myfree (temp_input_buf
);
18300 return (PARSER_SEPARATOR_UNMATCHED
);
18306 uint realm_len
= strlen (realm_pos
);
18308 if (realm_len
> 116)
18310 myfree (temp_input_buf
);
18312 return (PARSER_SALT_LENGTH
);
18317 char *URI_prefix_pos
= strchr (method_pos
, '*');
18319 if (URI_prefix_pos
== NULL
)
18321 myfree (temp_input_buf
);
18323 return (PARSER_SEPARATOR_UNMATCHED
);
18326 URI_prefix_pos
[0] = 0;
18329 uint method_len
= strlen (method_pos
);
18331 if (method_len
> 246)
18333 myfree (temp_input_buf
);
18335 return (PARSER_SALT_LENGTH
);
18340 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
18342 if (URI_resource_pos
== NULL
)
18344 myfree (temp_input_buf
);
18346 return (PARSER_SEPARATOR_UNMATCHED
);
18349 URI_resource_pos
[0] = 0;
18350 URI_resource_pos
++;
18352 uint URI_prefix_len
= strlen (URI_prefix_pos
);
18354 if (URI_prefix_len
> 245)
18356 myfree (temp_input_buf
);
18358 return (PARSER_SALT_LENGTH
);
18363 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
18365 if (URI_suffix_pos
== NULL
)
18367 myfree (temp_input_buf
);
18369 return (PARSER_SEPARATOR_UNMATCHED
);
18372 URI_suffix_pos
[0] = 0;
18375 uint URI_resource_len
= strlen (URI_resource_pos
);
18377 if (URI_resource_len
< 1 || URI_resource_len
> 246)
18379 myfree (temp_input_buf
);
18381 return (PARSER_SALT_LENGTH
);
18386 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
18388 if (nonce_pos
== NULL
)
18390 myfree (temp_input_buf
);
18392 return (PARSER_SEPARATOR_UNMATCHED
);
18398 uint URI_suffix_len
= strlen (URI_suffix_pos
);
18400 if (URI_suffix_len
> 245)
18402 myfree (temp_input_buf
);
18404 return (PARSER_SALT_LENGTH
);
18409 char *nonce_client_pos
= strchr (nonce_pos
, '*');
18411 if (nonce_client_pos
== NULL
)
18413 myfree (temp_input_buf
);
18415 return (PARSER_SEPARATOR_UNMATCHED
);
18418 nonce_client_pos
[0] = 0;
18419 nonce_client_pos
++;
18421 uint nonce_len
= strlen (nonce_pos
);
18423 if (nonce_len
< 1 || nonce_len
> 50)
18425 myfree (temp_input_buf
);
18427 return (PARSER_SALT_LENGTH
);
18432 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18434 if (nonce_count_pos
== NULL
)
18436 myfree (temp_input_buf
);
18438 return (PARSER_SEPARATOR_UNMATCHED
);
18441 nonce_count_pos
[0] = 0;
18444 uint nonce_client_len
= strlen (nonce_client_pos
);
18446 if (nonce_client_len
> 50)
18448 myfree (temp_input_buf
);
18450 return (PARSER_SALT_LENGTH
);
18455 char *qop_pos
= strchr (nonce_count_pos
, '*');
18457 if (qop_pos
== NULL
)
18459 myfree (temp_input_buf
);
18461 return (PARSER_SEPARATOR_UNMATCHED
);
18467 uint nonce_count_len
= strlen (nonce_count_pos
);
18469 if (nonce_count_len
> 50)
18471 myfree (temp_input_buf
);
18473 return (PARSER_SALT_LENGTH
);
18478 char *directive_pos
= strchr (qop_pos
, '*');
18480 if (directive_pos
== NULL
)
18482 myfree (temp_input_buf
);
18484 return (PARSER_SEPARATOR_UNMATCHED
);
18487 directive_pos
[0] = 0;
18490 uint qop_len
= strlen (qop_pos
);
18494 myfree (temp_input_buf
);
18496 return (PARSER_SALT_LENGTH
);
18501 char *digest_pos
= strchr (directive_pos
, '*');
18503 if (digest_pos
== NULL
)
18505 myfree (temp_input_buf
);
18507 return (PARSER_SEPARATOR_UNMATCHED
);
18513 uint directive_len
= strlen (directive_pos
);
18515 if (directive_len
!= 3)
18517 myfree (temp_input_buf
);
18519 return (PARSER_SALT_LENGTH
);
18522 if (memcmp (directive_pos
, "MD5", 3))
18524 log_info ("ERROR: only the MD5 directive is currently supported\n");
18526 myfree (temp_input_buf
);
18528 return (PARSER_SIP_AUTH_DIRECTIVE
);
18532 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18537 uint md5_max_len
= 4 * 64;
18539 uint md5_remaining_len
= md5_max_len
;
18541 uint tmp_md5_buf
[64] = { 0 };
18543 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18545 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18547 md5_len
+= method_len
+ 1;
18548 tmp_md5_ptr
+= method_len
+ 1;
18550 if (URI_prefix_len
> 0)
18552 md5_remaining_len
= md5_max_len
- md5_len
;
18554 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18556 md5_len
+= URI_prefix_len
+ 1;
18557 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18560 md5_remaining_len
= md5_max_len
- md5_len
;
18562 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18564 md5_len
+= URI_resource_len
;
18565 tmp_md5_ptr
+= URI_resource_len
;
18567 if (URI_suffix_len
> 0)
18569 md5_remaining_len
= md5_max_len
- md5_len
;
18571 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18573 md5_len
+= 1 + URI_suffix_len
;
18576 uint tmp_digest
[4] = { 0 };
18578 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18580 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18581 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18582 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18583 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18589 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18591 uint esalt_len
= 0;
18593 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18595 // there are 2 possibilities for the esalt:
18597 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18599 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18601 if (esalt_len
> max_esalt_len
)
18603 myfree (temp_input_buf
);
18605 return (PARSER_SALT_LENGTH
);
18608 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18620 esalt_len
= 1 + nonce_len
+ 1 + 32;
18622 if (esalt_len
> max_esalt_len
)
18624 myfree (temp_input_buf
);
18626 return (PARSER_SALT_LENGTH
);
18629 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18637 // add 0x80 to esalt
18639 esalt_buf_ptr
[esalt_len
] = 0x80;
18641 sip
->esalt_len
= esalt_len
;
18647 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18649 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18651 uint max_salt_len
= 119;
18653 if (salt_len
> max_salt_len
)
18655 myfree (temp_input_buf
);
18657 return (PARSER_SALT_LENGTH
);
18660 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18662 sip
->salt_len
= salt_len
;
18665 * fake salt (for sorting)
18668 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18672 uint fake_salt_len
= salt_len
;
18674 if (fake_salt_len
> max_salt_len
)
18676 fake_salt_len
= max_salt_len
;
18679 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18681 salt
->salt_len
= fake_salt_len
;
18687 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18688 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18689 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18690 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18692 digest
[0] = byte_swap_32 (digest
[0]);
18693 digest
[1] = byte_swap_32 (digest
[1]);
18694 digest
[2] = byte_swap_32 (digest
[2]);
18695 digest
[3] = byte_swap_32 (digest
[3]);
18697 myfree (temp_input_buf
);
18699 return (PARSER_OK
);
18702 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18704 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18706 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18708 u32
*digest
= (u32
*) hash_buf
->digest
;
18710 salt_t
*salt
= hash_buf
->salt
;
18714 char *digest_pos
= input_buf
;
18716 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18723 char *salt_buf
= input_buf
+ 8 + 1;
18727 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18729 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18731 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18733 salt
->salt_len
= salt_len
;
18735 return (PARSER_OK
);
18738 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18740 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18742 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18744 u32
*digest
= (u32
*) hash_buf
->digest
;
18746 salt_t
*salt
= hash_buf
->salt
;
18748 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18754 char *p_buf_pos
= input_buf
+ 4;
18756 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18758 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18760 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18762 NumCyclesPower_pos
++;
18764 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18766 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18768 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18772 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18774 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18776 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18780 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18782 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18784 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18788 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18790 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18792 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18796 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18798 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18800 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18804 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18806 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18808 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18812 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18814 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18816 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18820 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18822 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18824 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18828 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;
18830 const uint iter
= atoi (NumCyclesPower_pos
);
18831 const uint crc
= atoi (crc_buf_pos
);
18832 const uint p_buf
= atoi (p_buf_pos
);
18833 const uint salt_len
= atoi (salt_len_pos
);
18834 const uint iv_len
= atoi (iv_len_pos
);
18835 const uint unpack_size
= atoi (unpack_size_pos
);
18836 const uint data_len
= atoi (data_len_pos
);
18842 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18843 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18845 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18847 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18849 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18855 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18856 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18857 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18858 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18860 seven_zip
->iv_len
= iv_len
;
18862 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18864 seven_zip
->salt_len
= 0;
18866 seven_zip
->crc
= crc
;
18868 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18870 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18872 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18875 seven_zip
->data_len
= data_len
;
18877 seven_zip
->unpack_size
= unpack_size
;
18881 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18882 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18883 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18884 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18886 salt
->salt_len
= 16;
18888 salt
->salt_sign
[0] = iter
;
18890 salt
->salt_iter
= 1 << iter
;
18901 return (PARSER_OK
);
18904 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18906 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18908 u32
*digest
= (u32
*) hash_buf
->digest
;
18910 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18911 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18912 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18913 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18914 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18915 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18916 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18917 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18919 digest
[0] = byte_swap_32 (digest
[0]);
18920 digest
[1] = byte_swap_32 (digest
[1]);
18921 digest
[2] = byte_swap_32 (digest
[2]);
18922 digest
[3] = byte_swap_32 (digest
[3]);
18923 digest
[4] = byte_swap_32 (digest
[4]);
18924 digest
[5] = byte_swap_32 (digest
[5]);
18925 digest
[6] = byte_swap_32 (digest
[6]);
18926 digest
[7] = byte_swap_32 (digest
[7]);
18928 return (PARSER_OK
);
18931 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18933 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18935 u32
*digest
= (u32
*) hash_buf
->digest
;
18937 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18938 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18939 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18940 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18941 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18942 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18943 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18944 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18945 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18946 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18947 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18948 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18949 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18950 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18951 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18952 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18954 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18955 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18956 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18957 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18958 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18959 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18960 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18961 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18962 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18963 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18964 digest
[10] = byte_swap_32 (digest
[10]);
18965 digest
[11] = byte_swap_32 (digest
[11]);
18966 digest
[12] = byte_swap_32 (digest
[12]);
18967 digest
[13] = byte_swap_32 (digest
[13]);
18968 digest
[14] = byte_swap_32 (digest
[14]);
18969 digest
[15] = byte_swap_32 (digest
[15]);
18971 return (PARSER_OK
);
18974 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18976 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18978 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18980 u32
*digest
= (u32
*) hash_buf
->digest
;
18982 salt_t
*salt
= hash_buf
->salt
;
18984 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18992 char *iter_pos
= input_buf
+ 4;
18994 u32 iter
= atoi (iter_pos
);
18996 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18997 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18999 // first is *raw* salt
19001 char *salt_pos
= strchr (iter_pos
, ':');
19003 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19007 char *hash_pos
= strchr (salt_pos
, ':');
19009 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19011 u32 salt_len
= hash_pos
- salt_pos
;
19013 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19017 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19019 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19023 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
19025 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19027 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19029 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19030 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19032 salt
->salt_len
= salt_len
;
19033 salt
->salt_iter
= iter
- 1;
19037 u8 tmp_buf
[100] = { 0 };
19039 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19041 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19043 memcpy (digest
, tmp_buf
, 16);
19045 // add some stuff to normal salt to make sorted happy
19047 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
19048 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
19049 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
19050 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
19051 salt
->salt_buf
[4] = salt
->salt_iter
;
19053 return (PARSER_OK
);
19056 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19058 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
19060 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
19062 u32
*digest
= (u32
*) hash_buf
->digest
;
19064 salt_t
*salt
= hash_buf
->salt
;
19066 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
19074 char *iter_pos
= input_buf
+ 5;
19076 u32 iter
= atoi (iter_pos
);
19078 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19079 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19081 // first is *raw* salt
19083 char *salt_pos
= strchr (iter_pos
, ':');
19085 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19089 char *hash_pos
= strchr (salt_pos
, ':');
19091 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19093 u32 salt_len
= hash_pos
- salt_pos
;
19095 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19099 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19101 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19105 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
19107 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19109 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19111 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19112 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19114 salt
->salt_len
= salt_len
;
19115 salt
->salt_iter
= iter
- 1;
19119 u8 tmp_buf
[100] = { 0 };
19121 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19123 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19125 memcpy (digest
, tmp_buf
, 16);
19127 digest
[0] = byte_swap_32 (digest
[0]);
19128 digest
[1] = byte_swap_32 (digest
[1]);
19129 digest
[2] = byte_swap_32 (digest
[2]);
19130 digest
[3] = byte_swap_32 (digest
[3]);
19132 // add some stuff to normal salt to make sorted happy
19134 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
19135 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
19136 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
19137 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
19138 salt
->salt_buf
[4] = salt
->salt_iter
;
19140 return (PARSER_OK
);
19143 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19145 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
19147 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
19149 u64
*digest
= (u64
*) hash_buf
->digest
;
19151 salt_t
*salt
= hash_buf
->salt
;
19153 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
19161 char *iter_pos
= input_buf
+ 7;
19163 u32 iter
= atoi (iter_pos
);
19165 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19166 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19168 // first is *raw* salt
19170 char *salt_pos
= strchr (iter_pos
, ':');
19172 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19176 char *hash_pos
= strchr (salt_pos
, ':');
19178 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19180 u32 salt_len
= hash_pos
- salt_pos
;
19182 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19186 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19188 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19192 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
19194 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19196 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19198 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19199 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19201 salt
->salt_len
= salt_len
;
19202 salt
->salt_iter
= iter
- 1;
19206 u8 tmp_buf
[100] = { 0 };
19208 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19210 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19212 memcpy (digest
, tmp_buf
, 64);
19214 digest
[0] = byte_swap_64 (digest
[0]);
19215 digest
[1] = byte_swap_64 (digest
[1]);
19216 digest
[2] = byte_swap_64 (digest
[2]);
19217 digest
[3] = byte_swap_64 (digest
[3]);
19218 digest
[4] = byte_swap_64 (digest
[4]);
19219 digest
[5] = byte_swap_64 (digest
[5]);
19220 digest
[6] = byte_swap_64 (digest
[6]);
19221 digest
[7] = byte_swap_64 (digest
[7]);
19223 // add some stuff to normal salt to make sorted happy
19225 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
19226 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
19227 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
19228 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
19229 salt
->salt_buf
[4] = salt
->salt_iter
;
19231 return (PARSER_OK
);
19234 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19236 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
19238 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
19240 uint
*digest
= (uint
*) hash_buf
->digest
;
19242 salt_t
*salt
= hash_buf
->salt
;
19248 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
19250 char *hash_pos
= strchr (salt_pos
, '$');
19252 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19254 u32 salt_len
= hash_pos
- salt_pos
;
19256 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19260 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
19262 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
19266 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
19267 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
19285 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19286 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19288 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
19289 salt
->salt_len
= 8;
19291 return (PARSER_OK
);
19294 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19296 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
19298 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19300 unsigned char c19
= itoa64_to_int (input_buf
[19]);
19302 if (c19
& 3) return (PARSER_HASH_VALUE
);
19304 salt_t
*salt
= hash_buf
->salt
;
19306 u32
*digest
= (u32
*) hash_buf
->digest
;
19310 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
19311 | itoa64_to_int (input_buf
[2]) << 6
19312 | itoa64_to_int (input_buf
[3]) << 12
19313 | itoa64_to_int (input_buf
[4]) << 18;
19317 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
19318 | itoa64_to_int (input_buf
[6]) << 6
19319 | itoa64_to_int (input_buf
[7]) << 12
19320 | itoa64_to_int (input_buf
[8]) << 18;
19322 salt
->salt_len
= 4;
19324 u8 tmp_buf
[100] = { 0 };
19326 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
19328 memcpy (digest
, tmp_buf
, 8);
19332 IP (digest
[0], digest
[1], tt
);
19334 digest
[0] = rotr32 (digest
[0], 31);
19335 digest
[1] = rotr32 (digest
[1], 31);
19339 return (PARSER_OK
);
19342 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19344 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
19346 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
19348 u32
*digest
= (u32
*) hash_buf
->digest
;
19350 salt_t
*salt
= hash_buf
->salt
;
19356 char *type_pos
= input_buf
+ 6 + 1;
19358 char *salt_pos
= strchr (type_pos
, '*');
19360 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19362 u32 type_len
= salt_pos
- type_pos
;
19364 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
19368 char *crypted_pos
= strchr (salt_pos
, '*');
19370 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19372 u32 salt_len
= crypted_pos
- salt_pos
;
19374 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19378 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
19380 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
19386 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19387 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19389 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19390 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19392 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
19393 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
19394 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
19395 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
19397 salt
->salt_len
= 24;
19398 salt
->salt_iter
= ROUNDS_RAR3
;
19400 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
19401 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
19403 digest
[0] = 0xc43d7b00;
19404 digest
[1] = 0x40070000;
19408 return (PARSER_OK
);
19411 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19413 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19415 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19417 u32
*digest
= (u32
*) hash_buf
->digest
;
19419 salt_t
*salt
= hash_buf
->salt
;
19421 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19427 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19429 char *param1_pos
= strchr (param0_pos
, '$');
19431 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19433 u32 param0_len
= param1_pos
- param0_pos
;
19437 char *param2_pos
= strchr (param1_pos
, '$');
19439 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19441 u32 param1_len
= param2_pos
- param1_pos
;
19445 char *param3_pos
= strchr (param2_pos
, '$');
19447 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19449 u32 param2_len
= param3_pos
- param2_pos
;
19453 char *param4_pos
= strchr (param3_pos
, '$');
19455 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19457 u32 param3_len
= param4_pos
- param3_pos
;
19461 char *param5_pos
= strchr (param4_pos
, '$');
19463 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19465 u32 param4_len
= param5_pos
- param4_pos
;
19469 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19471 char *salt_buf
= param1_pos
;
19472 char *iv
= param3_pos
;
19473 char *pswcheck
= param5_pos
;
19475 const uint salt_len
= atoi (param0_pos
);
19476 const uint iterations
= atoi (param2_pos
);
19477 const uint pswcheck_len
= atoi (param4_pos
);
19483 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19484 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19485 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19487 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19488 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19489 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19495 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19496 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19497 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19498 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19500 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19501 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19502 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19503 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19505 salt
->salt_len
= 16;
19507 salt
->salt_sign
[0] = iterations
;
19509 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19515 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19516 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19520 return (PARSER_OK
);
19523 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19525 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19527 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19529 u32
*digest
= (u32
*) hash_buf
->digest
;
19531 salt_t
*salt
= hash_buf
->salt
;
19533 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19540 char *account_pos
= input_buf
+ 11 + 1;
19546 if (account_pos
[0] == '*')
19550 data_pos
= strchr (account_pos
, '*');
19555 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19557 uint account_len
= data_pos
- account_pos
+ 1;
19559 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19564 data_len
= input_len
- 11 - 1 - account_len
- 2;
19566 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19570 /* assume $krb5tgs$23$checksum$edata2 */
19571 data_pos
= account_pos
;
19573 memcpy (krb5tgs
->account_info
, "**", 3);
19575 data_len
= input_len
- 11 - 1 - 1;
19578 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19580 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19582 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19584 const char p0
= data_pos
[i
+ 0];
19585 const char p1
= data_pos
[i
+ 1];
19587 *checksum_ptr
++ = hex_convert (p1
) << 0
19588 | hex_convert (p0
) << 4;
19591 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19593 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19596 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19598 const char p0
= data_pos
[i
+ 0];
19599 const char p1
= data_pos
[i
+ 1];
19600 *edata_ptr
++ = hex_convert (p1
) << 0
19601 | hex_convert (p0
) << 4;
19604 /* this is needed for hmac_md5 */
19605 *edata_ptr
++ = 0x80;
19607 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19608 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19609 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19610 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19612 salt
->salt_len
= 32;
19614 digest
[0] = krb5tgs
->checksum
[0];
19615 digest
[1] = krb5tgs
->checksum
[1];
19616 digest
[2] = krb5tgs
->checksum
[2];
19617 digest
[3] = krb5tgs
->checksum
[3];
19619 return (PARSER_OK
);
19622 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19624 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19626 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19628 u32
*digest
= (u32
*) hash_buf
->digest
;
19630 salt_t
*salt
= hash_buf
->salt
;
19637 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19641 char *wrapped_key_pos
;
19645 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19647 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19649 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19651 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19656 data_pos
= salt_pos
;
19658 wrapped_key_pos
= strchr (salt_pos
, '*');
19660 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19662 uint salt_len
= wrapped_key_pos
- salt_pos
;
19664 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19669 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19671 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19673 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19674 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19675 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19676 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19680 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19681 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19682 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19683 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19684 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19685 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19687 salt
->salt_len
= 40;
19689 digest
[0] = salt
->salt_buf
[0];
19690 digest
[1] = salt
->salt_buf
[1];
19691 digest
[2] = salt
->salt_buf
[2];
19692 digest
[3] = salt
->salt_buf
[3];
19694 return (PARSER_OK
);
19697 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19699 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19701 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19703 u32
*digest
= (u32
*) hash_buf
->digest
;
19705 salt_t
*salt
= hash_buf
->salt
;
19707 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19717 char *algorithm_pos
;
19719 char *final_random_seed_pos
;
19720 u32 final_random_seed_len
;
19722 char *transf_random_seed_pos
;
19723 u32 transf_random_seed_len
;
19728 /* default is no keyfile provided */
19729 char *keyfile_len_pos
;
19730 u32 keyfile_len
= 0;
19731 u32 is_keyfile_present
= 0;
19732 char *keyfile_inline_pos
;
19735 /* specific to version 1 */
19736 char *contents_len_pos
;
19738 char *contents_pos
;
19740 /* specific to version 2 */
19741 char *expected_bytes_pos
;
19742 u32 expected_bytes_len
;
19744 char *contents_hash_pos
;
19745 u32 contents_hash_len
;
19747 version_pos
= input_buf
+ 8 + 1 + 1;
19749 keepass
->version
= atoi (version_pos
);
19751 rounds_pos
= strchr (version_pos
, '*');
19753 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19757 salt
->salt_iter
= (atoi (rounds_pos
));
19759 algorithm_pos
= strchr (rounds_pos
, '*');
19761 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19765 keepass
->algorithm
= atoi (algorithm_pos
);
19767 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19769 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19771 final_random_seed_pos
++;
19773 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19774 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19775 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19776 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19778 if (keepass
->version
== 2)
19780 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19781 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19782 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19783 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19786 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19788 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19790 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19792 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19793 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19795 transf_random_seed_pos
++;
19797 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19798 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19799 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19800 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19801 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19802 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19803 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19804 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19806 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19808 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19810 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19812 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19816 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19817 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19818 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19819 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19821 if (keepass
->version
== 1)
19823 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19825 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19827 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19829 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19831 contents_hash_pos
++;
19833 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19834 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19835 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19836 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19837 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19838 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19839 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19840 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19842 /* get length of contents following */
19843 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19845 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19847 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19849 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19853 u32 inline_flag
= atoi (inline_flag_pos
);
19855 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19857 contents_len_pos
= strchr (inline_flag_pos
, '*');
19859 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19861 contents_len_pos
++;
19863 contents_len
= atoi (contents_len_pos
);
19865 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19867 contents_pos
= strchr (contents_len_pos
, '*');
19869 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19875 keepass
->contents_len
= contents_len
;
19877 contents_len
= contents_len
/ 4;
19879 keyfile_inline_pos
= strchr (contents_pos
, '*');
19881 u32 real_contents_len
;
19883 if (keyfile_inline_pos
== NULL
)
19884 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19887 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19888 keyfile_inline_pos
++;
19889 is_keyfile_present
= 1;
19892 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
19894 for (i
= 0; i
< contents_len
; i
++)
19895 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
19897 else if (keepass
->version
== 2)
19899 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
19901 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19903 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
19905 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19907 expected_bytes_pos
++;
19909 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
19910 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
19911 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
19912 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
19913 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
19914 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
19915 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
19916 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
19918 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
19920 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19922 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
19924 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
19926 contents_hash_pos
++;
19928 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19929 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19930 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19931 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19932 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19933 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19934 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19935 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19937 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
19939 if (keyfile_inline_pos
== NULL
)
19940 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
19943 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
19944 keyfile_inline_pos
++;
19945 is_keyfile_present
= 1;
19947 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19950 if (is_keyfile_present
!= 0)
19952 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
19956 keyfile_len
= atoi (keyfile_len_pos
);
19958 keepass
->keyfile_len
= keyfile_len
;
19960 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19962 keyfile_pos
= strchr (keyfile_len_pos
, '*');
19964 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19968 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
19970 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19972 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
19973 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
19974 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
19975 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
19976 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
19977 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
19978 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
19979 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
19982 digest
[0] = keepass
->enc_iv
[0];
19983 digest
[1] = keepass
->enc_iv
[1];
19984 digest
[2] = keepass
->enc_iv
[2];
19985 digest
[3] = keepass
->enc_iv
[3];
19987 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
19988 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
19989 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
19990 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
19991 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
19992 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
19993 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
19994 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
19996 return (PARSER_OK
);
19999 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20001 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
20003 u32
*digest
= (u32
*) hash_buf
->digest
;
20005 salt_t
*salt
= hash_buf
->salt
;
20007 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20008 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20009 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20010 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20011 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20012 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20013 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20014 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20016 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20018 uint salt_len
= input_len
- 64 - 1;
20020 char *salt_buf
= input_buf
+ 64 + 1;
20022 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
20024 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
20026 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
20028 salt
->salt_len
= salt_len
;
20031 * we can precompute the first sha256 transform
20034 uint w
[16] = { 0 };
20036 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
20037 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
20038 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
20039 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
20040 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
20041 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
20042 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
20043 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
20044 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
20045 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
20046 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
20047 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
20048 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
20049 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
20050 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
20051 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
20053 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
20055 sha256_64 (w
, pc256
);
20057 salt
->salt_buf_pc
[0] = pc256
[0];
20058 salt
->salt_buf_pc
[1] = pc256
[1];
20059 salt
->salt_buf_pc
[2] = pc256
[2];
20060 salt
->salt_buf_pc
[3] = pc256
[3];
20061 salt
->salt_buf_pc
[4] = pc256
[4];
20062 salt
->salt_buf_pc
[5] = pc256
[5];
20063 salt
->salt_buf_pc
[6] = pc256
[6];
20064 salt
->salt_buf_pc
[7] = pc256
[7];
20066 digest
[0] -= pc256
[0];
20067 digest
[1] -= pc256
[1];
20068 digest
[2] -= pc256
[2];
20069 digest
[3] -= pc256
[3];
20070 digest
[4] -= pc256
[4];
20071 digest
[5] -= pc256
[5];
20072 digest
[6] -= pc256
[6];
20073 digest
[7] -= pc256
[7];
20075 return (PARSER_OK
);
20078 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20080 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
20082 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
20084 u32
*digest
= (u32
*) hash_buf
->digest
;
20086 salt_t
*salt
= hash_buf
->salt
;
20092 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
20094 char *data_buf_pos
= strchr (data_len_pos
, '$');
20096 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20098 u32 data_len_len
= data_buf_pos
- data_len_pos
;
20100 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
20101 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
20105 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
20107 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
20109 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
20111 u32 data_len
= atoi (data_len_pos
);
20113 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
20119 char *salt_pos
= data_buf_pos
;
20121 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20122 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20123 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
20124 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
20126 // this is actually the CT, which is also the hash later (if matched)
20128 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
20129 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
20130 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
20131 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
20133 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
20135 salt
->salt_iter
= 10 - 1;
20141 digest
[0] = salt
->salt_buf
[4];
20142 digest
[1] = salt
->salt_buf
[5];
20143 digest
[2] = salt
->salt_buf
[6];
20144 digest
[3] = salt
->salt_buf
[7];
20146 return (PARSER_OK
);
20149 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20151 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
20153 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
20155 u32
*digest
= (u32
*) hash_buf
->digest
;
20157 salt_t
*salt
= hash_buf
->salt
;
20163 char *salt_pos
= input_buf
+ 11 + 1;
20165 char *iter_pos
= strchr (salt_pos
, ',');
20167 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20169 u32 salt_len
= iter_pos
- salt_pos
;
20171 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
20175 char *hash_pos
= strchr (iter_pos
, ',');
20177 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20179 u32 iter_len
= hash_pos
- iter_pos
;
20181 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
20185 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
20187 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
20193 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20194 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20195 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
20196 salt
->salt_buf
[3] = 0x00018000;
20198 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
20199 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
20200 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
20201 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
20203 salt
->salt_len
= salt_len
/ 2;
20205 salt
->salt_iter
= atoi (iter_pos
) - 1;
20211 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20212 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20213 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20214 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20215 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20216 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20217 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20218 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20220 return (PARSER_OK
);
20223 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20225 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
20227 u32
*digest
= (u32
*) hash_buf
->digest
;
20229 salt_t
*salt
= hash_buf
->salt
;
20235 char *hash_pos
= input_buf
+ 64;
20236 char *salt1_pos
= input_buf
+ 128;
20237 char *salt2_pos
= input_buf
;
20243 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
20244 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
20245 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
20246 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
20248 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
20249 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
20250 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
20251 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
20253 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
20254 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
20255 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
20256 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
20258 salt
->salt_len
= 48;
20260 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
20266 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20267 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20268 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20269 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20270 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20271 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20272 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20273 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20275 return (PARSER_OK
);
20278 int zip2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20280 if ((input_len
< DISPLAY_LEN_MIN_13600
) || (input_len
> DISPLAY_LEN_MAX_13600
)) return (PARSER_GLOBAL_LENGTH
);
20282 if (memcmp (SIGNATURE_ZIP2_START
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
20283 if (memcmp (SIGNATURE_ZIP2_STOP
, input_buf
+ input_len
- 7, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
20285 u32
*digest
= (u32
*) hash_buf
->digest
;
20287 salt_t
*salt
= hash_buf
->salt
;
20289 zip2_t
*zip2
= (zip2_t
*) hash_buf
->esalt
;
20295 char *param0_pos
= input_buf
+ 6 + 1;
20297 char *param1_pos
= strchr (param0_pos
, '*');
20299 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20301 u32 param0_len
= param1_pos
- param0_pos
;
20305 char *param2_pos
= strchr (param1_pos
, '*');
20307 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20309 u32 param1_len
= param2_pos
- param1_pos
;
20313 char *param3_pos
= strchr (param2_pos
, '*');
20315 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20317 u32 param2_len
= param3_pos
- param2_pos
;
20321 char *param4_pos
= strchr (param3_pos
, '*');
20323 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20325 u32 param3_len
= param4_pos
- param3_pos
;
20329 char *param5_pos
= strchr (param4_pos
, '*');
20331 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20333 u32 param4_len
= param5_pos
- param4_pos
;
20337 char *param6_pos
= strchr (param5_pos
, '*');
20339 if (param6_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20341 u32 param5_len
= param6_pos
- param5_pos
;
20345 char *param7_pos
= strchr (param6_pos
, '*');
20347 if (param7_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20349 u32 param6_len
= param7_pos
- param6_pos
;
20353 char *param8_pos
= strchr (param7_pos
, '*');
20355 if (param8_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20357 u32 param7_len
= param8_pos
- param7_pos
;
20361 const uint type
= atoi (param0_pos
);
20362 const uint mode
= atoi (param1_pos
);
20363 const uint magic
= atoi (param2_pos
);
20365 char *salt_buf
= param3_pos
;
20367 uint verify_bytes
; sscanf (param4_pos
, "%4x*", &verify_bytes
);
20369 const uint compress_length
= atoi (param5_pos
);
20371 char *data_buf
= param6_pos
;
20372 char *auth
= param7_pos
;
20378 if (param0_len
!= 1) return (PARSER_SALT_VALUE
);
20380 if (param1_len
!= 1) return (PARSER_SALT_VALUE
);
20382 if (param2_len
!= 1) return (PARSER_SALT_VALUE
);
20384 if ((param3_len
!= 16) && (param3_len
!= 24) && (param3_len
!= 32)) return (PARSER_SALT_VALUE
);
20386 if (param4_len
>= 5) return (PARSER_SALT_VALUE
);
20388 if (param5_len
>= 5) return (PARSER_SALT_VALUE
);
20390 if (param6_len
>= 8192) return (PARSER_SALT_VALUE
);
20392 if (param6_len
& 1) return (PARSER_SALT_VALUE
);
20394 if (param7_len
!= 20) return (PARSER_SALT_VALUE
);
20396 if (type
!= 0) return (PARSER_SALT_VALUE
);
20398 if ((mode
!= 1) && (mode
!= 2) && (mode
!= 3)) return (PARSER_SALT_VALUE
);
20400 if (magic
!= 0) return (PARSER_SALT_VALUE
);
20402 if (verify_bytes
>= 0x10000) return (PARSER_SALT_VALUE
);
20410 zip2
->magic
= magic
;
20414 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20415 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20416 zip2
->salt_buf
[2] = 0;
20417 zip2
->salt_buf
[3] = 0;
20419 zip2
->salt_len
= 8;
20421 else if (mode
== 2)
20423 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20424 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20425 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20426 zip2
->salt_buf
[3] = 0;
20428 zip2
->salt_len
= 12;
20430 else if (mode
== 3)
20432 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20433 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20434 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20435 zip2
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
20437 zip2
->salt_len
= 16;
20440 zip2
->salt_buf
[0] = byte_swap_32 (zip2
->salt_buf
[0]);
20441 zip2
->salt_buf
[1] = byte_swap_32 (zip2
->salt_buf
[1]);
20442 zip2
->salt_buf
[2] = byte_swap_32 (zip2
->salt_buf
[2]);
20443 zip2
->salt_buf
[3] = byte_swap_32 (zip2
->salt_buf
[3]);
20445 zip2
->verify_bytes
= verify_bytes
;
20447 zip2
->compress_length
= compress_length
;
20449 char *data_buf_ptr
= (char *) zip2
->data_buf
;
20451 for (uint i
= 0; i
< param6_len
; i
+= 2)
20453 const char p0
= data_buf
[i
+ 0];
20454 const char p1
= data_buf
[i
+ 1];
20456 *data_buf_ptr
++ = hex_convert (p1
) << 0
20457 | hex_convert (p0
) << 4;
20462 *data_buf_ptr
= 0x80;
20464 char *auth_ptr
= (char *) zip2
->auth_buf
;
20466 for (uint i
= 0; i
< param7_len
; i
+= 2)
20468 const char p0
= auth
[i
+ 0];
20469 const char p1
= auth
[i
+ 1];
20471 *auth_ptr
++ = hex_convert (p1
) << 0
20472 | hex_convert (p0
) << 4;
20481 salt
->salt_buf
[0] = zip2
->salt_buf
[0];
20482 salt
->salt_buf
[1] = zip2
->salt_buf
[1];
20483 salt
->salt_buf
[2] = zip2
->salt_buf
[2];
20484 salt
->salt_buf
[3] = zip2
->salt_buf
[3];
20485 salt
->salt_buf
[4] = zip2
->data_buf
[0];
20486 salt
->salt_buf
[5] = zip2
->data_buf
[1];
20487 salt
->salt_buf
[6] = zip2
->data_buf
[2];
20488 salt
->salt_buf
[7] = zip2
->data_buf
[3];
20490 salt
->salt_len
= 32;
20492 salt
->salt_iter
= ROUNDS_ZIP2
- 1;
20495 * digest buf (fake)
20498 digest
[0] = zip2
->auth_buf
[0];
20499 digest
[1] = zip2
->auth_buf
[1];
20500 digest
[2] = zip2
->auth_buf
[2];
20501 digest
[3] = zip2
->auth_buf
[3];
20503 return (PARSER_OK
);
20507 * parallel running threads
20512 BOOL WINAPI
sigHandler_default (DWORD sig
)
20516 case CTRL_CLOSE_EVENT
:
20519 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
20520 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
20521 * function otherwise it is too late (e.g. after returning from this function)
20526 SetConsoleCtrlHandler (NULL
, TRUE
);
20533 case CTRL_LOGOFF_EVENT
:
20534 case CTRL_SHUTDOWN_EVENT
:
20538 SetConsoleCtrlHandler (NULL
, TRUE
);
20546 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
20550 case CTRL_CLOSE_EVENT
:
20554 SetConsoleCtrlHandler (NULL
, TRUE
);
20561 case CTRL_LOGOFF_EVENT
:
20562 case CTRL_SHUTDOWN_EVENT
:
20566 SetConsoleCtrlHandler (NULL
, TRUE
);
20574 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
20576 if (callback
== NULL
)
20578 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
20582 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
20588 void sigHandler_default (int sig
)
20592 signal (sig
, NULL
);
20595 void sigHandler_benchmark (int sig
)
20599 signal (sig
, NULL
);
20602 void hc_signal (void (callback
) (int))
20604 if (callback
== NULL
) callback
= SIG_DFL
;
20606 signal (SIGINT
, callback
);
20607 signal (SIGTERM
, callback
);
20608 signal (SIGABRT
, callback
);
20613 void status_display ();
20615 void *thread_keypress (void *p
)
20617 int benchmark
= *((int *) p
);
20619 uint quiet
= data
.quiet
;
20623 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
20625 int ch
= tty_getchar();
20627 if (ch
== -1) break;
20629 if (ch
== 0) continue;
20631 //https://github.com/hashcat/hashcat/issues/302
20636 hc_thread_mutex_lock (mux_display
);
20652 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20653 if (quiet
== 0) fflush (stdout
);
20665 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20666 if (quiet
== 0) fflush (stdout
);
20678 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20679 if (quiet
== 0) fflush (stdout
);
20691 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20692 if (quiet
== 0) fflush (stdout
);
20700 if (benchmark
== 1) break;
20702 stop_at_checkpoint ();
20706 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20707 if (quiet
== 0) fflush (stdout
);
20715 if (benchmark
== 1)
20727 //https://github.com/hashcat/hashcat/issues/302
20732 hc_thread_mutex_unlock (mux_display
);
20744 bool class_num (const u8 c
)
20746 return ((c
>= '0') && (c
<= '9'));
20749 bool class_lower (const u8 c
)
20751 return ((c
>= 'a') && (c
<= 'z'));
20754 bool class_upper (const u8 c
)
20756 return ((c
>= 'A') && (c
<= 'Z'));
20759 bool class_alpha (const u8 c
)
20761 return (class_lower (c
) || class_upper (c
));
20764 int conv_ctoi (const u8 c
)
20770 else if (class_upper (c
))
20772 return c
- 'A' + 10;
20778 int conv_itoc (const u8 c
)
20786 return c
+ 'A' - 10;
20796 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20797 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20798 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20799 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20800 #define MAX_KERNEL_RULES 255
20801 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20802 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20803 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20805 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20806 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20807 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20808 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20810 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20815 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20817 switch (rule_buf
[rule_pos
])
20823 case RULE_OP_MANGLE_NOOP
:
20824 SET_NAME (rule
, rule_buf
[rule_pos
]);
20827 case RULE_OP_MANGLE_LREST
:
20828 SET_NAME (rule
, rule_buf
[rule_pos
]);
20831 case RULE_OP_MANGLE_UREST
:
20832 SET_NAME (rule
, rule_buf
[rule_pos
]);
20835 case RULE_OP_MANGLE_LREST_UFIRST
:
20836 SET_NAME (rule
, rule_buf
[rule_pos
]);
20839 case RULE_OP_MANGLE_UREST_LFIRST
:
20840 SET_NAME (rule
, rule_buf
[rule_pos
]);
20843 case RULE_OP_MANGLE_TREST
:
20844 SET_NAME (rule
, rule_buf
[rule_pos
]);
20847 case RULE_OP_MANGLE_TOGGLE_AT
:
20848 SET_NAME (rule
, rule_buf
[rule_pos
]);
20849 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20852 case RULE_OP_MANGLE_REVERSE
:
20853 SET_NAME (rule
, rule_buf
[rule_pos
]);
20856 case RULE_OP_MANGLE_DUPEWORD
:
20857 SET_NAME (rule
, rule_buf
[rule_pos
]);
20860 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20861 SET_NAME (rule
, rule_buf
[rule_pos
]);
20862 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20865 case RULE_OP_MANGLE_REFLECT
:
20866 SET_NAME (rule
, rule_buf
[rule_pos
]);
20869 case RULE_OP_MANGLE_ROTATE_LEFT
:
20870 SET_NAME (rule
, rule_buf
[rule_pos
]);
20873 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20874 SET_NAME (rule
, rule_buf
[rule_pos
]);
20877 case RULE_OP_MANGLE_APPEND
:
20878 SET_NAME (rule
, rule_buf
[rule_pos
]);
20879 SET_P0 (rule
, rule_buf
[rule_pos
]);
20882 case RULE_OP_MANGLE_PREPEND
:
20883 SET_NAME (rule
, rule_buf
[rule_pos
]);
20884 SET_P0 (rule
, rule_buf
[rule_pos
]);
20887 case RULE_OP_MANGLE_DELETE_FIRST
:
20888 SET_NAME (rule
, rule_buf
[rule_pos
]);
20891 case RULE_OP_MANGLE_DELETE_LAST
:
20892 SET_NAME (rule
, rule_buf
[rule_pos
]);
20895 case RULE_OP_MANGLE_DELETE_AT
:
20896 SET_NAME (rule
, rule_buf
[rule_pos
]);
20897 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20900 case RULE_OP_MANGLE_EXTRACT
:
20901 SET_NAME (rule
, rule_buf
[rule_pos
]);
20902 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20903 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20906 case RULE_OP_MANGLE_OMIT
:
20907 SET_NAME (rule
, rule_buf
[rule_pos
]);
20908 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20909 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20912 case RULE_OP_MANGLE_INSERT
:
20913 SET_NAME (rule
, rule_buf
[rule_pos
]);
20914 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20915 SET_P1 (rule
, rule_buf
[rule_pos
]);
20918 case RULE_OP_MANGLE_OVERSTRIKE
:
20919 SET_NAME (rule
, rule_buf
[rule_pos
]);
20920 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20921 SET_P1 (rule
, rule_buf
[rule_pos
]);
20924 case RULE_OP_MANGLE_TRUNCATE_AT
:
20925 SET_NAME (rule
, rule_buf
[rule_pos
]);
20926 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20929 case RULE_OP_MANGLE_REPLACE
:
20930 SET_NAME (rule
, rule_buf
[rule_pos
]);
20931 SET_P0 (rule
, rule_buf
[rule_pos
]);
20932 SET_P1 (rule
, rule_buf
[rule_pos
]);
20935 case RULE_OP_MANGLE_PURGECHAR
:
20939 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20943 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20944 SET_NAME (rule
, rule_buf
[rule_pos
]);
20945 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20948 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20949 SET_NAME (rule
, rule_buf
[rule_pos
]);
20950 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20953 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20954 SET_NAME (rule
, rule_buf
[rule_pos
]);
20957 case RULE_OP_MANGLE_SWITCH_FIRST
:
20958 SET_NAME (rule
, rule_buf
[rule_pos
]);
20961 case RULE_OP_MANGLE_SWITCH_LAST
:
20962 SET_NAME (rule
, rule_buf
[rule_pos
]);
20965 case RULE_OP_MANGLE_SWITCH_AT
:
20966 SET_NAME (rule
, rule_buf
[rule_pos
]);
20967 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20968 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20971 case RULE_OP_MANGLE_CHR_SHIFTL
:
20972 SET_NAME (rule
, rule_buf
[rule_pos
]);
20973 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20976 case RULE_OP_MANGLE_CHR_SHIFTR
:
20977 SET_NAME (rule
, rule_buf
[rule_pos
]);
20978 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20981 case RULE_OP_MANGLE_CHR_INCR
:
20982 SET_NAME (rule
, rule_buf
[rule_pos
]);
20983 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20986 case RULE_OP_MANGLE_CHR_DECR
:
20987 SET_NAME (rule
, rule_buf
[rule_pos
]);
20988 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20991 case RULE_OP_MANGLE_REPLACE_NP1
:
20992 SET_NAME (rule
, rule_buf
[rule_pos
]);
20993 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20996 case RULE_OP_MANGLE_REPLACE_NM1
:
20997 SET_NAME (rule
, rule_buf
[rule_pos
]);
20998 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21001 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21002 SET_NAME (rule
, rule_buf
[rule_pos
]);
21003 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21006 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21007 SET_NAME (rule
, rule_buf
[rule_pos
]);
21008 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21011 case RULE_OP_MANGLE_TITLE
:
21012 SET_NAME (rule
, rule_buf
[rule_pos
]);
21021 if (rule_pos
< rule_len
) return (-1);
21026 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
21030 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
21034 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
21038 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
21042 case RULE_OP_MANGLE_NOOP
:
21043 rule_buf
[rule_pos
] = rule_cmd
;
21046 case RULE_OP_MANGLE_LREST
:
21047 rule_buf
[rule_pos
] = rule_cmd
;
21050 case RULE_OP_MANGLE_UREST
:
21051 rule_buf
[rule_pos
] = rule_cmd
;
21054 case RULE_OP_MANGLE_LREST_UFIRST
:
21055 rule_buf
[rule_pos
] = rule_cmd
;
21058 case RULE_OP_MANGLE_UREST_LFIRST
:
21059 rule_buf
[rule_pos
] = rule_cmd
;
21062 case RULE_OP_MANGLE_TREST
:
21063 rule_buf
[rule_pos
] = rule_cmd
;
21066 case RULE_OP_MANGLE_TOGGLE_AT
:
21067 rule_buf
[rule_pos
] = rule_cmd
;
21068 GET_P0_CONV (rule
);
21071 case RULE_OP_MANGLE_REVERSE
:
21072 rule_buf
[rule_pos
] = rule_cmd
;
21075 case RULE_OP_MANGLE_DUPEWORD
:
21076 rule_buf
[rule_pos
] = rule_cmd
;
21079 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21080 rule_buf
[rule_pos
] = rule_cmd
;
21081 GET_P0_CONV (rule
);
21084 case RULE_OP_MANGLE_REFLECT
:
21085 rule_buf
[rule_pos
] = rule_cmd
;
21088 case RULE_OP_MANGLE_ROTATE_LEFT
:
21089 rule_buf
[rule_pos
] = rule_cmd
;
21092 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21093 rule_buf
[rule_pos
] = rule_cmd
;
21096 case RULE_OP_MANGLE_APPEND
:
21097 rule_buf
[rule_pos
] = rule_cmd
;
21101 case RULE_OP_MANGLE_PREPEND
:
21102 rule_buf
[rule_pos
] = rule_cmd
;
21106 case RULE_OP_MANGLE_DELETE_FIRST
:
21107 rule_buf
[rule_pos
] = rule_cmd
;
21110 case RULE_OP_MANGLE_DELETE_LAST
:
21111 rule_buf
[rule_pos
] = rule_cmd
;
21114 case RULE_OP_MANGLE_DELETE_AT
:
21115 rule_buf
[rule_pos
] = rule_cmd
;
21116 GET_P0_CONV (rule
);
21119 case RULE_OP_MANGLE_EXTRACT
:
21120 rule_buf
[rule_pos
] = rule_cmd
;
21121 GET_P0_CONV (rule
);
21122 GET_P1_CONV (rule
);
21125 case RULE_OP_MANGLE_OMIT
:
21126 rule_buf
[rule_pos
] = rule_cmd
;
21127 GET_P0_CONV (rule
);
21128 GET_P1_CONV (rule
);
21131 case RULE_OP_MANGLE_INSERT
:
21132 rule_buf
[rule_pos
] = rule_cmd
;
21133 GET_P0_CONV (rule
);
21137 case RULE_OP_MANGLE_OVERSTRIKE
:
21138 rule_buf
[rule_pos
] = rule_cmd
;
21139 GET_P0_CONV (rule
);
21143 case RULE_OP_MANGLE_TRUNCATE_AT
:
21144 rule_buf
[rule_pos
] = rule_cmd
;
21145 GET_P0_CONV (rule
);
21148 case RULE_OP_MANGLE_REPLACE
:
21149 rule_buf
[rule_pos
] = rule_cmd
;
21154 case RULE_OP_MANGLE_PURGECHAR
:
21158 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21162 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21163 rule_buf
[rule_pos
] = rule_cmd
;
21164 GET_P0_CONV (rule
);
21167 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21168 rule_buf
[rule_pos
] = rule_cmd
;
21169 GET_P0_CONV (rule
);
21172 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21173 rule_buf
[rule_pos
] = rule_cmd
;
21176 case RULE_OP_MANGLE_SWITCH_FIRST
:
21177 rule_buf
[rule_pos
] = rule_cmd
;
21180 case RULE_OP_MANGLE_SWITCH_LAST
:
21181 rule_buf
[rule_pos
] = rule_cmd
;
21184 case RULE_OP_MANGLE_SWITCH_AT
:
21185 rule_buf
[rule_pos
] = rule_cmd
;
21186 GET_P0_CONV (rule
);
21187 GET_P1_CONV (rule
);
21190 case RULE_OP_MANGLE_CHR_SHIFTL
:
21191 rule_buf
[rule_pos
] = rule_cmd
;
21192 GET_P0_CONV (rule
);
21195 case RULE_OP_MANGLE_CHR_SHIFTR
:
21196 rule_buf
[rule_pos
] = rule_cmd
;
21197 GET_P0_CONV (rule
);
21200 case RULE_OP_MANGLE_CHR_INCR
:
21201 rule_buf
[rule_pos
] = rule_cmd
;
21202 GET_P0_CONV (rule
);
21205 case RULE_OP_MANGLE_CHR_DECR
:
21206 rule_buf
[rule_pos
] = rule_cmd
;
21207 GET_P0_CONV (rule
);
21210 case RULE_OP_MANGLE_REPLACE_NP1
:
21211 rule_buf
[rule_pos
] = rule_cmd
;
21212 GET_P0_CONV (rule
);
21215 case RULE_OP_MANGLE_REPLACE_NM1
:
21216 rule_buf
[rule_pos
] = rule_cmd
;
21217 GET_P0_CONV (rule
);
21220 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21221 rule_buf
[rule_pos
] = rule_cmd
;
21222 GET_P0_CONV (rule
);
21225 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21226 rule_buf
[rule_pos
] = rule_cmd
;
21227 GET_P0_CONV (rule
);
21230 case RULE_OP_MANGLE_TITLE
:
21231 rule_buf
[rule_pos
] = rule_cmd
;
21235 return rule_pos
- 1;
21253 * CPU rules : this is from hashcat sources, cpu based rules
21256 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
21257 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
21259 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
21260 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
21261 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
21263 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
21264 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
21265 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
21267 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
21271 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
21276 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
21280 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
21285 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
21289 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
21294 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
21299 for (l
= 0; l
< arr_len
; l
++)
21301 r
= arr_len
- 1 - l
;
21305 MANGLE_SWITCH (arr
, l
, r
);
21311 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
21313 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21315 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
21317 return (arr_len
* 2);
21320 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
21322 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21324 int orig_len
= arr_len
;
21328 for (i
= 0; i
< times
; i
++)
21330 memcpy (&arr
[arr_len
], arr
, orig_len
);
21332 arr_len
+= orig_len
;
21338 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
21340 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21342 mangle_double (arr
, arr_len
);
21344 mangle_reverse (arr
+ arr_len
, arr_len
);
21346 return (arr_len
* 2);
21349 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
21354 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
21356 MANGLE_SWITCH (arr
, l
, r
);
21362 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
21367 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
21369 MANGLE_SWITCH (arr
, l
, r
);
21375 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21377 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21381 return (arr_len
+ 1);
21384 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21386 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21390 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21392 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21397 return (arr_len
+ 1);
21400 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21402 if (upos
>= arr_len
) return (arr_len
);
21406 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
21408 arr
[arr_pos
] = arr
[arr_pos
+ 1];
21411 return (arr_len
- 1);
21414 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21416 if (upos
>= arr_len
) return (arr_len
);
21418 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
21422 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
21424 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
21430 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21432 if (upos
>= arr_len
) return (arr_len
);
21434 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
21438 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
21440 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
21443 return (arr_len
- ulen
);
21446 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21448 if (upos
>= arr_len
) return (arr_len
);
21450 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21454 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
21456 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21461 return (arr_len
+ 1);
21464 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
)
21466 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21468 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
21470 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
21472 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
21474 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
21476 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
21478 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
21480 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
21482 return (arr_len
+ arr2_cpy
);
21485 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21487 if (upos
>= arr_len
) return (arr_len
);
21494 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21496 if (upos
>= arr_len
) return (arr_len
);
21498 memset (arr
+ upos
, 0, arr_len
- upos
);
21503 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
21507 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21509 if (arr
[arr_pos
] != oldc
) continue;
21511 arr
[arr_pos
] = newc
;
21517 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21523 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21525 if (arr
[arr_pos
] == c
) continue;
21527 arr
[ret_len
] = arr
[arr_pos
];
21535 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21537 if (ulen
> arr_len
) return (arr_len
);
21539 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21541 char cs
[100] = { 0 };
21543 memcpy (cs
, arr
, ulen
);
21547 for (i
= 0; i
< ulen
; i
++)
21551 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
21557 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21559 if (ulen
> arr_len
) return (arr_len
);
21561 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21563 int upos
= arr_len
- ulen
;
21567 for (i
= 0; i
< ulen
; i
++)
21569 char c
= arr
[upos
+ i
];
21571 arr_len
= mangle_append (arr
, arr_len
, c
);
21577 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21579 if ( arr_len
== 0) return (arr_len
);
21580 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21582 char c
= arr
[upos
];
21586 for (i
= 0; i
< ulen
; i
++)
21588 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
21594 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
21596 if ( arr_len
== 0) return (arr_len
);
21597 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21601 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21603 int new_pos
= arr_pos
* 2;
21605 arr
[new_pos
] = arr
[arr_pos
];
21607 arr
[new_pos
+ 1] = arr
[arr_pos
];
21610 return (arr_len
* 2);
21613 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21615 if (upos
>= arr_len
) return (arr_len
);
21616 if (upos2
>= arr_len
) return (arr_len
);
21618 MANGLE_SWITCH (arr
, upos
, upos2
);
21623 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21625 MANGLE_SWITCH (arr
, upos
, upos2
);
21630 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21632 if (upos
>= arr_len
) return (arr_len
);
21639 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21641 if (upos
>= arr_len
) return (arr_len
);
21648 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21650 if (upos
>= arr_len
) return (arr_len
);
21657 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21659 if (upos
>= arr_len
) return (arr_len
);
21666 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21668 int upper_next
= 1;
21672 for (pos
= 0; pos
< arr_len
; pos
++)
21674 if (arr
[pos
] == ' ')
21685 MANGLE_UPPER_AT (arr
, pos
);
21689 MANGLE_LOWER_AT (arr
, pos
);
21696 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21698 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21704 for (j
= 0; j
< rp_gen_num
; j
++)
21711 switch ((char) get_random_num (0, 9))
21714 r
= get_random_num (0, sizeof (grp_op_nop
));
21715 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21719 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21720 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21721 p1
= get_random_num (0, sizeof (grp_pos
));
21722 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21726 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21727 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21728 p1
= get_random_num (1, 6);
21729 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21733 r
= get_random_num (0, sizeof (grp_op_chr
));
21734 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21735 p1
= get_random_num (0x20, 0x7e);
21736 rule_buf
[rule_pos
++] = (char) p1
;
21740 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21741 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21742 p1
= get_random_num (0x20, 0x7e);
21743 rule_buf
[rule_pos
++] = (char) p1
;
21744 p2
= get_random_num (0x20, 0x7e);
21746 p2
= get_random_num (0x20, 0x7e);
21747 rule_buf
[rule_pos
++] = (char) p2
;
21751 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21752 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21753 p1
= get_random_num (0, sizeof (grp_pos
));
21754 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21755 p2
= get_random_num (0x20, 0x7e);
21756 rule_buf
[rule_pos
++] = (char) p2
;
21760 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21761 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21762 p1
= get_random_num (0, sizeof (grp_pos
));
21763 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21764 p2
= get_random_num (0, sizeof (grp_pos
));
21766 p2
= get_random_num (0, sizeof (grp_pos
));
21767 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21771 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21772 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21773 p1
= get_random_num (0, sizeof (grp_pos
));
21774 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21775 p2
= get_random_num (1, sizeof (grp_pos
));
21777 p2
= get_random_num (1, sizeof (grp_pos
));
21778 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21782 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21783 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21784 p1
= get_random_num (0, sizeof (grp_pos
));
21785 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21786 p2
= get_random_num (1, sizeof (grp_pos
));
21787 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21788 p3
= get_random_num (0, sizeof (grp_pos
));
21789 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21797 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21799 char mem
[BLOCK_SIZE
] = { 0 };
21801 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21803 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21805 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21807 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21809 int out_len
= in_len
;
21810 int mem_len
= in_len
;
21812 memcpy (out
, in
, out_len
);
21816 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21821 switch (rule
[rule_pos
])
21826 case RULE_OP_MANGLE_NOOP
:
21829 case RULE_OP_MANGLE_LREST
:
21830 out_len
= mangle_lrest (out
, out_len
);
21833 case RULE_OP_MANGLE_UREST
:
21834 out_len
= mangle_urest (out
, out_len
);
21837 case RULE_OP_MANGLE_LREST_UFIRST
:
21838 out_len
= mangle_lrest (out
, out_len
);
21839 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21842 case RULE_OP_MANGLE_UREST_LFIRST
:
21843 out_len
= mangle_urest (out
, out_len
);
21844 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21847 case RULE_OP_MANGLE_TREST
:
21848 out_len
= mangle_trest (out
, out_len
);
21851 case RULE_OP_MANGLE_TOGGLE_AT
:
21852 NEXT_RULEPOS (rule_pos
);
21853 NEXT_RPTOI (rule
, rule_pos
, upos
);
21854 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21857 case RULE_OP_MANGLE_REVERSE
:
21858 out_len
= mangle_reverse (out
, out_len
);
21861 case RULE_OP_MANGLE_DUPEWORD
:
21862 out_len
= mangle_double (out
, out_len
);
21865 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21866 NEXT_RULEPOS (rule_pos
);
21867 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21868 out_len
= mangle_double_times (out
, out_len
, ulen
);
21871 case RULE_OP_MANGLE_REFLECT
:
21872 out_len
= mangle_reflect (out
, out_len
);
21875 case RULE_OP_MANGLE_ROTATE_LEFT
:
21876 mangle_rotate_left (out
, out_len
);
21879 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21880 mangle_rotate_right (out
, out_len
);
21883 case RULE_OP_MANGLE_APPEND
:
21884 NEXT_RULEPOS (rule_pos
);
21885 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
21888 case RULE_OP_MANGLE_PREPEND
:
21889 NEXT_RULEPOS (rule_pos
);
21890 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
21893 case RULE_OP_MANGLE_DELETE_FIRST
:
21894 out_len
= mangle_delete_at (out
, out_len
, 0);
21897 case RULE_OP_MANGLE_DELETE_LAST
:
21898 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
21901 case RULE_OP_MANGLE_DELETE_AT
:
21902 NEXT_RULEPOS (rule_pos
);
21903 NEXT_RPTOI (rule
, rule_pos
, upos
);
21904 out_len
= mangle_delete_at (out
, out_len
, upos
);
21907 case RULE_OP_MANGLE_EXTRACT
:
21908 NEXT_RULEPOS (rule_pos
);
21909 NEXT_RPTOI (rule
, rule_pos
, upos
);
21910 NEXT_RULEPOS (rule_pos
);
21911 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21912 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
21915 case RULE_OP_MANGLE_OMIT
:
21916 NEXT_RULEPOS (rule_pos
);
21917 NEXT_RPTOI (rule
, rule_pos
, upos
);
21918 NEXT_RULEPOS (rule_pos
);
21919 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21920 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
21923 case RULE_OP_MANGLE_INSERT
:
21924 NEXT_RULEPOS (rule_pos
);
21925 NEXT_RPTOI (rule
, rule_pos
, upos
);
21926 NEXT_RULEPOS (rule_pos
);
21927 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
21930 case RULE_OP_MANGLE_OVERSTRIKE
:
21931 NEXT_RULEPOS (rule_pos
);
21932 NEXT_RPTOI (rule
, rule_pos
, upos
);
21933 NEXT_RULEPOS (rule_pos
);
21934 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
21937 case RULE_OP_MANGLE_TRUNCATE_AT
:
21938 NEXT_RULEPOS (rule_pos
);
21939 NEXT_RPTOI (rule
, rule_pos
, upos
);
21940 out_len
= mangle_truncate_at (out
, out_len
, upos
);
21943 case RULE_OP_MANGLE_REPLACE
:
21944 NEXT_RULEPOS (rule_pos
);
21945 NEXT_RULEPOS (rule_pos
);
21946 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
21949 case RULE_OP_MANGLE_PURGECHAR
:
21950 NEXT_RULEPOS (rule_pos
);
21951 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
21954 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21958 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21959 NEXT_RULEPOS (rule_pos
);
21960 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21961 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
21964 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21965 NEXT_RULEPOS (rule_pos
);
21966 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21967 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
21970 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21971 out_len
= mangle_dupechar (out
, out_len
);
21974 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21975 NEXT_RULEPOS (rule_pos
);
21976 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21977 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
21980 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21981 NEXT_RULEPOS (rule_pos
);
21982 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21983 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
21986 case RULE_OP_MANGLE_SWITCH_FIRST
:
21987 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
21990 case RULE_OP_MANGLE_SWITCH_LAST
:
21991 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
21994 case RULE_OP_MANGLE_SWITCH_AT
:
21995 NEXT_RULEPOS (rule_pos
);
21996 NEXT_RPTOI (rule
, rule_pos
, upos
);
21997 NEXT_RULEPOS (rule_pos
);
21998 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21999 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
22002 case RULE_OP_MANGLE_CHR_SHIFTL
:
22003 NEXT_RULEPOS (rule_pos
);
22004 NEXT_RPTOI (rule
, rule_pos
, upos
);
22005 mangle_chr_shiftl (out
, out_len
, upos
);
22008 case RULE_OP_MANGLE_CHR_SHIFTR
:
22009 NEXT_RULEPOS (rule_pos
);
22010 NEXT_RPTOI (rule
, rule_pos
, upos
);
22011 mangle_chr_shiftr (out
, out_len
, upos
);
22014 case RULE_OP_MANGLE_CHR_INCR
:
22015 NEXT_RULEPOS (rule_pos
);
22016 NEXT_RPTOI (rule
, rule_pos
, upos
);
22017 mangle_chr_incr (out
, out_len
, upos
);
22020 case RULE_OP_MANGLE_CHR_DECR
:
22021 NEXT_RULEPOS (rule_pos
);
22022 NEXT_RPTOI (rule
, rule_pos
, upos
);
22023 mangle_chr_decr (out
, out_len
, upos
);
22026 case RULE_OP_MANGLE_REPLACE_NP1
:
22027 NEXT_RULEPOS (rule_pos
);
22028 NEXT_RPTOI (rule
, rule_pos
, upos
);
22029 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
22032 case RULE_OP_MANGLE_REPLACE_NM1
:
22033 NEXT_RULEPOS (rule_pos
);
22034 NEXT_RPTOI (rule
, rule_pos
, upos
);
22035 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
22038 case RULE_OP_MANGLE_TITLE
:
22039 out_len
= mangle_title (out
, out_len
);
22042 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
22043 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22044 NEXT_RULEPOS (rule_pos
);
22045 NEXT_RPTOI (rule
, rule_pos
, upos
);
22046 NEXT_RULEPOS (rule_pos
);
22047 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22048 NEXT_RULEPOS (rule_pos
);
22049 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22050 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
22053 case RULE_OP_MANGLE_APPEND_MEMORY
:
22054 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22055 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22056 memcpy (out
+ out_len
, mem
, mem_len
);
22057 out_len
+= mem_len
;
22060 case RULE_OP_MANGLE_PREPEND_MEMORY
:
22061 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22062 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22063 memcpy (mem
+ mem_len
, out
, out_len
);
22064 out_len
+= mem_len
;
22065 memcpy (out
, mem
, out_len
);
22068 case RULE_OP_MEMORIZE_WORD
:
22069 memcpy (mem
, out
, out_len
);
22073 case RULE_OP_REJECT_LESS
:
22074 NEXT_RULEPOS (rule_pos
);
22075 NEXT_RPTOI (rule
, rule_pos
, upos
);
22076 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
22079 case RULE_OP_REJECT_GREATER
:
22080 NEXT_RULEPOS (rule_pos
);
22081 NEXT_RPTOI (rule
, rule_pos
, upos
);
22082 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
22085 case RULE_OP_REJECT_CONTAIN
:
22086 NEXT_RULEPOS (rule_pos
);
22087 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
22090 case RULE_OP_REJECT_NOT_CONTAIN
:
22091 NEXT_RULEPOS (rule_pos
);
22092 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
22095 case RULE_OP_REJECT_EQUAL_FIRST
:
22096 NEXT_RULEPOS (rule_pos
);
22097 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22100 case RULE_OP_REJECT_EQUAL_LAST
:
22101 NEXT_RULEPOS (rule_pos
);
22102 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22105 case RULE_OP_REJECT_EQUAL_AT
:
22106 NEXT_RULEPOS (rule_pos
);
22107 NEXT_RPTOI (rule
, rule_pos
, upos
);
22108 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22109 NEXT_RULEPOS (rule_pos
);
22110 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22113 case RULE_OP_REJECT_CONTAINS
:
22114 NEXT_RULEPOS (rule_pos
);
22115 NEXT_RPTOI (rule
, rule_pos
, upos
);
22116 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22117 NEXT_RULEPOS (rule_pos
);
22118 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
22119 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
22122 case RULE_OP_REJECT_MEMORY
:
22123 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
22127 return (RULE_RC_SYNTAX_ERROR
);
22132 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);