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_temperature_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
].vendor_id
== VENDOR_ID_AMD
)
3069 if (data
.hm_device
[device_id
].od_version
== 5)
3071 ADLTemperature Temperature
;
3073 Temperature
.iSize
= sizeof (ADLTemperature
);
3075 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3077 return Temperature
.iTemperature
/ 1000;
3079 else if (data
.hm_device
[device_id
].od_version
== 6)
3081 int Temperature
= 0;
3083 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3085 return Temperature
/ 1000;
3091 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3092 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3094 #if defined(LINUX) && defined(HAVE_NVML)
3095 int temperature
= 0;
3097 hm_NVML_nvmlDeviceGetTemperature (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
);
3102 #if defined(WIN) && defined(HAVE_NVAPI)
3103 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3105 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3106 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3107 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3108 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3110 if (hm_NvAPI_GPU_GetThermalSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3112 return pThermalSettings
.sensor
[0].currentTemp
;
3113 #endif // WIN && HAVE_NVAPI
3115 #endif // HAVE_NVML || HAVE_NVAPI
3120 int hm_get_fanspeed_with_device_id (const uint device_id
)
3122 // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
3123 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3125 if (data
.hm_device
[device_id
].fan_supported
== 1)
3128 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3132 if (data
.hm_device
[device_id
].od_version
== 5)
3134 ADLFanSpeedValue lpFanSpeedValue
;
3136 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3138 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3139 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3140 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3142 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3144 return lpFanSpeedValue
.iFanSpeed
;
3146 else // od_version == 6
3148 ADLOD6FanSpeedInfo faninfo
;
3150 memset (&faninfo
, 0, sizeof (faninfo
));
3152 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3154 return faninfo
.iFanSpeedPercent
;
3160 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3161 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3163 #if defined(LINUX) && defined(HAVE_NVML)
3166 hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (uint
*) &speed
);
3171 #if defined(WIN) && defined(HAVE_NVAPI)
3173 NV_GPU_COOLER_SETTINGS pCoolerSettings
;
3175 pCoolerSettings
.Version
= GPU_COOLER_SETTINGS_VER
| sizeof (NV_GPU_COOLER_SETTINGS
);
3177 hm_NvAPI_GPU_GetCoolerSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pCoolerSettings
);
3179 return pCoolerSettings
.Cooler
[0].CurrentLevel
;
3182 #endif // HAVE_NVML || HAVE_NVAPI
3188 int hm_get_utilization_with_device_id (const uint device_id
)
3190 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3193 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3197 ADLPMActivity PMActivity
;
3199 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3201 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3203 return PMActivity
.iActivityPercent
;
3208 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3209 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3211 #if defined(LINUX) && defined(HAVE_NVML)
3212 nvmlUtilization_t utilization
;
3214 hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3216 return utilization
.gpu
;
3219 #if defined(WIN) && defined(HAVE_NVAPI)
3220 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3222 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3224 if (hm_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3226 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3229 #endif // HAVE_NVML || HAVE_NVAPI
3235 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3237 if (data
.hm_device
[device_id
].fan_supported
== 1)
3241 if (data
.hm_device
[device_id
].od_version
== 5)
3243 ADLFanSpeedValue lpFanSpeedValue
;
3245 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3247 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3248 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3249 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3250 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3252 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3256 else // od_version == 6
3258 ADLOD6FanSpeedValue fan_speed_value
;
3260 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3262 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3263 fan_speed_value
.iFanSpeed
= fanspeed
;
3265 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3276 // helper function for status display
3278 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3280 #define VALUE_NOT_AVAILABLE "N/A"
3284 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3288 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3291 #endif // HAVE_HWMON
3297 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3299 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3301 if (css_cnt
> SP_PW_MAX
)
3303 log_error ("ERROR: mask length is too long");
3308 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3310 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3312 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3313 uint cs_len
= css
[css_pos
].cs_len
;
3315 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3317 uint c
= cs_buf
[cs_pos
] & 0xff;
3324 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3326 cs_t
*cs
= &css
[css_cnt
];
3328 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3330 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3334 for (i
= 0; i
< cs
->cs_len
; i
++)
3336 const uint u
= cs
->cs_buf
[i
];
3341 for (i
= 0; i
< in_len
; i
++)
3343 uint u
= in_buf
[i
] & 0xff;
3345 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3347 if (css_uniq
[u
] == 1) continue;
3351 cs
->cs_buf
[cs
->cs_len
] = u
;
3359 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3363 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3365 uint p0
= in_buf
[in_pos
] & 0xff;
3367 if (interpret
== 1 && p0
== '?')
3371 if (in_pos
== in_len
) break;
3373 uint p1
= in_buf
[in_pos
] & 0xff;
3377 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3379 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3381 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3383 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3385 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3387 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3389 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3390 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3392 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3393 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3395 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3396 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3398 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3399 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3401 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3403 default: log_error ("Syntax error: %s", in_buf
);
3409 if (data
.hex_charset
)
3413 if (in_pos
== in_len
)
3415 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3420 uint p1
= in_buf
[in_pos
] & 0xff;
3422 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3424 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3431 chr
= hex_convert (p1
) << 0;
3432 chr
|= hex_convert (p0
) << 4;
3434 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3440 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3446 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3450 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3452 sum
*= css
[css_pos
].cs_len
;
3458 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3460 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3465 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3467 char p0
= mask_buf
[mask_pos
];
3473 if (mask_pos
== mask_len
) break;
3475 char p1
= mask_buf
[mask_pos
];
3481 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3483 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3485 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3487 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3489 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3491 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3493 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3494 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3496 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3497 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3499 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3500 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3502 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3503 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3505 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3507 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3513 if (data
.hex_charset
)
3517 // if there is no 2nd hex character, show an error:
3519 if (mask_pos
== mask_len
)
3521 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3526 char p1
= mask_buf
[mask_pos
];
3528 // if they are not valid hex character, show an error:
3530 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3532 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3539 chr
|= hex_convert (p1
) << 0;
3540 chr
|= hex_convert (p0
) << 4;
3542 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3548 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3555 log_error ("ERROR: invalid mask length (0)");
3565 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3567 for (int i
= 0; i
< css_cnt
; i
++)
3569 uint len
= css
[i
].cs_len
;
3570 u64 next
= val
/ len
;
3571 uint pos
= val
% len
;
3572 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3577 void mp_cut_at (char *mask
, uint max
)
3581 uint mask_len
= strlen (mask
);
3583 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3585 if (mask
[i
] == '?') i
++;
3591 void mp_setup_sys (cs_t
*mp_sys
)
3595 uint donec
[CHARSIZ
] = { 0 };
3597 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3598 mp_sys
[0].cs_buf
[pos
++] = chr
;
3599 mp_sys
[0].cs_len
= pos
; }
3601 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3602 mp_sys
[1].cs_buf
[pos
++] = chr
;
3603 mp_sys
[1].cs_len
= pos
; }
3605 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3606 mp_sys
[2].cs_buf
[pos
++] = chr
;
3607 mp_sys
[2].cs_len
= pos
; }
3609 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3610 mp_sys
[3].cs_buf
[pos
++] = chr
;
3611 mp_sys
[3].cs_len
= pos
; }
3613 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3614 mp_sys
[4].cs_len
= pos
; }
3616 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3617 mp_sys
[5].cs_len
= pos
; }
3620 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3622 FILE *fp
= fopen (buf
, "rb");
3624 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3626 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3630 char mp_file
[1024] = { 0 };
3632 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3636 len
= in_superchop (mp_file
);
3640 log_info ("WARNING: charset file corrupted");
3642 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3646 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3651 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3653 mp_usr
[index
].cs_len
= 0;
3655 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3658 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3660 char *new_mask_buf
= (char *) mymalloc (256);
3666 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3668 if (css_pos
== len
) break;
3670 char p0
= mask_buf
[mask_pos
];
3672 new_mask_buf
[mask_pos
] = p0
;
3678 if (mask_pos
== mask_len
) break;
3680 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3684 if (data
.hex_charset
)
3688 if (mask_pos
== mask_len
)
3690 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3695 char p1
= mask_buf
[mask_pos
];
3697 // if they are not valid hex character, show an error:
3699 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3701 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3706 new_mask_buf
[mask_pos
] = p1
;
3711 if (css_pos
== len
) return (new_mask_buf
);
3713 myfree (new_mask_buf
);
3722 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3728 for (i
= start
; i
< stop
; i
++)
3730 sum
*= root_css_buf
[i
].cs_len
;
3736 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3740 cs_t
*cs
= &root_css_buf
[start
];
3744 for (i
= start
; i
< stop
; i
++)
3746 const u64 m
= v
% cs
->cs_len
;
3747 const u64 d
= v
/ cs
->cs_len
;
3751 const uint k
= cs
->cs_buf
[m
];
3753 pw_buf
[i
- start
] = (char) k
;
3755 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3759 int sp_comp_val (const void *p1
, const void *p2
)
3761 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3762 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3764 return b2
->val
- b1
->val
;
3767 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
)
3774 * Initialize hcstats
3777 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3779 u64
*root_stats_ptr
= root_stats_buf
;
3781 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3783 for (i
= 0; i
< SP_PW_MAX
; i
++)
3785 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3787 root_stats_ptr
+= CHARSIZ
;
3790 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3792 u64
*markov_stats_ptr
= markov_stats_buf
;
3794 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3796 for (i
= 0; i
< SP_PW_MAX
; i
++)
3798 for (j
= 0; j
< CHARSIZ
; j
++)
3800 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3802 markov_stats_ptr
+= CHARSIZ
;
3812 char hcstat_tmp
[256] = { 0 };
3814 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3816 hcstat
= hcstat_tmp
;
3819 FILE *fd
= fopen (hcstat
, "rb");
3823 log_error ("%s: %s", hcstat
, strerror (errno
));
3828 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3830 log_error ("%s: Could not load data", hcstat
);
3837 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3839 log_error ("%s: Could not load data", hcstat
);
3849 * Markov modifier of hcstat_table on user request
3854 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
3855 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
3860 /* Add all stats to first position */
3862 for (i
= 1; i
< SP_PW_MAX
; i
++)
3864 u64
*out
= root_stats_buf_by_pos
[0];
3865 u64
*in
= root_stats_buf_by_pos
[i
];
3867 for (j
= 0; j
< CHARSIZ
; j
++)
3873 for (i
= 1; i
< SP_PW_MAX
; i
++)
3875 u64
*out
= markov_stats_buf_by_key
[0][0];
3876 u64
*in
= markov_stats_buf_by_key
[i
][0];
3878 for (j
= 0; j
< CHARSIZ
; j
++)
3880 for (k
= 0; k
< CHARSIZ
; k
++)
3887 /* copy them to all pw_positions */
3889 for (i
= 1; i
< SP_PW_MAX
; i
++)
3891 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
3894 for (i
= 1; i
< SP_PW_MAX
; i
++)
3896 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
3904 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3906 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3908 for (i
= 0; i
< SP_PW_MAX
; i
++)
3910 root_table_buf_by_pos
[i
] = root_table_ptr
;
3912 root_table_ptr
+= CHARSIZ
;
3915 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3917 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3919 for (i
= 0; i
< SP_PW_MAX
; i
++)
3921 for (j
= 0; j
< CHARSIZ
; j
++)
3923 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3925 markov_table_ptr
+= CHARSIZ
;
3930 * Convert hcstat to tables
3933 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3935 uint key
= i
% CHARSIZ
;
3937 root_table_buf
[i
].key
= key
;
3938 root_table_buf
[i
].val
= root_stats_buf
[i
];
3941 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3943 uint key
= i
% CHARSIZ
;
3945 markov_table_buf
[i
].key
= key
;
3946 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3949 myfree (root_stats_buf
);
3950 myfree (markov_stats_buf
);
3956 for (i
= 0; i
< SP_PW_MAX
; i
++)
3958 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3961 for (i
= 0; i
< SP_PW_MAX
; i
++)
3963 for (j
= 0; j
< CHARSIZ
; j
++)
3965 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3970 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
])
3973 * Convert tables to css
3976 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
3978 uint pw_pos
= i
/ CHARSIZ
;
3980 cs_t
*cs
= &root_css_buf
[pw_pos
];
3982 if (cs
->cs_len
== threshold
) continue;
3984 uint key
= root_table_buf
[i
].key
;
3986 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
3988 cs
->cs_buf
[cs
->cs_len
] = key
;
3994 * Convert table to css
3997 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
3999 uint c
= i
/ CHARSIZ
;
4001 cs_t
*cs
= &markov_css_buf
[c
];
4003 if (cs
->cs_len
== threshold
) continue;
4005 uint pw_pos
= c
/ CHARSIZ
;
4007 uint key
= markov_table_buf
[i
].key
;
4009 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4011 cs
->cs_buf
[cs
->cs_len
] = key
;
4017 for (uint i = 0; i < 8; i++)
4019 for (uint j = 0x20; j < 0x80; j++)
4021 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4023 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4025 for (uint k = 0; k < 10; k++)
4027 printf (" %u\n", ptr->cs_buf[k]);
4034 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4036 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4038 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4048 for (uint j
= 1; j
< CHARSIZ
; j
++)
4058 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4060 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4062 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4064 out
+= CHARSIZ
* CHARSIZ
;
4065 in
+= CHARSIZ
* CHARSIZ
;
4067 for (uint j
= 0; j
< CHARSIZ
; j
++)
4074 for (uint k
= 1; k
< CHARSIZ
; k
++)
4086 * mixed shared functions
4089 void dump_hex (const u8
*s
, const int sz
)
4091 for (int i
= 0; i
< sz
; i
++)
4093 log_info_nn ("%02x ", s
[i
]);
4099 void usage_mini_print (const char *progname
)
4101 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4104 void usage_big_print (const char *progname
)
4106 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4109 char *get_exec_path ()
4111 int exec_path_len
= 1024;
4113 char *exec_path
= (char *) mymalloc (exec_path_len
);
4117 char tmp
[32] = { 0 };
4119 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4121 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4125 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4129 uint size
= exec_path_len
;
4131 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4133 log_error("! executable path buffer too small\n");
4138 const int len
= strlen (exec_path
);
4141 #error Your Operating System is not supported or detected
4149 char *get_install_dir (const char *progname
)
4151 char *install_dir
= mystrdup (progname
);
4152 char *last_slash
= NULL
;
4154 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4158 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4164 install_dir
[0] = '.';
4168 return (install_dir
);
4171 char *get_profile_dir (const char *homedir
)
4173 #define DOT_HASHCAT ".hashcat"
4175 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4177 char *profile_dir
= (char *) mymalloc (len
+ 1);
4179 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4184 char *get_session_dir (const char *profile_dir
)
4186 #define SESSIONS_FOLDER "sessions"
4188 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4190 char *session_dir
= (char *) mymalloc (len
+ 1);
4192 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4197 uint
count_lines (FILE *fd
)
4201 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4207 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4209 if (nread
< 1) continue;
4213 for (i
= 0; i
< nread
; i
++)
4215 if (prev
== '\n') cnt
++;
4226 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4230 FILE *fd
= fopen (filename
, "rb");
4234 log_error ("%s: %s", filename
, strerror (errno
));
4239 #define MAX_KEY_SIZE (1024 * 1024)
4241 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4243 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4249 for (int fpos
= 0; fpos
< nread
; fpos
++)
4251 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4253 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4254 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4255 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4256 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4258 if (kpos
>= 64) kpos
= 0;
4265 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4269 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4270 if (CPU_ISSET(core
, cpu_set
)) break;
4272 thread_affinity_policy_data_t policy
= { core
};
4274 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4276 if (data
.quiet
== 0)
4278 if (rc
!= KERN_SUCCESS
)
4280 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4288 void set_cpu_affinity (char *cpu_affinity
)
4291 DWORD_PTR aff_mask
= 0;
4299 char *devices
= strdup (cpu_affinity
);
4301 char *next
= strtok (devices
, ",");
4305 uint cpu_id
= atoi (next
);
4320 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4326 aff_mask
|= 1 << (cpu_id
- 1);
4328 CPU_SET ((cpu_id
- 1), &cpuset
);
4331 } while ((next
= strtok (NULL
, ",")) != NULL
);
4337 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4338 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4340 pthread_t thread
= pthread_self ();
4341 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4345 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4347 char *element
, *end
;
4349 end
= (char *) base
+ nmemb
* size
;
4351 for (element
= (char *) base
; element
< end
; element
+= size
)
4352 if (!compar (element
, key
))
4358 int sort_by_u32 (const void *v1
, const void *v2
)
4360 const u32
*s1
= (const u32
*) v1
;
4361 const u32
*s2
= (const u32
*) v2
;
4366 int sort_by_salt (const void *v1
, const void *v2
)
4368 const salt_t
*s1
= (const salt_t
*) v1
;
4369 const salt_t
*s2
= (const salt_t
*) v2
;
4371 const int res1
= s1
->salt_len
- s2
->salt_len
;
4373 if (res1
!= 0) return (res1
);
4375 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4377 if (res2
!= 0) return (res2
);
4385 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4386 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4393 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4394 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4400 int sort_by_salt_buf (const void *v1
, const void *v2
)
4402 const pot_t
*p1
= (const pot_t
*) v1
;
4403 const pot_t
*p2
= (const pot_t
*) v2
;
4405 const hash_t
*h1
= &p1
->hash
;
4406 const hash_t
*h2
= &p2
->hash
;
4408 const salt_t
*s1
= h1
->salt
;
4409 const salt_t
*s2
= h2
->salt
;
4415 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4416 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4422 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4424 const hash_t
*h1
= (const hash_t
*) v1
;
4425 const hash_t
*h2
= (const hash_t
*) v2
;
4427 const salt_t
*s1
= h1
->salt
;
4428 const salt_t
*s2
= h2
->salt
;
4430 // testphase: this should work
4435 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4436 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4439 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4440 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4441 if (s1->salt_len > s2->salt_len) return ( 1);
4442 if (s1->salt_len < s2->salt_len) return (-1);
4444 uint n = s1->salt_len;
4448 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4449 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4456 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4458 const hash_t
*h1
= (const hash_t
*) v1
;
4459 const hash_t
*h2
= (const hash_t
*) v2
;
4461 const salt_t
*s1
= h1
->salt
;
4462 const salt_t
*s2
= h2
->salt
;
4464 // 16 - 2 (since last 2 uints contain the digest)
4469 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4470 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4476 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4478 const hash_t
*h1
= (const hash_t
*) v1
;
4479 const hash_t
*h2
= (const hash_t
*) v2
;
4481 const void *d1
= h1
->digest
;
4482 const void *d2
= h2
->digest
;
4484 return data
.sort_by_digest (d1
, d2
);
4487 int sort_by_hash (const void *v1
, const void *v2
)
4489 const hash_t
*h1
= (const hash_t
*) v1
;
4490 const hash_t
*h2
= (const hash_t
*) v2
;
4494 const salt_t
*s1
= h1
->salt
;
4495 const salt_t
*s2
= h2
->salt
;
4497 int res
= sort_by_salt (s1
, s2
);
4499 if (res
!= 0) return (res
);
4502 const void *d1
= h1
->digest
;
4503 const void *d2
= h2
->digest
;
4505 return data
.sort_by_digest (d1
, d2
);
4508 int sort_by_pot (const void *v1
, const void *v2
)
4510 const pot_t
*p1
= (const pot_t
*) v1
;
4511 const pot_t
*p2
= (const pot_t
*) v2
;
4513 const hash_t
*h1
= &p1
->hash
;
4514 const hash_t
*h2
= &p2
->hash
;
4516 return sort_by_hash (h1
, h2
);
4519 int sort_by_mtime (const void *p1
, const void *p2
)
4521 const char **f1
= (const char **) p1
;
4522 const char **f2
= (const char **) p2
;
4524 struct stat s1
; stat (*f1
, &s1
);
4525 struct stat s2
; stat (*f2
, &s2
);
4527 return s2
.st_mtime
- s1
.st_mtime
;
4530 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4532 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4533 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4535 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4538 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4540 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4541 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4543 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4546 int sort_by_stringptr (const void *p1
, const void *p2
)
4548 const char **s1
= (const char **) p1
;
4549 const char **s2
= (const char **) p2
;
4551 return strcmp (*s1
, *s2
);
4554 int sort_by_dictstat (const void *s1
, const void *s2
)
4556 dictstat_t
*d1
= (dictstat_t
*) s1
;
4557 dictstat_t
*d2
= (dictstat_t
*) s2
;
4560 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4562 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4565 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4568 int sort_by_bitmap (const void *p1
, const void *p2
)
4570 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4571 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4573 return b1
->collisions
- b2
->collisions
;
4576 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4578 const u32
*d1
= (const u32
*) v1
;
4579 const u32
*d2
= (const u32
*) v2
;
4585 if (d1
[n
] > d2
[n
]) return ( 1);
4586 if (d1
[n
] < d2
[n
]) return (-1);
4592 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4594 const u32
*d1
= (const u32
*) v1
;
4595 const u32
*d2
= (const u32
*) v2
;
4601 if (d1
[n
] > d2
[n
]) return ( 1);
4602 if (d1
[n
] < d2
[n
]) return (-1);
4608 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4610 const u32
*d1
= (const u32
*) v1
;
4611 const u32
*d2
= (const u32
*) v2
;
4617 if (d1
[n
] > d2
[n
]) return ( 1);
4618 if (d1
[n
] < d2
[n
]) return (-1);
4624 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4626 const u32
*d1
= (const u32
*) v1
;
4627 const u32
*d2
= (const u32
*) v2
;
4633 if (d1
[n
] > d2
[n
]) return ( 1);
4634 if (d1
[n
] < d2
[n
]) return (-1);
4640 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4642 const u32
*d1
= (const u32
*) v1
;
4643 const u32
*d2
= (const u32
*) v2
;
4649 if (d1
[n
] > d2
[n
]) return ( 1);
4650 if (d1
[n
] < d2
[n
]) return (-1);
4656 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4658 const u32
*d1
= (const u32
*) v1
;
4659 const u32
*d2
= (const u32
*) v2
;
4665 if (d1
[n
] > d2
[n
]) return ( 1);
4666 if (d1
[n
] < d2
[n
]) return (-1);
4672 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4674 const u32
*d1
= (const u32
*) v1
;
4675 const u32
*d2
= (const u32
*) v2
;
4681 if (d1
[n
] > d2
[n
]) return ( 1);
4682 if (d1
[n
] < d2
[n
]) return (-1);
4688 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4690 const u32
*d1
= (const u32
*) v1
;
4691 const u32
*d2
= (const u32
*) v2
;
4697 if (d1
[n
] > d2
[n
]) return ( 1);
4698 if (d1
[n
] < d2
[n
]) return (-1);
4704 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4706 const u64
*d1
= (const u64
*) v1
;
4707 const u64
*d2
= (const u64
*) v2
;
4713 if (d1
[n
] > d2
[n
]) return ( 1);
4714 if (d1
[n
] < d2
[n
]) return (-1);
4720 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4722 const u64
*d1
= (const u64
*) v1
;
4723 const u64
*d2
= (const u64
*) v2
;
4729 if (d1
[n
] > d2
[n
]) return ( 1);
4730 if (d1
[n
] < d2
[n
]) return (-1);
4736 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4738 const u64
*d1
= (const u64
*) v1
;
4739 const u64
*d2
= (const u64
*) v2
;
4745 if (d1
[n
] > d2
[n
]) return ( 1);
4746 if (d1
[n
] < d2
[n
]) return (-1);
4752 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4754 const u32
*d1
= (const u32
*) v1
;
4755 const u32
*d2
= (const u32
*) v2
;
4757 const uint dgst_pos0
= data
.dgst_pos0
;
4758 const uint dgst_pos1
= data
.dgst_pos1
;
4759 const uint dgst_pos2
= data
.dgst_pos2
;
4760 const uint dgst_pos3
= data
.dgst_pos3
;
4762 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4763 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4764 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4765 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4766 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4767 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4768 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4769 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4774 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4776 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4777 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4779 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4781 if (res1
!= 0) return (res1
);
4786 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4788 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4789 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4791 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4793 if (res1
!= 0) return (res1
);
4795 const int res2
= t1
->attack_mode
4798 if (res2
!= 0) return (res2
);
4800 const int res3
= t1
->hash_type
4803 if (res3
!= 0) return (res3
);
4808 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
)
4810 uint outfile_autohex
= data
.outfile_autohex
;
4812 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4814 FILE *debug_fp
= NULL
;
4816 if (debug_file
!= NULL
)
4818 debug_fp
= fopen (debug_file
, "ab");
4820 lock_file (debug_fp
);
4827 if (debug_fp
== NULL
)
4829 log_info ("WARNING: Could not open debug-file for writing");
4833 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4835 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4837 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4840 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4842 if (debug_mode
== 4)
4844 fputc (':', debug_fp
);
4846 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4849 fputc ('\n', debug_fp
);
4851 if (debug_file
!= NULL
) fclose (debug_fp
);
4855 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4857 int needs_hexify
= 0;
4859 if (outfile_autohex
== 1)
4861 for (uint i
= 0; i
< plain_len
; i
++)
4863 if (plain_ptr
[i
] < 0x20)
4870 if (plain_ptr
[i
] > 0x7f)
4879 if (needs_hexify
== 1)
4881 fprintf (fp
, "$HEX[");
4883 for (uint i
= 0; i
< plain_len
; i
++)
4885 fprintf (fp
, "%02x", plain_ptr
[i
]);
4892 fwrite (plain_ptr
, plain_len
, 1, fp
);
4896 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
)
4898 uint outfile_format
= data
.outfile_format
;
4900 char separator
= data
.separator
;
4902 if (outfile_format
& OUTFILE_FMT_HASH
)
4904 fprintf (out_fp
, "%s", out_buf
);
4906 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4908 fputc (separator
, out_fp
);
4911 else if (data
.username
)
4913 if (username
!= NULL
)
4915 for (uint i
= 0; i
< user_len
; i
++)
4917 fprintf (out_fp
, "%c", username
[i
]);
4920 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4922 fputc (separator
, out_fp
);
4927 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4929 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4931 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4933 fputc (separator
, out_fp
);
4937 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4939 for (uint i
= 0; i
< plain_len
; i
++)
4941 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4944 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4946 fputc (separator
, out_fp
);
4950 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4953 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4958 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
4960 fprintf (out_fp
, "%llu", crackpos
);
4965 fputc ('\n', out_fp
);
4968 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
)
4972 pot_key
.hash
.salt
= hashes_buf
->salt
;
4973 pot_key
.hash
.digest
= hashes_buf
->digest
;
4975 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4981 input_buf
[input_len
] = 0;
4984 unsigned char *username
= NULL
;
4989 user_t
*user
= hashes_buf
->hash_info
->user
;
4993 username
= (unsigned char *) (user
->user_name
);
4995 user_len
= user
->user_len
;
4999 // do output the line
5000 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5004 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5005 #define LM_MASKED_PLAIN "[notfound]"
5007 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
)
5013 pot_left_key
.hash
.salt
= hash_left
->salt
;
5014 pot_left_key
.hash
.digest
= hash_left
->digest
;
5016 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5020 uint weak_hash_found
= 0;
5022 pot_t pot_right_key
;
5024 pot_right_key
.hash
.salt
= hash_right
->salt
;
5025 pot_right_key
.hash
.digest
= hash_right
->digest
;
5027 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5029 if (pot_right_ptr
== NULL
)
5031 // special case, if "weak hash"
5033 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5035 weak_hash_found
= 1;
5037 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5039 // in theory this is not needed, but we are paranoia:
5041 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5042 pot_right_ptr
->plain_len
= 0;
5046 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5048 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
5053 // at least one half was found:
5057 input_buf
[input_len
] = 0;
5061 unsigned char *username
= NULL
;
5066 user_t
*user
= hash_left
->hash_info
->user
;
5070 username
= (unsigned char *) (user
->user_name
);
5072 user_len
= user
->user_len
;
5076 // mask the part which was not found
5078 uint left_part_masked
= 0;
5079 uint right_part_masked
= 0;
5081 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5083 if (pot_left_ptr
== NULL
)
5085 left_part_masked
= 1;
5087 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5089 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5091 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5092 pot_left_ptr
->plain_len
= mask_plain_len
;
5095 if (pot_right_ptr
== NULL
)
5097 right_part_masked
= 1;
5099 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5101 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5103 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5104 pot_right_ptr
->plain_len
= mask_plain_len
;
5107 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5111 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5113 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5115 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5117 // do output the line
5119 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5121 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5123 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5124 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5127 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
)
5131 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5133 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5135 if (pot_ptr
== NULL
)
5139 input_buf
[input_len
] = 0;
5141 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5145 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
)
5151 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5153 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5157 pot_t pot_right_key
;
5159 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5161 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5163 uint weak_hash_found
= 0;
5165 if (pot_right_ptr
== NULL
)
5167 // special case, if "weak hash"
5169 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5171 weak_hash_found
= 1;
5173 // we just need that pot_right_ptr is not a NULL pointer
5175 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5179 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5181 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5186 // ... at least one part was not cracked
5190 input_buf
[input_len
] = 0;
5192 // only show the hash part which is still not cracked
5194 uint user_len
= input_len
- 32;
5196 char *hash_output
= (char *) mymalloc (33);
5198 memcpy (hash_output
, input_buf
, input_len
);
5200 if (pot_left_ptr
!= NULL
)
5202 // only show right part (because left part was already found)
5204 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5206 hash_output
[user_len
+ 16] = 0;
5209 if (pot_right_ptr
!= NULL
)
5211 // only show left part (because right part was already found)
5213 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5215 hash_output
[user_len
+ 16] = 0;
5218 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5220 myfree (hash_output
);
5222 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5225 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5227 uint opencl_platforms_filter
= 0;
5229 if (opencl_platforms
)
5231 char *platforms
= strdup (opencl_platforms
);
5233 char *next
= strtok (platforms
, ",");
5237 int platform
= atoi (next
);
5239 if (platform
< 1 || platform
> 32)
5241 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5246 opencl_platforms_filter
|= 1 << (platform
- 1);
5248 } while ((next
= strtok (NULL
, ",")) != NULL
);
5254 opencl_platforms_filter
= -1;
5257 return opencl_platforms_filter
;
5260 u32
setup_devices_filter (char *opencl_devices
)
5262 u32 devices_filter
= 0;
5266 char *devices
= strdup (opencl_devices
);
5268 char *next
= strtok (devices
, ",");
5272 int device_id
= atoi (next
);
5274 if (device_id
< 1 || device_id
> 32)
5276 log_error ("ERROR: invalid device_id %u specified", device_id
);
5281 devices_filter
|= 1 << (device_id
- 1);
5283 } while ((next
= strtok (NULL
, ",")) != NULL
);
5289 devices_filter
= -1;
5292 return devices_filter
;
5295 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5297 cl_device_type device_types_filter
= 0;
5299 if (opencl_device_types
)
5301 char *device_types
= strdup (opencl_device_types
);
5303 char *next
= strtok (device_types
, ",");
5307 int device_type
= atoi (next
);
5309 if (device_type
< 1 || device_type
> 3)
5311 log_error ("ERROR: invalid device_type %u specified", device_type
);
5316 device_types_filter
|= 1 << device_type
;
5318 } while ((next
= strtok (NULL
, ",")) != NULL
);
5320 free (device_types
);
5324 // Do not use CPU by default, this often reduces GPU performance because
5325 // the CPU is too busy to handle GPU synchronization
5327 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5330 return device_types_filter
;
5333 u32
get_random_num (const u32 min
, const u32 max
)
5335 if (min
== max
) return (min
);
5337 return ((rand () % (max
- min
)) + min
);
5340 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5342 u32 quotient
= dividend
/ divisor
;
5344 if (dividend
% divisor
) quotient
++;
5349 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5351 u64 quotient
= dividend
/ divisor
;
5353 if (dividend
% divisor
) quotient
++;
5358 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5360 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5361 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5363 if (tm
->tm_year
- 70)
5365 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5366 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5368 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5370 else if (tm
->tm_yday
)
5372 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5373 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5375 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5377 else if (tm
->tm_hour
)
5379 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5380 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5382 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5384 else if (tm
->tm_min
)
5386 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5387 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5389 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5393 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5395 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5399 void format_speed_display (float val
, char *buf
, size_t len
)
5410 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5421 /* generate output */
5425 snprintf (buf
, len
- 1, "%.0f ", val
);
5429 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5433 void lowercase (u8
*buf
, int len
)
5435 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5438 void uppercase (u8
*buf
, int len
)
5440 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5443 int fgetl (FILE *fp
, char *line_buf
)
5449 const int c
= fgetc (fp
);
5451 if (c
== EOF
) break;
5453 line_buf
[line_len
] = (char) c
;
5457 if (line_len
== HCBUFSIZ
) line_len
--;
5459 if (c
== '\n') break;
5462 if (line_len
== 0) return 0;
5464 if (line_buf
[line_len
- 1] == '\n')
5468 line_buf
[line_len
] = 0;
5471 if (line_len
== 0) return 0;
5473 if (line_buf
[line_len
- 1] == '\r')
5477 line_buf
[line_len
] = 0;
5483 int in_superchop (char *buf
)
5485 int len
= strlen (buf
);
5489 if (buf
[len
- 1] == '\n')
5496 if (buf
[len
- 1] == '\r')
5511 char **scan_directory (const char *path
)
5513 char *tmp_path
= mystrdup (path
);
5515 size_t tmp_path_len
= strlen (tmp_path
);
5517 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5519 tmp_path
[tmp_path_len
- 1] = 0;
5521 tmp_path_len
= strlen (tmp_path
);
5524 char **files
= NULL
;
5530 if ((d
= opendir (tmp_path
)) != NULL
)
5536 memset (&e
, 0, sizeof (e
));
5537 struct dirent
*de
= NULL
;
5539 if (readdir_r (d
, &e
, &de
) != 0)
5541 log_error ("ERROR: readdir_r() failed");
5546 if (de
== NULL
) break;
5550 while ((de
= readdir (d
)) != NULL
)
5553 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5555 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5557 char *path_file
= (char *) mymalloc (path_size
+ 1);
5559 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5561 path_file
[path_size
] = 0;
5565 if ((d_test
= opendir (path_file
)) != NULL
)
5573 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5577 files
[num_files
- 1] = path_file
;
5583 else if (errno
== ENOTDIR
)
5585 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5589 files
[num_files
- 1] = mystrdup (path
);
5592 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5596 files
[num_files
- 1] = NULL
;
5603 int count_dictionaries (char **dictionary_files
)
5605 if (dictionary_files
== NULL
) return 0;
5609 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5617 char *stroptitype (const uint opti_type
)
5621 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5622 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5623 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5624 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5625 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5626 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5627 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5628 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5629 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5630 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5631 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5632 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5633 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5634 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5635 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5636 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5637 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5638 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5644 char *strparser (const uint parser_status
)
5646 switch (parser_status
)
5648 case PARSER_OK
: return ((char *) PA_000
); break;
5649 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5650 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5651 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5652 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5653 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5654 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5655 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5656 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5657 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5658 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5659 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5660 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5661 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5662 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5663 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5664 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5667 return ((char *) PA_255
);
5670 char *strhashtype (const uint hash_mode
)
5674 case 0: return ((char *) HT_00000
); break;
5675 case 10: return ((char *) HT_00010
); break;
5676 case 11: return ((char *) HT_00011
); break;
5677 case 12: return ((char *) HT_00012
); break;
5678 case 20: return ((char *) HT_00020
); break;
5679 case 21: return ((char *) HT_00021
); break;
5680 case 22: return ((char *) HT_00022
); break;
5681 case 23: return ((char *) HT_00023
); break;
5682 case 30: return ((char *) HT_00030
); break;
5683 case 40: return ((char *) HT_00040
); break;
5684 case 50: return ((char *) HT_00050
); break;
5685 case 60: return ((char *) HT_00060
); break;
5686 case 100: return ((char *) HT_00100
); break;
5687 case 101: return ((char *) HT_00101
); break;
5688 case 110: return ((char *) HT_00110
); break;
5689 case 111: return ((char *) HT_00111
); break;
5690 case 112: return ((char *) HT_00112
); break;
5691 case 120: return ((char *) HT_00120
); break;
5692 case 121: return ((char *) HT_00121
); break;
5693 case 122: return ((char *) HT_00122
); break;
5694 case 124: return ((char *) HT_00124
); break;
5695 case 125: return ((char *) HT_00125
); break;
5696 case 130: return ((char *) HT_00130
); break;
5697 case 131: return ((char *) HT_00131
); break;
5698 case 132: return ((char *) HT_00132
); break;
5699 case 133: return ((char *) HT_00133
); break;
5700 case 140: return ((char *) HT_00140
); break;
5701 case 141: return ((char *) HT_00141
); break;
5702 case 150: return ((char *) HT_00150
); break;
5703 case 160: return ((char *) HT_00160
); break;
5704 case 190: return ((char *) HT_00190
); break;
5705 case 200: return ((char *) HT_00200
); break;
5706 case 300: return ((char *) HT_00300
); break;
5707 case 400: return ((char *) HT_00400
); break;
5708 case 500: return ((char *) HT_00500
); break;
5709 case 501: return ((char *) HT_00501
); break;
5710 case 900: return ((char *) HT_00900
); break;
5711 case 910: return ((char *) HT_00910
); break;
5712 case 1000: return ((char *) HT_01000
); break;
5713 case 1100: return ((char *) HT_01100
); break;
5714 case 1400: return ((char *) HT_01400
); break;
5715 case 1410: return ((char *) HT_01410
); break;
5716 case 1420: return ((char *) HT_01420
); break;
5717 case 1421: return ((char *) HT_01421
); break;
5718 case 1430: return ((char *) HT_01430
); break;
5719 case 1440: return ((char *) HT_01440
); break;
5720 case 1441: return ((char *) HT_01441
); break;
5721 case 1450: return ((char *) HT_01450
); break;
5722 case 1460: return ((char *) HT_01460
); break;
5723 case 1500: return ((char *) HT_01500
); break;
5724 case 1600: return ((char *) HT_01600
); break;
5725 case 1700: return ((char *) HT_01700
); break;
5726 case 1710: return ((char *) HT_01710
); break;
5727 case 1711: return ((char *) HT_01711
); break;
5728 case 1720: return ((char *) HT_01720
); break;
5729 case 1722: return ((char *) HT_01722
); break;
5730 case 1730: return ((char *) HT_01730
); break;
5731 case 1731: return ((char *) HT_01731
); break;
5732 case 1740: return ((char *) HT_01740
); break;
5733 case 1750: return ((char *) HT_01750
); break;
5734 case 1760: return ((char *) HT_01760
); break;
5735 case 1800: return ((char *) HT_01800
); break;
5736 case 2100: return ((char *) HT_02100
); break;
5737 case 2400: return ((char *) HT_02400
); break;
5738 case 2410: return ((char *) HT_02410
); break;
5739 case 2500: return ((char *) HT_02500
); break;
5740 case 2600: return ((char *) HT_02600
); break;
5741 case 2611: return ((char *) HT_02611
); break;
5742 case 2612: return ((char *) HT_02612
); break;
5743 case 2711: return ((char *) HT_02711
); break;
5744 case 2811: return ((char *) HT_02811
); break;
5745 case 3000: return ((char *) HT_03000
); break;
5746 case 3100: return ((char *) HT_03100
); break;
5747 case 3200: return ((char *) HT_03200
); break;
5748 case 3710: return ((char *) HT_03710
); break;
5749 case 3711: return ((char *) HT_03711
); break;
5750 case 3800: return ((char *) HT_03800
); break;
5751 case 4300: return ((char *) HT_04300
); break;
5752 case 4400: return ((char *) HT_04400
); break;
5753 case 4500: return ((char *) HT_04500
); break;
5754 case 4700: return ((char *) HT_04700
); break;
5755 case 4800: return ((char *) HT_04800
); break;
5756 case 4900: return ((char *) HT_04900
); break;
5757 case 5000: return ((char *) HT_05000
); break;
5758 case 5100: return ((char *) HT_05100
); break;
5759 case 5200: return ((char *) HT_05200
); break;
5760 case 5300: return ((char *) HT_05300
); break;
5761 case 5400: return ((char *) HT_05400
); break;
5762 case 5500: return ((char *) HT_05500
); break;
5763 case 5600: return ((char *) HT_05600
); break;
5764 case 5700: return ((char *) HT_05700
); break;
5765 case 5800: return ((char *) HT_05800
); break;
5766 case 6000: return ((char *) HT_06000
); break;
5767 case 6100: return ((char *) HT_06100
); break;
5768 case 6211: return ((char *) HT_06211
); break;
5769 case 6212: return ((char *) HT_06212
); break;
5770 case 6213: return ((char *) HT_06213
); break;
5771 case 6221: return ((char *) HT_06221
); break;
5772 case 6222: return ((char *) HT_06222
); break;
5773 case 6223: return ((char *) HT_06223
); break;
5774 case 6231: return ((char *) HT_06231
); break;
5775 case 6232: return ((char *) HT_06232
); break;
5776 case 6233: return ((char *) HT_06233
); break;
5777 case 6241: return ((char *) HT_06241
); break;
5778 case 6242: return ((char *) HT_06242
); break;
5779 case 6243: return ((char *) HT_06243
); break;
5780 case 6300: return ((char *) HT_06300
); break;
5781 case 6400: return ((char *) HT_06400
); break;
5782 case 6500: return ((char *) HT_06500
); break;
5783 case 6600: return ((char *) HT_06600
); break;
5784 case 6700: return ((char *) HT_06700
); break;
5785 case 6800: return ((char *) HT_06800
); break;
5786 case 6900: return ((char *) HT_06900
); break;
5787 case 7100: return ((char *) HT_07100
); break;
5788 case 7200: return ((char *) HT_07200
); break;
5789 case 7300: return ((char *) HT_07300
); break;
5790 case 7400: return ((char *) HT_07400
); break;
5791 case 7500: return ((char *) HT_07500
); break;
5792 case 7600: return ((char *) HT_07600
); break;
5793 case 7700: return ((char *) HT_07700
); break;
5794 case 7800: return ((char *) HT_07800
); break;
5795 case 7900: return ((char *) HT_07900
); break;
5796 case 8000: return ((char *) HT_08000
); break;
5797 case 8100: return ((char *) HT_08100
); break;
5798 case 8200: return ((char *) HT_08200
); break;
5799 case 8300: return ((char *) HT_08300
); break;
5800 case 8400: return ((char *) HT_08400
); break;
5801 case 8500: return ((char *) HT_08500
); break;
5802 case 8600: return ((char *) HT_08600
); break;
5803 case 8700: return ((char *) HT_08700
); break;
5804 case 8800: return ((char *) HT_08800
); break;
5805 case 8900: return ((char *) HT_08900
); break;
5806 case 9000: return ((char *) HT_09000
); break;
5807 case 9100: return ((char *) HT_09100
); break;
5808 case 9200: return ((char *) HT_09200
); break;
5809 case 9300: return ((char *) HT_09300
); break;
5810 case 9400: return ((char *) HT_09400
); break;
5811 case 9500: return ((char *) HT_09500
); break;
5812 case 9600: return ((char *) HT_09600
); break;
5813 case 9700: return ((char *) HT_09700
); break;
5814 case 9710: return ((char *) HT_09710
); break;
5815 case 9720: return ((char *) HT_09720
); break;
5816 case 9800: return ((char *) HT_09800
); break;
5817 case 9810: return ((char *) HT_09810
); break;
5818 case 9820: return ((char *) HT_09820
); break;
5819 case 9900: return ((char *) HT_09900
); break;
5820 case 10000: return ((char *) HT_10000
); break;
5821 case 10100: return ((char *) HT_10100
); break;
5822 case 10200: return ((char *) HT_10200
); break;
5823 case 10300: return ((char *) HT_10300
); break;
5824 case 10400: return ((char *) HT_10400
); break;
5825 case 10410: return ((char *) HT_10410
); break;
5826 case 10420: return ((char *) HT_10420
); break;
5827 case 10500: return ((char *) HT_10500
); break;
5828 case 10600: return ((char *) HT_10600
); break;
5829 case 10700: return ((char *) HT_10700
); break;
5830 case 10800: return ((char *) HT_10800
); break;
5831 case 10900: return ((char *) HT_10900
); break;
5832 case 11000: return ((char *) HT_11000
); break;
5833 case 11100: return ((char *) HT_11100
); break;
5834 case 11200: return ((char *) HT_11200
); break;
5835 case 11300: return ((char *) HT_11300
); break;
5836 case 11400: return ((char *) HT_11400
); break;
5837 case 11500: return ((char *) HT_11500
); break;
5838 case 11600: return ((char *) HT_11600
); break;
5839 case 11700: return ((char *) HT_11700
); break;
5840 case 11800: return ((char *) HT_11800
); break;
5841 case 11900: return ((char *) HT_11900
); break;
5842 case 12000: return ((char *) HT_12000
); break;
5843 case 12100: return ((char *) HT_12100
); break;
5844 case 12200: return ((char *) HT_12200
); break;
5845 case 12300: return ((char *) HT_12300
); break;
5846 case 12400: return ((char *) HT_12400
); break;
5847 case 12500: return ((char *) HT_12500
); break;
5848 case 12600: return ((char *) HT_12600
); break;
5849 case 12700: return ((char *) HT_12700
); break;
5850 case 12800: return ((char *) HT_12800
); break;
5851 case 12900: return ((char *) HT_12900
); break;
5852 case 13000: return ((char *) HT_13000
); break;
5853 case 13100: return ((char *) HT_13100
); break;
5854 case 13200: return ((char *) HT_13200
); break;
5855 case 13300: return ((char *) HT_13300
); break;
5856 case 13400: return ((char *) HT_13400
); break;
5857 case 13500: return ((char *) HT_13500
); break;
5860 return ((char *) "Unknown");
5863 char *strstatus (const uint devices_status
)
5865 switch (devices_status
)
5867 case STATUS_INIT
: return ((char *) ST_0000
); break;
5868 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5869 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5870 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5871 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5872 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5873 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5874 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5875 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5876 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5877 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
5880 return ((char *) "Unknown");
5883 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
5885 uint hash_type
= data
.hash_type
;
5886 uint hash_mode
= data
.hash_mode
;
5887 uint salt_type
= data
.salt_type
;
5888 uint opts_type
= data
.opts_type
;
5889 uint opti_type
= data
.opti_type
;
5890 uint dgst_size
= data
.dgst_size
;
5892 char *hashfile
= data
.hashfile
;
5896 uint digest_buf
[64] = { 0 };
5898 u64
*digest_buf64
= (u64
*) digest_buf
;
5900 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5902 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5904 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5910 case HASH_TYPE_DESCRYPT
:
5911 FP (digest_buf
[1], digest_buf
[0], tt
);
5914 case HASH_TYPE_DESRACF
:
5915 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5916 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5918 FP (digest_buf
[1], digest_buf
[0], tt
);
5922 FP (digest_buf
[1], digest_buf
[0], tt
);
5925 case HASH_TYPE_NETNTLM
:
5926 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5927 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5928 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5929 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5931 FP (digest_buf
[1], digest_buf
[0], tt
);
5932 FP (digest_buf
[3], digest_buf
[2], tt
);
5935 case HASH_TYPE_BSDICRYPT
:
5936 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5937 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5939 FP (digest_buf
[1], digest_buf
[0], tt
);
5944 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5949 digest_buf
[0] += MD4M_A
;
5950 digest_buf
[1] += MD4M_B
;
5951 digest_buf
[2] += MD4M_C
;
5952 digest_buf
[3] += MD4M_D
;
5956 digest_buf
[0] += MD5M_A
;
5957 digest_buf
[1] += MD5M_B
;
5958 digest_buf
[2] += MD5M_C
;
5959 digest_buf
[3] += MD5M_D
;
5962 case HASH_TYPE_SHA1
:
5963 digest_buf
[0] += SHA1M_A
;
5964 digest_buf
[1] += SHA1M_B
;
5965 digest_buf
[2] += SHA1M_C
;
5966 digest_buf
[3] += SHA1M_D
;
5967 digest_buf
[4] += SHA1M_E
;
5970 case HASH_TYPE_SHA256
:
5971 digest_buf
[0] += SHA256M_A
;
5972 digest_buf
[1] += SHA256M_B
;
5973 digest_buf
[2] += SHA256M_C
;
5974 digest_buf
[3] += SHA256M_D
;
5975 digest_buf
[4] += SHA256M_E
;
5976 digest_buf
[5] += SHA256M_F
;
5977 digest_buf
[6] += SHA256M_G
;
5978 digest_buf
[7] += SHA256M_H
;
5981 case HASH_TYPE_SHA384
:
5982 digest_buf64
[0] += SHA384M_A
;
5983 digest_buf64
[1] += SHA384M_B
;
5984 digest_buf64
[2] += SHA384M_C
;
5985 digest_buf64
[3] += SHA384M_D
;
5986 digest_buf64
[4] += SHA384M_E
;
5987 digest_buf64
[5] += SHA384M_F
;
5988 digest_buf64
[6] += 0;
5989 digest_buf64
[7] += 0;
5992 case HASH_TYPE_SHA512
:
5993 digest_buf64
[0] += SHA512M_A
;
5994 digest_buf64
[1] += SHA512M_B
;
5995 digest_buf64
[2] += SHA512M_C
;
5996 digest_buf64
[3] += SHA512M_D
;
5997 digest_buf64
[4] += SHA512M_E
;
5998 digest_buf64
[5] += SHA512M_F
;
5999 digest_buf64
[6] += SHA512M_G
;
6000 digest_buf64
[7] += SHA512M_H
;
6005 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6007 if (dgst_size
== DGST_SIZE_4_2
)
6009 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6011 else if (dgst_size
== DGST_SIZE_4_4
)
6013 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6015 else if (dgst_size
== DGST_SIZE_4_5
)
6017 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6019 else if (dgst_size
== DGST_SIZE_4_6
)
6021 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6023 else if (dgst_size
== DGST_SIZE_4_8
)
6025 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6027 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6029 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6031 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6033 else if (hash_type
== HASH_TYPE_SHA384
)
6035 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6037 else if (hash_type
== HASH_TYPE_SHA512
)
6039 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6041 else if (hash_type
== HASH_TYPE_GOST
)
6043 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6046 else if (dgst_size
== DGST_SIZE_4_64
)
6048 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6050 else if (dgst_size
== DGST_SIZE_8_25
)
6052 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6056 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6057 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6058 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6064 memset (&salt
, 0, sizeof (salt_t
));
6066 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6068 char *ptr
= (char *) salt
.salt_buf
;
6070 uint len
= salt
.salt_len
;
6072 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6078 case HASH_TYPE_NETNTLM
:
6080 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6081 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6083 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6089 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6091 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6099 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6101 uint max
= salt
.salt_len
/ 4;
6105 for (uint i
= 0; i
< max
; i
++)
6107 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6111 if (opts_type
& OPTS_TYPE_ST_HEX
)
6113 char tmp
[64] = { 0 };
6115 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6117 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6122 memcpy (ptr
, tmp
, len
);
6125 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6127 memset (ptr
+ len
, 0, memset_size
);
6129 salt
.salt_len
= len
;
6133 // some modes require special encoding
6136 uint out_buf_plain
[256] = { 0 };
6137 uint out_buf_salt
[256] = { 0 };
6139 char tmp_buf
[1024] = { 0 };
6141 char *ptr_plain
= (char *) out_buf_plain
;
6142 char *ptr_salt
= (char *) out_buf_salt
;
6144 if (hash_mode
== 22)
6146 char username
[30] = { 0 };
6148 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6150 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6152 u16
*ptr
= (u16
*) digest_buf
;
6154 tmp_buf
[ 0] = sig
[0];
6155 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6156 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6157 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6158 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6159 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6160 tmp_buf
[ 6] = sig
[1];
6161 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6162 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6163 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6164 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6165 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6166 tmp_buf
[12] = sig
[2];
6167 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6168 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6169 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6170 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6171 tmp_buf
[17] = sig
[3];
6172 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6173 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6174 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6175 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6176 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6177 tmp_buf
[23] = sig
[4];
6178 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6179 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6180 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6181 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6182 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6183 tmp_buf
[29] = sig
[5];
6185 snprintf (out_buf
, len
-1, "%s:%s",
6189 else if (hash_mode
== 23)
6191 // do not show the skyper part in output
6193 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6195 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6197 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6204 else if (hash_mode
== 101)
6206 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6208 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6209 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6210 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6211 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6212 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6214 memcpy (tmp_buf
, digest_buf
, 20);
6216 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6218 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6220 else if (hash_mode
== 111)
6222 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6224 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6225 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6226 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6227 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6228 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6230 memcpy (tmp_buf
, digest_buf
, 20);
6231 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6233 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6235 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6237 else if ((hash_mode
== 122) || (hash_mode
== 125))
6239 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6240 (char *) salt
.salt_buf
,
6247 else if (hash_mode
== 124)
6249 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6250 (char *) salt
.salt_buf
,
6257 else if (hash_mode
== 131)
6259 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6260 (char *) salt
.salt_buf
,
6268 else if (hash_mode
== 132)
6270 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6271 (char *) salt
.salt_buf
,
6278 else if (hash_mode
== 133)
6280 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6282 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6283 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6284 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6285 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6286 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6288 memcpy (tmp_buf
, digest_buf
, 20);
6290 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6292 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6294 else if (hash_mode
== 141)
6296 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6298 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6300 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6302 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6304 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6305 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6306 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6307 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6308 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6310 memcpy (tmp_buf
, digest_buf
, 20);
6312 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6316 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6318 else if (hash_mode
== 400)
6320 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6322 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6323 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6324 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6325 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6327 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6329 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6331 else if (hash_mode
== 500)
6333 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6335 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6336 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6337 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6338 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6340 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6342 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6344 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6348 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6351 else if (hash_mode
== 501)
6353 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6355 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6356 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6358 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6360 else if (hash_mode
== 1421)
6362 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6364 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6380 else if (hash_mode
== 1441)
6382 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6384 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6386 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6388 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6390 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6391 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6392 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6393 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6394 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6395 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6396 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6397 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6399 memcpy (tmp_buf
, digest_buf
, 32);
6401 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6405 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6407 else if (hash_mode
== 1500)
6409 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6410 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6411 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6412 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6413 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6415 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6417 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6419 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6420 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6422 memcpy (tmp_buf
, digest_buf
, 8);
6424 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6426 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6430 else if (hash_mode
== 1600)
6432 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6434 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6435 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6436 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6437 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6439 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6441 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6443 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6447 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6450 else if (hash_mode
== 1711)
6452 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6454 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6455 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6456 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6457 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6458 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6459 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6460 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6461 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6463 memcpy (tmp_buf
, digest_buf
, 64);
6464 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6466 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6468 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6470 else if (hash_mode
== 1722)
6472 uint
*ptr
= digest_buf
;
6474 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6475 (unsigned char *) salt
.salt_buf
,
6485 else if (hash_mode
== 1731)
6487 uint
*ptr
= digest_buf
;
6489 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6490 (unsigned char *) salt
.salt_buf
,
6500 else if (hash_mode
== 1800)
6504 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6505 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6506 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6507 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6508 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6509 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6510 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6511 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6513 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6515 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6517 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6521 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6524 else if (hash_mode
== 2100)
6528 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6530 salt
.salt_iter
+ 1);
6532 uint signature_len
= strlen (out_buf
);
6534 pos
+= signature_len
;
6535 len
-= signature_len
;
6537 char *salt_ptr
= (char *) salt
.salt_buf
;
6539 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6541 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6542 byte_swap_32 (digest_buf
[0]),
6543 byte_swap_32 (digest_buf
[1]),
6544 byte_swap_32 (digest_buf
[2]),
6545 byte_swap_32 (digest_buf
[3]));
6547 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6549 memcpy (tmp_buf
, digest_buf
, 16);
6551 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6553 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6554 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6555 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6556 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6558 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6559 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6560 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6561 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6563 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6564 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6565 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6566 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6568 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6569 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6570 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6571 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6573 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6574 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6575 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6576 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6580 else if (hash_mode
== 2500)
6582 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6584 wpa_t
*wpa
= &wpas
[salt_pos
];
6586 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6587 (char *) salt
.salt_buf
,
6601 else if (hash_mode
== 4400)
6603 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6604 byte_swap_32 (digest_buf
[0]),
6605 byte_swap_32 (digest_buf
[1]),
6606 byte_swap_32 (digest_buf
[2]),
6607 byte_swap_32 (digest_buf
[3]));
6609 else if (hash_mode
== 4700)
6611 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6612 byte_swap_32 (digest_buf
[0]),
6613 byte_swap_32 (digest_buf
[1]),
6614 byte_swap_32 (digest_buf
[2]),
6615 byte_swap_32 (digest_buf
[3]),
6616 byte_swap_32 (digest_buf
[4]));
6618 else if (hash_mode
== 4800)
6620 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6622 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6627 byte_swap_32 (salt
.salt_buf
[0]),
6628 byte_swap_32 (salt
.salt_buf
[1]),
6629 byte_swap_32 (salt
.salt_buf
[2]),
6630 byte_swap_32 (salt
.salt_buf
[3]),
6633 else if (hash_mode
== 4900)
6635 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6636 byte_swap_32 (digest_buf
[0]),
6637 byte_swap_32 (digest_buf
[1]),
6638 byte_swap_32 (digest_buf
[2]),
6639 byte_swap_32 (digest_buf
[3]),
6640 byte_swap_32 (digest_buf
[4]));
6642 else if (hash_mode
== 5100)
6644 snprintf (out_buf
, len
-1, "%08x%08x",
6648 else if (hash_mode
== 5200)
6650 snprintf (out_buf
, len
-1, "%s", hashfile
);
6652 else if (hash_mode
== 5300)
6654 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6656 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6658 int buf_len
= len
-1;
6662 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6664 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6666 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6668 snprintf (out_buf
, buf_len
, ":");
6674 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6682 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6684 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6686 if ((i
== 0) || (i
== 5))
6688 snprintf (out_buf
, buf_len
, ":");
6694 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6702 for (uint i
= 0; i
< 4; i
++)
6706 snprintf (out_buf
, buf_len
, ":");
6712 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6718 else if (hash_mode
== 5400)
6720 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6722 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6724 int buf_len
= len
-1;
6728 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6730 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6732 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6734 snprintf (out_buf
, buf_len
, ":");
6740 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6748 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6750 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6752 if ((i
== 0) || (i
== 5))
6754 snprintf (out_buf
, buf_len
, ":");
6760 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6768 for (uint i
= 0; i
< 5; i
++)
6772 snprintf (out_buf
, buf_len
, ":");
6778 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6784 else if (hash_mode
== 5500)
6786 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6788 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6790 char user_buf
[64] = { 0 };
6791 char domain_buf
[64] = { 0 };
6792 char srvchall_buf
[1024] = { 0 };
6793 char clichall_buf
[1024] = { 0 };
6795 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6797 char *ptr
= (char *) netntlm
->userdomain_buf
;
6799 user_buf
[i
] = ptr
[j
];
6802 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6804 char *ptr
= (char *) netntlm
->userdomain_buf
;
6806 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6809 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6811 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6813 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6816 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6818 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6820 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6823 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6831 byte_swap_32 (salt
.salt_buf_pc
[0]),
6832 byte_swap_32 (salt
.salt_buf_pc
[1]),
6835 else if (hash_mode
== 5600)
6837 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6839 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6841 char user_buf
[64] = { 0 };
6842 char domain_buf
[64] = { 0 };
6843 char srvchall_buf
[1024] = { 0 };
6844 char clichall_buf
[1024] = { 0 };
6846 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6848 char *ptr
= (char *) netntlm
->userdomain_buf
;
6850 user_buf
[i
] = ptr
[j
];
6853 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6855 char *ptr
= (char *) netntlm
->userdomain_buf
;
6857 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6860 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6862 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6864 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6867 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6869 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6871 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6874 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6884 else if (hash_mode
== 5700)
6886 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6888 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6889 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6890 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6891 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6892 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6893 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6894 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6895 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6897 memcpy (tmp_buf
, digest_buf
, 32);
6899 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6903 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6905 else if (hash_mode
== 5800)
6907 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6908 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6909 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6910 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6911 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6913 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6920 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6922 snprintf (out_buf
, len
-1, "%s", hashfile
);
6924 else if (hash_mode
== 6300)
6926 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6928 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6929 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6930 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6931 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6933 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6935 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6937 else if (hash_mode
== 6400)
6939 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6941 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6943 else if (hash_mode
== 6500)
6945 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6947 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6949 else if (hash_mode
== 6600)
6951 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6953 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6955 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6956 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6958 uint buf_len
= len
- 1;
6960 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6963 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6965 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6970 else if (hash_mode
== 6700)
6972 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6974 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6976 else if (hash_mode
== 6800)
6978 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6980 else if (hash_mode
== 7100)
6982 uint
*ptr
= digest_buf
;
6984 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6986 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6988 uint esalt
[8] = { 0 };
6990 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6991 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6992 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6993 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6994 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6995 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6996 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6997 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6999 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",
7000 SIGNATURE_SHA512OSX
,
7002 esalt
[ 0], esalt
[ 1],
7003 esalt
[ 2], esalt
[ 3],
7004 esalt
[ 4], esalt
[ 5],
7005 esalt
[ 6], esalt
[ 7],
7013 ptr
[15], ptr
[14]);
7015 else if (hash_mode
== 7200)
7017 uint
*ptr
= digest_buf
;
7019 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7021 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7025 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7027 len_used
= strlen (out_buf
);
7029 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7031 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7033 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7036 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",
7044 ptr
[15], ptr
[14]);
7046 else if (hash_mode
== 7300)
7048 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7050 rakp_t
*rakp
= &rakps
[salt_pos
];
7052 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7054 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7057 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7064 else if (hash_mode
== 7400)
7066 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
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]);
7073 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7074 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7075 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7077 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7079 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7081 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7085 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7088 else if (hash_mode
== 7500)
7090 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7092 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7094 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7095 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7097 char data
[128] = { 0 };
7099 char *ptr_data
= data
;
7101 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7103 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7106 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7108 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7113 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7115 (char *) krb5pa
->user
,
7116 (char *) krb5pa
->realm
,
7117 (char *) krb5pa
->salt
,
7120 else if (hash_mode
== 7700)
7122 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7123 (char *) salt
.salt_buf
,
7127 else if (hash_mode
== 7800)
7129 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7130 (char *) salt
.salt_buf
,
7137 else if (hash_mode
== 7900)
7139 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7143 char *tmp
= (char *) salt
.salt_buf_pc
;
7145 ptr_plain
[42] = tmp
[0];
7151 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7153 else if (hash_mode
== 8000)
7155 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7156 (unsigned char *) salt
.salt_buf
,
7166 else if (hash_mode
== 8100)
7168 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7169 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7171 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7172 (unsigned char *) salt
.salt_buf
,
7179 else if (hash_mode
== 8200)
7181 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7183 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7185 char data_buf
[4096] = { 0 };
7187 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7189 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7192 data_buf
[cloudkey
->data_len
* 2] = 0;
7194 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7195 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7196 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7197 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7198 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7199 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7200 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7201 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7203 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7204 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7205 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7206 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7208 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7224 else if (hash_mode
== 8300)
7226 char digest_buf_c
[34] = { 0 };
7228 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7229 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7230 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7231 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7232 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7234 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7236 digest_buf_c
[32] = 0;
7240 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7242 char domain_buf_c
[33] = { 0 };
7244 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7246 for (uint i
= 0; i
< salt_pc_len
; i
++)
7248 const char next
= domain_buf_c
[i
];
7250 domain_buf_c
[i
] = '.';
7255 domain_buf_c
[salt_pc_len
] = 0;
7259 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7261 else if (hash_mode
== 8500)
7263 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7265 else if (hash_mode
== 2612)
7267 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7269 (char *) salt
.salt_buf
,
7275 else if (hash_mode
== 3711)
7277 char *salt_ptr
= (char *) salt
.salt_buf
;
7279 salt_ptr
[salt
.salt_len
- 1] = 0;
7281 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7282 SIGNATURE_MEDIAWIKI_B
,
7289 else if (hash_mode
== 8800)
7291 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7293 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7295 char tmp
[3073] = { 0 };
7297 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7299 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7304 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7305 SIGNATURE_ANDROIDFDE
,
7306 byte_swap_32 (salt
.salt_buf
[0]),
7307 byte_swap_32 (salt
.salt_buf
[1]),
7308 byte_swap_32 (salt
.salt_buf
[2]),
7309 byte_swap_32 (salt
.salt_buf
[3]),
7310 byte_swap_32 (digest_buf
[0]),
7311 byte_swap_32 (digest_buf
[1]),
7312 byte_swap_32 (digest_buf
[2]),
7313 byte_swap_32 (digest_buf
[3]),
7316 else if (hash_mode
== 8900)
7318 uint N
= salt
.scrypt_N
;
7319 uint r
= salt
.scrypt_r
;
7320 uint p
= salt
.scrypt_p
;
7322 char base64_salt
[32] = { 0 };
7324 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7326 memset (tmp_buf
, 0, 46);
7328 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7329 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7330 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7331 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7332 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7333 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7334 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7335 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7336 digest_buf
[8] = 0; // needed for base64_encode ()
7338 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7340 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7348 else if (hash_mode
== 9000)
7350 snprintf (out_buf
, len
-1, "%s", hashfile
);
7352 else if (hash_mode
== 9200)
7356 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7358 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7360 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7364 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7365 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7366 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7367 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7368 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7369 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7370 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7371 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7372 digest_buf
[8] = 0; // needed for base64_encode ()
7374 char tmp_buf
[64] = { 0 };
7376 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7377 tmp_buf
[43] = 0; // cut it here
7381 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7383 else if (hash_mode
== 9300)
7385 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7386 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7387 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7388 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7389 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7390 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7391 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7392 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7393 digest_buf
[8] = 0; // needed for base64_encode ()
7395 char tmp_buf
[64] = { 0 };
7397 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7398 tmp_buf
[43] = 0; // cut it here
7400 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7402 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7404 else if (hash_mode
== 9400)
7406 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7408 office2007_t
*office2007
= &office2007s
[salt_pos
];
7410 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7411 SIGNATURE_OFFICE2007
,
7414 office2007
->keySize
,
7420 office2007
->encryptedVerifier
[0],
7421 office2007
->encryptedVerifier
[1],
7422 office2007
->encryptedVerifier
[2],
7423 office2007
->encryptedVerifier
[3],
7424 office2007
->encryptedVerifierHash
[0],
7425 office2007
->encryptedVerifierHash
[1],
7426 office2007
->encryptedVerifierHash
[2],
7427 office2007
->encryptedVerifierHash
[3],
7428 office2007
->encryptedVerifierHash
[4]);
7430 else if (hash_mode
== 9500)
7432 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7434 office2010_t
*office2010
= &office2010s
[salt_pos
];
7436 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,
7442 office2010
->encryptedVerifier
[0],
7443 office2010
->encryptedVerifier
[1],
7444 office2010
->encryptedVerifier
[2],
7445 office2010
->encryptedVerifier
[3],
7446 office2010
->encryptedVerifierHash
[0],
7447 office2010
->encryptedVerifierHash
[1],
7448 office2010
->encryptedVerifierHash
[2],
7449 office2010
->encryptedVerifierHash
[3],
7450 office2010
->encryptedVerifierHash
[4],
7451 office2010
->encryptedVerifierHash
[5],
7452 office2010
->encryptedVerifierHash
[6],
7453 office2010
->encryptedVerifierHash
[7]);
7455 else if (hash_mode
== 9600)
7457 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7459 office2013_t
*office2013
= &office2013s
[salt_pos
];
7461 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,
7467 office2013
->encryptedVerifier
[0],
7468 office2013
->encryptedVerifier
[1],
7469 office2013
->encryptedVerifier
[2],
7470 office2013
->encryptedVerifier
[3],
7471 office2013
->encryptedVerifierHash
[0],
7472 office2013
->encryptedVerifierHash
[1],
7473 office2013
->encryptedVerifierHash
[2],
7474 office2013
->encryptedVerifierHash
[3],
7475 office2013
->encryptedVerifierHash
[4],
7476 office2013
->encryptedVerifierHash
[5],
7477 office2013
->encryptedVerifierHash
[6],
7478 office2013
->encryptedVerifierHash
[7]);
7480 else if (hash_mode
== 9700)
7482 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7484 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7486 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7487 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7488 byte_swap_32 (salt
.salt_buf
[0]),
7489 byte_swap_32 (salt
.salt_buf
[1]),
7490 byte_swap_32 (salt
.salt_buf
[2]),
7491 byte_swap_32 (salt
.salt_buf
[3]),
7492 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7493 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7494 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7495 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7496 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7497 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7498 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7499 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7501 else if (hash_mode
== 9710)
7503 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7505 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7507 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7508 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7509 byte_swap_32 (salt
.salt_buf
[0]),
7510 byte_swap_32 (salt
.salt_buf
[1]),
7511 byte_swap_32 (salt
.salt_buf
[2]),
7512 byte_swap_32 (salt
.salt_buf
[3]),
7513 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7514 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7515 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7516 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7517 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7518 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7519 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7520 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7522 else if (hash_mode
== 9720)
7524 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7526 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7528 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7530 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7531 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7532 byte_swap_32 (salt
.salt_buf
[0]),
7533 byte_swap_32 (salt
.salt_buf
[1]),
7534 byte_swap_32 (salt
.salt_buf
[2]),
7535 byte_swap_32 (salt
.salt_buf
[3]),
7536 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7537 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7538 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7539 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7540 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7541 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7542 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7543 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7550 else if (hash_mode
== 9800)
7552 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7554 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7556 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7557 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7562 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7563 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7564 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7565 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7566 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7567 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7568 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7569 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7570 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7572 else if (hash_mode
== 9810)
7574 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7576 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7578 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7579 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7584 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7585 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7586 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7587 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7588 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7589 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7590 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7591 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7592 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7594 else if (hash_mode
== 9820)
7596 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7598 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7600 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7602 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7603 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7608 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7609 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7610 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7611 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7612 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7613 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7614 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7615 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7616 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7623 else if (hash_mode
== 10000)
7627 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7629 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7631 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7635 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7636 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7637 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7638 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7639 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7640 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7641 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7642 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7643 digest_buf
[8] = 0; // needed for base64_encode ()
7645 char tmp_buf
[64] = { 0 };
7647 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7651 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7653 else if (hash_mode
== 10100)
7655 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7660 byte_swap_32 (salt
.salt_buf
[0]),
7661 byte_swap_32 (salt
.salt_buf
[1]),
7662 byte_swap_32 (salt
.salt_buf
[2]),
7663 byte_swap_32 (salt
.salt_buf
[3]));
7665 else if (hash_mode
== 10200)
7667 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7669 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7673 char challenge
[100] = { 0 };
7675 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7679 char tmp_buf
[100] = { 0 };
7681 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7682 (char *) cram_md5
->user
,
7688 char response
[100] = { 0 };
7690 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7692 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7694 else if (hash_mode
== 10300)
7696 char tmp_buf
[100] = { 0 };
7698 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7699 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7701 uint tmp_len
= 20 + salt
.salt_len
;
7705 char base64_encoded
[100] = { 0 };
7707 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7709 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7711 else if (hash_mode
== 10400)
7713 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7715 pdf_t
*pdf
= &pdfs
[salt_pos
];
7717 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",
7725 byte_swap_32 (pdf
->id_buf
[0]),
7726 byte_swap_32 (pdf
->id_buf
[1]),
7727 byte_swap_32 (pdf
->id_buf
[2]),
7728 byte_swap_32 (pdf
->id_buf
[3]),
7730 byte_swap_32 (pdf
->u_buf
[0]),
7731 byte_swap_32 (pdf
->u_buf
[1]),
7732 byte_swap_32 (pdf
->u_buf
[2]),
7733 byte_swap_32 (pdf
->u_buf
[3]),
7734 byte_swap_32 (pdf
->u_buf
[4]),
7735 byte_swap_32 (pdf
->u_buf
[5]),
7736 byte_swap_32 (pdf
->u_buf
[6]),
7737 byte_swap_32 (pdf
->u_buf
[7]),
7739 byte_swap_32 (pdf
->o_buf
[0]),
7740 byte_swap_32 (pdf
->o_buf
[1]),
7741 byte_swap_32 (pdf
->o_buf
[2]),
7742 byte_swap_32 (pdf
->o_buf
[3]),
7743 byte_swap_32 (pdf
->o_buf
[4]),
7744 byte_swap_32 (pdf
->o_buf
[5]),
7745 byte_swap_32 (pdf
->o_buf
[6]),
7746 byte_swap_32 (pdf
->o_buf
[7])
7749 else if (hash_mode
== 10410)
7751 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7753 pdf_t
*pdf
= &pdfs
[salt_pos
];
7755 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",
7763 byte_swap_32 (pdf
->id_buf
[0]),
7764 byte_swap_32 (pdf
->id_buf
[1]),
7765 byte_swap_32 (pdf
->id_buf
[2]),
7766 byte_swap_32 (pdf
->id_buf
[3]),
7768 byte_swap_32 (pdf
->u_buf
[0]),
7769 byte_swap_32 (pdf
->u_buf
[1]),
7770 byte_swap_32 (pdf
->u_buf
[2]),
7771 byte_swap_32 (pdf
->u_buf
[3]),
7772 byte_swap_32 (pdf
->u_buf
[4]),
7773 byte_swap_32 (pdf
->u_buf
[5]),
7774 byte_swap_32 (pdf
->u_buf
[6]),
7775 byte_swap_32 (pdf
->u_buf
[7]),
7777 byte_swap_32 (pdf
->o_buf
[0]),
7778 byte_swap_32 (pdf
->o_buf
[1]),
7779 byte_swap_32 (pdf
->o_buf
[2]),
7780 byte_swap_32 (pdf
->o_buf
[3]),
7781 byte_swap_32 (pdf
->o_buf
[4]),
7782 byte_swap_32 (pdf
->o_buf
[5]),
7783 byte_swap_32 (pdf
->o_buf
[6]),
7784 byte_swap_32 (pdf
->o_buf
[7])
7787 else if (hash_mode
== 10420)
7789 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7791 pdf_t
*pdf
= &pdfs
[salt_pos
];
7793 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7795 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",
7803 byte_swap_32 (pdf
->id_buf
[0]),
7804 byte_swap_32 (pdf
->id_buf
[1]),
7805 byte_swap_32 (pdf
->id_buf
[2]),
7806 byte_swap_32 (pdf
->id_buf
[3]),
7808 byte_swap_32 (pdf
->u_buf
[0]),
7809 byte_swap_32 (pdf
->u_buf
[1]),
7810 byte_swap_32 (pdf
->u_buf
[2]),
7811 byte_swap_32 (pdf
->u_buf
[3]),
7812 byte_swap_32 (pdf
->u_buf
[4]),
7813 byte_swap_32 (pdf
->u_buf
[5]),
7814 byte_swap_32 (pdf
->u_buf
[6]),
7815 byte_swap_32 (pdf
->u_buf
[7]),
7817 byte_swap_32 (pdf
->o_buf
[0]),
7818 byte_swap_32 (pdf
->o_buf
[1]),
7819 byte_swap_32 (pdf
->o_buf
[2]),
7820 byte_swap_32 (pdf
->o_buf
[3]),
7821 byte_swap_32 (pdf
->o_buf
[4]),
7822 byte_swap_32 (pdf
->o_buf
[5]),
7823 byte_swap_32 (pdf
->o_buf
[6]),
7824 byte_swap_32 (pdf
->o_buf
[7]),
7832 else if (hash_mode
== 10500)
7834 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7836 pdf_t
*pdf
= &pdfs
[salt_pos
];
7838 if (pdf
->id_len
== 32)
7840 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",
7848 byte_swap_32 (pdf
->id_buf
[0]),
7849 byte_swap_32 (pdf
->id_buf
[1]),
7850 byte_swap_32 (pdf
->id_buf
[2]),
7851 byte_swap_32 (pdf
->id_buf
[3]),
7852 byte_swap_32 (pdf
->id_buf
[4]),
7853 byte_swap_32 (pdf
->id_buf
[5]),
7854 byte_swap_32 (pdf
->id_buf
[6]),
7855 byte_swap_32 (pdf
->id_buf
[7]),
7857 byte_swap_32 (pdf
->u_buf
[0]),
7858 byte_swap_32 (pdf
->u_buf
[1]),
7859 byte_swap_32 (pdf
->u_buf
[2]),
7860 byte_swap_32 (pdf
->u_buf
[3]),
7861 byte_swap_32 (pdf
->u_buf
[4]),
7862 byte_swap_32 (pdf
->u_buf
[5]),
7863 byte_swap_32 (pdf
->u_buf
[6]),
7864 byte_swap_32 (pdf
->u_buf
[7]),
7866 byte_swap_32 (pdf
->o_buf
[0]),
7867 byte_swap_32 (pdf
->o_buf
[1]),
7868 byte_swap_32 (pdf
->o_buf
[2]),
7869 byte_swap_32 (pdf
->o_buf
[3]),
7870 byte_swap_32 (pdf
->o_buf
[4]),
7871 byte_swap_32 (pdf
->o_buf
[5]),
7872 byte_swap_32 (pdf
->o_buf
[6]),
7873 byte_swap_32 (pdf
->o_buf
[7])
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])
7911 else if (hash_mode
== 10600)
7913 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7915 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7916 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7918 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7920 else if (hash_mode
== 10700)
7922 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7924 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7925 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7927 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7929 else if (hash_mode
== 10900)
7931 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7933 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7934 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7936 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7938 else if (hash_mode
== 11100)
7940 u32 salt_challenge
= salt
.salt_buf
[0];
7942 salt_challenge
= byte_swap_32 (salt_challenge
);
7944 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7946 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7947 SIGNATURE_POSTGRESQL_AUTH
,
7955 else if (hash_mode
== 11200)
7957 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7958 SIGNATURE_MYSQL_AUTH
,
7959 (unsigned char *) salt
.salt_buf
,
7966 else if (hash_mode
== 11300)
7968 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7970 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7972 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7973 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7974 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7976 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7977 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7978 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7980 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7982 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7984 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7987 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7989 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7991 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7994 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7996 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
7998 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8001 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8002 SIGNATURE_BITCOIN_WALLET
,
8006 (unsigned char *) salt
.salt_buf
,
8014 free (cry_master_buf
);
8016 free (public_key_buf
);
8018 else if (hash_mode
== 11400)
8020 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8022 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8023 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8025 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8027 else if (hash_mode
== 11600)
8029 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8031 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8033 const uint data_len
= seven_zip
->data_len
;
8035 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8037 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8039 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8041 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8044 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8045 SIGNATURE_SEVEN_ZIP
,
8049 (char *) seven_zip
->salt_buf
,
8051 seven_zip
->iv_buf
[0],
8052 seven_zip
->iv_buf
[1],
8053 seven_zip
->iv_buf
[2],
8054 seven_zip
->iv_buf
[3],
8056 seven_zip
->data_len
,
8057 seven_zip
->unpack_size
,
8062 else if (hash_mode
== 11700)
8064 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8074 else if (hash_mode
== 11800)
8076 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8094 else if (hash_mode
== 11900)
8096 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8098 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8099 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8101 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8103 else if (hash_mode
== 12000)
8105 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8107 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8108 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8110 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8112 else if (hash_mode
== 12100)
8114 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8116 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8117 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8119 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8121 else if (hash_mode
== 12200)
8123 uint
*ptr_digest
= digest_buf
;
8124 uint
*ptr_salt
= salt
.salt_buf
;
8126 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8133 else if (hash_mode
== 12300)
8135 uint
*ptr_digest
= digest_buf
;
8136 uint
*ptr_salt
= salt
.salt_buf
;
8138 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",
8139 ptr_digest
[ 0], ptr_digest
[ 1],
8140 ptr_digest
[ 2], ptr_digest
[ 3],
8141 ptr_digest
[ 4], ptr_digest
[ 5],
8142 ptr_digest
[ 6], ptr_digest
[ 7],
8143 ptr_digest
[ 8], ptr_digest
[ 9],
8144 ptr_digest
[10], ptr_digest
[11],
8145 ptr_digest
[12], ptr_digest
[13],
8146 ptr_digest
[14], ptr_digest
[15],
8152 else if (hash_mode
== 12400)
8154 // encode iteration count
8156 char salt_iter
[5] = { 0 };
8158 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8159 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8160 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8161 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8166 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8167 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8168 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8169 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8174 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8176 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8177 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8179 memcpy (tmp_buf
, digest_buf
, 8);
8181 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8185 // fill the resulting buffer
8187 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8189 else if (hash_mode
== 12500)
8191 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8193 byte_swap_32 (salt
.salt_buf
[0]),
8194 byte_swap_32 (salt
.salt_buf
[1]),
8200 else if (hash_mode
== 12600)
8202 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8203 digest_buf
[0] + salt
.salt_buf_pc
[0],
8204 digest_buf
[1] + salt
.salt_buf_pc
[1],
8205 digest_buf
[2] + salt
.salt_buf_pc
[2],
8206 digest_buf
[3] + salt
.salt_buf_pc
[3],
8207 digest_buf
[4] + salt
.salt_buf_pc
[4],
8208 digest_buf
[5] + salt
.salt_buf_pc
[5],
8209 digest_buf
[6] + salt
.salt_buf_pc
[6],
8210 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8212 else if (hash_mode
== 12700)
8214 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8216 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8217 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8219 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8221 else if (hash_mode
== 12800)
8223 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8225 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",
8238 byte_swap_32 (digest_buf
[0]),
8239 byte_swap_32 (digest_buf
[1]),
8240 byte_swap_32 (digest_buf
[2]),
8241 byte_swap_32 (digest_buf
[3]),
8242 byte_swap_32 (digest_buf
[4]),
8243 byte_swap_32 (digest_buf
[5]),
8244 byte_swap_32 (digest_buf
[6]),
8245 byte_swap_32 (digest_buf
[7])
8248 else if (hash_mode
== 12900)
8250 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",
8259 byte_swap_32 (digest_buf
[0]),
8260 byte_swap_32 (digest_buf
[1]),
8261 byte_swap_32 (digest_buf
[2]),
8262 byte_swap_32 (digest_buf
[3]),
8263 byte_swap_32 (digest_buf
[4]),
8264 byte_swap_32 (digest_buf
[5]),
8265 byte_swap_32 (digest_buf
[6]),
8266 byte_swap_32 (digest_buf
[7]),
8273 else if (hash_mode
== 13000)
8275 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8277 rar5_t
*rar5
= &rar5s
[salt_pos
];
8279 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8289 byte_swap_32 (digest_buf
[0]),
8290 byte_swap_32 (digest_buf
[1])
8293 else if (hash_mode
== 13100)
8295 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8297 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8299 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8300 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8302 char data
[2560 * 4 * 2] = { 0 };
8304 char *ptr_data
= data
;
8306 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8307 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8312 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8313 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8315 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8317 (char *) krb5tgs
->account_info
,
8321 else if (hash_mode
== 13200)
8323 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8337 else if (hash_mode
== 13300)
8339 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8340 SIGNATURE_AXCRYPT_SHA1
,
8346 else if (hash_mode
== 13400)
8348 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8350 keepass_t
*keepass
= &keepasss
[salt_pos
];
8352 u32 version
= (u32
) keepass
->version
;
8353 u32 rounds
= salt
.salt_iter
;
8354 u32 algorithm
= (u32
) keepass
->algorithm
;
8355 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8357 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8358 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8359 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8360 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8361 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8363 /* specific to version 1 */
8367 /* specific to version 2 */
8368 u32 expected_bytes_len
;
8369 u32
*ptr_expected_bytes
;
8371 u32 final_random_seed_len
;
8372 u32 transf_random_seed_len
;
8374 u32 contents_hash_len
;
8376 transf_random_seed_len
= 8;
8378 contents_hash_len
= 8;
8379 final_random_seed_len
= 8;
8382 final_random_seed_len
= 4;
8384 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8390 char *ptr_data
= out_buf
;
8392 ptr_data
+= strlen(out_buf
);
8397 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8398 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8403 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8404 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8409 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8410 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8417 contents_len
= (u32
) keepass
->contents_len
;
8418 ptr_contents
= (u32
*) keepass
->contents
;
8420 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8421 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8433 char ptr_contents_len
[10] = { 0 };
8435 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8437 sprintf (ptr_data
, "%d", contents_len
);
8439 ptr_data
+= strlen(ptr_contents_len
);
8444 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8445 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8447 else if (version
== 2)
8449 expected_bytes_len
= 8;
8450 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8452 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8453 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8458 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8459 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8473 sprintf (ptr_data
, "%d", keyfile_len
);
8480 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8481 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8484 else if (hash_mode
== 13500)
8486 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8488 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8490 const u32 salt_len
= (pstoken
->salt_len
> 512) ? 512 : pstoken
->salt_len
;
8492 char pstoken_tmp
[1024 + 1] = { 0 };
8494 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8496 const u8
*ptr
= (const u8
*) pstoken
->salt_buf
;
8498 sprintf (pstoken_tmp
+ j
, "%02x", ptr
[i
]);
8501 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8511 if (hash_type
== HASH_TYPE_MD4
)
8513 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8519 else if (hash_type
== HASH_TYPE_MD5
)
8521 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8527 else if (hash_type
== HASH_TYPE_SHA1
)
8529 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8536 else if (hash_type
== HASH_TYPE_SHA256
)
8538 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8548 else if (hash_type
== HASH_TYPE_SHA384
)
8550 uint
*ptr
= digest_buf
;
8552 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8560 else if (hash_type
== HASH_TYPE_SHA512
)
8562 uint
*ptr
= digest_buf
;
8564 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8574 else if (hash_type
== HASH_TYPE_LM
)
8576 snprintf (out_buf
, len
-1, "%08x%08x",
8580 else if (hash_type
== HASH_TYPE_ORACLEH
)
8582 snprintf (out_buf
, len
-1, "%08X%08X",
8586 else if (hash_type
== HASH_TYPE_BCRYPT
)
8588 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8589 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8591 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8593 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8595 else if (hash_type
== HASH_TYPE_KECCAK
)
8597 uint
*ptr
= digest_buf
;
8599 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",
8627 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8629 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8631 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8638 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8640 digest_buf
[ 0] = digest_buf
[ 0];
8641 digest_buf
[ 1] = digest_buf
[ 1];
8642 digest_buf
[ 2] = digest_buf
[ 2];
8643 digest_buf
[ 3] = digest_buf
[ 3];
8644 digest_buf
[ 4] = digest_buf
[ 4];
8645 digest_buf
[ 5] = digest_buf
[ 5];
8646 digest_buf
[ 6] = digest_buf
[ 6];
8647 digest_buf
[ 7] = digest_buf
[ 7];
8648 digest_buf
[ 8] = digest_buf
[ 8];
8649 digest_buf
[ 9] = digest_buf
[ 9];
8650 digest_buf
[10] = digest_buf
[10];
8651 digest_buf
[11] = digest_buf
[11];
8652 digest_buf
[12] = digest_buf
[12];
8653 digest_buf
[13] = digest_buf
[13];
8654 digest_buf
[14] = digest_buf
[14];
8655 digest_buf
[15] = digest_buf
[15];
8657 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8675 else if (hash_type
== HASH_TYPE_GOST
)
8677 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8687 else if (hash_type
== HASH_TYPE_MYSQL
)
8689 snprintf (out_buf
, len
-1, "%08x%08x",
8693 else if (hash_type
== HASH_TYPE_LOTUS5
)
8695 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8701 else if (hash_type
== HASH_TYPE_LOTUS6
)
8703 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8704 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8705 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8706 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8708 char buf
[16] = { 0 };
8710 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8711 memcpy (buf
+ 5, digest_buf
, 9);
8715 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8717 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8720 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8722 else if (hash_type
== HASH_TYPE_LOTUS8
)
8724 char buf
[52] = { 0 };
8728 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8734 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8738 buf
[26] = salt
.salt_buf_pc
[0];
8739 buf
[27] = salt
.salt_buf_pc
[1];
8743 memcpy (buf
+ 28, digest_buf
, 8);
8745 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8749 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8751 else if (hash_type
== HASH_TYPE_CRC32
)
8753 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8757 if (salt_type
== SALT_TYPE_INTERN
)
8759 size_t pos
= strlen (out_buf
);
8761 out_buf
[pos
] = data
.separator
;
8763 char *ptr
= (char *) salt
.salt_buf
;
8765 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8767 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8771 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8773 memset (hccap
, 0, sizeof (hccap_t
));
8775 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8777 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8779 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8780 wpa_t
*wpa
= &wpas
[salt_pos
];
8782 hccap
->keyver
= wpa
->keyver
;
8784 hccap
->eapol_size
= wpa
->eapol_size
;
8786 if (wpa
->keyver
!= 1)
8788 uint eapol_tmp
[64] = { 0 };
8790 for (uint i
= 0; i
< 64; i
++)
8792 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8795 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8799 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8802 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
8803 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
8804 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
8805 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
8807 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8809 uint dgst_size
= data
.dgst_size
;
8811 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8813 if (wpa
->keyver
!= 1)
8815 uint digest_tmp
[4] = { 0 };
8817 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8818 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8819 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8820 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8822 memcpy (hccap
->keymic
, digest_tmp
, 16);
8826 memcpy (hccap
->keymic
, digest_ptr
, 16);
8830 void SuspendThreads ()
8832 if (data
.devices_status
== STATUS_RUNNING
)
8834 hc_timer_set (&data
.timer_paused
);
8836 data
.devices_status
= STATUS_PAUSED
;
8838 log_info ("Paused");
8842 void ResumeThreads ()
8844 if (data
.devices_status
== STATUS_PAUSED
)
8848 hc_timer_get (data
.timer_paused
, ms_paused
);
8850 data
.ms_paused
+= ms_paused
;
8852 data
.devices_status
= STATUS_RUNNING
;
8854 log_info ("Resumed");
8860 if (data
.devices_status
!= STATUS_RUNNING
) return;
8862 data
.devices_status
= STATUS_BYPASS
;
8864 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8867 void stop_at_checkpoint ()
8869 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8871 if (data
.devices_status
!= STATUS_RUNNING
) return;
8874 // this feature only makes sense if --restore-disable was not specified
8876 if (data
.restore_disable
== 1)
8878 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8883 // check if monitoring of Restore Point updates should be enabled or disabled
8885 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8887 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8889 // save the current restore point value
8891 data
.checkpoint_cur_words
= get_lowest_words_done ();
8893 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8897 data
.devices_status
= STATUS_RUNNING
;
8899 // reset the global value for checkpoint checks
8901 data
.checkpoint_cur_words
= 0;
8903 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8909 if (data
.devices_status
== STATUS_INIT
) return;
8910 if (data
.devices_status
== STATUS_STARTING
) return;
8912 data
.devices_status
= STATUS_ABORTED
;
8917 if (data
.devices_status
== STATUS_INIT
) return;
8918 if (data
.devices_status
== STATUS_STARTING
) return;
8920 data
.devices_status
= STATUS_QUIT
;
8923 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8925 FILE *fp
= fopen (kernel_file
, "rb");
8931 memset (&st
, 0, sizeof (st
));
8933 stat (kernel_file
, &st
);
8935 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8937 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8939 if (num_read
!= (size_t) st
.st_size
)
8941 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8948 buf
[st
.st_size
] = 0;
8950 for (int i
= 0; i
< num_devices
; i
++)
8952 kernel_lengths
[i
] = (size_t) st
.st_size
;
8954 kernel_sources
[i
] = buf
;
8959 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8967 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8969 if (binary_size
> 0)
8971 FILE *fp
= fopen (dst
, "wb");
8974 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8985 restore_data_t
*init_restore (int argc
, char **argv
)
8987 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8989 if (data
.restore_disable
== 0)
8991 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8995 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8999 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
9008 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9010 int pidbin_len
= -1;
9013 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9015 FILE *fd
= fopen (pidbin
, "rb");
9019 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9021 pidbin
[pidbin_len
] = 0;
9025 char *argv0_r
= strrchr (argv
[0], '/');
9027 char *pidbin_r
= strrchr (pidbin
, '/');
9029 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9031 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9033 if (strcmp (argv0_r
, pidbin_r
) == 0)
9035 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
9042 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9044 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9046 int pidbin2_len
= -1;
9048 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9049 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9051 pidbin
[pidbin_len
] = 0;
9052 pidbin2
[pidbin2_len
] = 0;
9056 if (strcmp (pidbin
, pidbin2
) == 0)
9058 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9071 if (rd
->version_bin
< RESTORE_MIN
)
9073 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9080 memset (rd
, 0, sizeof (restore_data_t
));
9082 rd
->version_bin
= VERSION_BIN
;
9085 rd
->pid
= getpid ();
9087 rd
->pid
= GetCurrentProcessId ();
9090 if (getcwd (rd
->cwd
, 255) == NULL
)
9103 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9105 FILE *fp
= fopen (eff_restore_file
, "rb");
9109 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
9114 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9116 log_error ("ERROR: cannot read %s", eff_restore_file
);
9121 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9123 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9125 for (uint i
= 0; i
< rd
->argc
; i
++)
9127 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9129 log_error ("ERROR: cannot read %s", eff_restore_file
);
9134 size_t len
= strlen (buf
);
9136 if (len
) buf
[len
- 1] = 0;
9138 rd
->argv
[i
] = mystrdup (buf
);
9145 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9147 if (chdir (rd
->cwd
))
9149 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9150 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9151 " https://github.com/philsmd/analyze_hc_restore\n"
9152 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9158 u64
get_lowest_words_done ()
9162 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9164 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9166 if (device_param
->skipped
) continue;
9168 const u64 words_done
= device_param
->words_done
;
9170 if (words_done
< words_cur
) words_cur
= words_done
;
9173 // It's possible that a device's workload isn't finished right after a restore-case.
9174 // In that case, this function would return 0 and overwrite the real restore point
9175 // There's also data.words_cur which is set to rd->words_cur but it changes while
9176 // the attack is running therefore we should stick to rd->words_cur.
9177 // Note that -s influences rd->words_cur we should keep a close look on that.
9179 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9184 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9186 u64 words_cur
= get_lowest_words_done ();
9188 rd
->words_cur
= words_cur
;
9190 FILE *fp
= fopen (new_restore_file
, "wb");
9194 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9199 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9201 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9206 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9208 for (uint i
= 0; i
< rd
->argc
; i
++)
9210 fprintf (fp
, "%s", rd
->argv
[i
]);
9216 fsync (fileno (fp
));
9221 void cycle_restore ()
9223 const char *eff_restore_file
= data
.eff_restore_file
;
9224 const char *new_restore_file
= data
.new_restore_file
;
9226 restore_data_t
*rd
= data
.rd
;
9228 write_restore (new_restore_file
, rd
);
9232 memset (&st
, 0, sizeof(st
));
9234 if (stat (eff_restore_file
, &st
) == 0)
9236 if (unlink (eff_restore_file
))
9238 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9242 if (rename (new_restore_file
, eff_restore_file
))
9244 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9248 void check_checkpoint ()
9250 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9252 u64 words_cur
= get_lowest_words_done ();
9254 if (words_cur
!= data
.checkpoint_cur_words
)
9264 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9268 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9270 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9272 myfree (alias
->device_name
);
9273 myfree (alias
->alias_name
);
9276 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9278 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9280 myfree (entry
->device_name
);
9283 myfree (tuning_db
->alias_buf
);
9284 myfree (tuning_db
->entry_buf
);
9289 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9291 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9293 int num_lines
= count_lines (fp
);
9295 // a bit over-allocated
9297 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9298 tuning_db
->alias_cnt
= 0;
9300 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9301 tuning_db
->entry_cnt
= 0;
9306 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9308 FILE *fp
= fopen (tuning_db_file
, "rb");
9312 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9317 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9323 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9327 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9329 if (line_buf
== NULL
) break;
9333 const int line_len
= in_superchop (line_buf
);
9335 if (line_len
== 0) continue;
9337 if (line_buf
[0] == '#') continue;
9341 char *token_ptr
[7] = { NULL
};
9345 char *next
= strtok (line_buf
, "\t ");
9347 token_ptr
[token_cnt
] = next
;
9351 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9353 token_ptr
[token_cnt
] = next
;
9360 char *device_name
= token_ptr
[0];
9361 char *alias_name
= token_ptr
[1];
9363 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9365 alias
->device_name
= mystrdup (device_name
);
9366 alias
->alias_name
= mystrdup (alias_name
);
9368 tuning_db
->alias_cnt
++;
9370 else if (token_cnt
== 6)
9372 if ((token_ptr
[1][0] != '0') &&
9373 (token_ptr
[1][0] != '1') &&
9374 (token_ptr
[1][0] != '3') &&
9375 (token_ptr
[1][0] != '*'))
9377 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9382 if ((token_ptr
[3][0] != '1') &&
9383 (token_ptr
[3][0] != '2') &&
9384 (token_ptr
[3][0] != '4') &&
9385 (token_ptr
[3][0] != '8') &&
9386 (token_ptr
[3][0] != 'N'))
9388 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9393 char *device_name
= token_ptr
[0];
9395 int attack_mode
= -1;
9397 int vector_width
= -1;
9398 int kernel_accel
= -1;
9399 int kernel_loops
= -1;
9401 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9402 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9403 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9405 if (token_ptr
[4][0] != 'A')
9407 kernel_accel
= atoi (token_ptr
[4]);
9409 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9411 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9421 if (token_ptr
[5][0] != 'A')
9423 kernel_loops
= atoi (token_ptr
[5]);
9425 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9427 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9437 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9439 entry
->device_name
= mystrdup (device_name
);
9440 entry
->attack_mode
= attack_mode
;
9441 entry
->hash_type
= hash_type
;
9442 entry
->vector_width
= vector_width
;
9443 entry
->kernel_accel
= kernel_accel
;
9444 entry
->kernel_loops
= kernel_loops
;
9446 tuning_db
->entry_cnt
++;
9450 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9460 // todo: print loaded 'cnt' message
9462 // sort the database
9464 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9465 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9470 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9472 static tuning_db_entry_t s
;
9474 // first we need to convert all spaces in the device_name to underscore
9476 char *device_name_nospace
= strdup (device_param
->device_name
);
9478 int device_name_length
= strlen (device_name_nospace
);
9482 for (i
= 0; i
< device_name_length
; i
++)
9484 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9487 // find out if there's an alias configured
9489 tuning_db_alias_t a
;
9491 a
.device_name
= device_name_nospace
;
9493 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
);
9495 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9497 // attack-mode 6 and 7 are attack-mode 1 basically
9499 if (attack_mode
== 6) attack_mode
= 1;
9500 if (attack_mode
== 7) attack_mode
= 1;
9502 // bsearch is not ideal but fast enough
9504 s
.device_name
= device_name_nospace
;
9505 s
.attack_mode
= attack_mode
;
9506 s
.hash_type
= hash_type
;
9508 tuning_db_entry_t
*entry
= NULL
;
9510 // this will produce all 2^3 combinations required
9512 for (i
= 0; i
< 8; i
++)
9514 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9515 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9516 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9518 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9520 if (entry
!= NULL
) break;
9522 // in non-wildcard mode do some additional checks:
9526 // in case we have an alias-name
9528 if (alias_name
!= NULL
)
9530 s
.device_name
= alias_name
;
9532 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9534 if (entry
!= NULL
) break;
9537 // or by device type
9539 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9541 s
.device_name
= "DEVICE_TYPE_CPU";
9543 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9545 s
.device_name
= "DEVICE_TYPE_GPU";
9547 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9549 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9552 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9554 if (entry
!= NULL
) break;
9558 // free converted device_name
9560 myfree (device_name_nospace
);
9569 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9571 u8 tmp
[256] = { 0 };
9573 if (salt_len
> sizeof (tmp
))
9578 memcpy (tmp
, in
, salt_len
);
9580 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9582 if ((salt_len
% 2) == 0)
9584 u32 new_salt_len
= salt_len
/ 2;
9586 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9591 tmp
[i
] = hex_convert (p1
) << 0;
9592 tmp
[i
] |= hex_convert (p0
) << 4;
9595 salt_len
= new_salt_len
;
9602 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9604 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9607 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9609 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9613 u32
*tmp_uint
= (u32
*) tmp
;
9615 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9616 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9617 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9618 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9619 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9620 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9621 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9622 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9623 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9624 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9626 salt_len
= salt_len
* 2;
9634 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9636 lowercase (tmp
, salt_len
);
9639 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9641 uppercase (tmp
, salt_len
);
9646 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9651 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9656 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9658 u32
*tmp_uint
= (uint
*) tmp
;
9664 for (u32 i
= 0; i
< max
; i
++)
9666 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9669 // Important: we may need to increase the length of memcpy since
9670 // we don't want to "loose" some swapped bytes (could happen if
9671 // they do not perfectly fit in the 4-byte blocks)
9672 // Memcpy does always copy the bytes in the BE order, but since
9673 // we swapped them, some important bytes could be in positions
9674 // we normally skip with the original len
9676 if (len
% 4) len
+= 4 - (len
% 4);
9679 memcpy (out
, tmp
, len
);
9684 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9686 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9688 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9690 u32
*digest
= (u32
*) hash_buf
->digest
;
9692 salt_t
*salt
= hash_buf
->salt
;
9694 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9696 char *iter_pos
= input_buf
+ 4;
9698 salt
->salt_iter
= 1 << atoi (iter_pos
);
9700 char *salt_pos
= strchr (iter_pos
, '$');
9702 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9708 salt
->salt_len
= salt_len
;
9710 u8 tmp_buf
[100] = { 0 };
9712 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9714 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9716 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9718 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9719 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9720 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9721 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9723 char *hash_pos
= salt_pos
+ 22;
9725 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9727 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9729 memcpy (digest
, tmp_buf
, 24);
9731 digest
[0] = byte_swap_32 (digest
[0]);
9732 digest
[1] = byte_swap_32 (digest
[1]);
9733 digest
[2] = byte_swap_32 (digest
[2]);
9734 digest
[3] = byte_swap_32 (digest
[3]);
9735 digest
[4] = byte_swap_32 (digest
[4]);
9736 digest
[5] = byte_swap_32 (digest
[5]);
9738 digest
[5] &= ~0xff; // its just 23 not 24 !
9743 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9745 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9747 u32
*digest
= (u32
*) hash_buf
->digest
;
9749 u8 tmp_buf
[100] = { 0 };
9751 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9753 memcpy (digest
, tmp_buf
, 32);
9755 digest
[0] = byte_swap_32 (digest
[0]);
9756 digest
[1] = byte_swap_32 (digest
[1]);
9757 digest
[2] = byte_swap_32 (digest
[2]);
9758 digest
[3] = byte_swap_32 (digest
[3]);
9759 digest
[4] = byte_swap_32 (digest
[4]);
9760 digest
[5] = byte_swap_32 (digest
[5]);
9761 digest
[6] = byte_swap_32 (digest
[6]);
9762 digest
[7] = byte_swap_32 (digest
[7]);
9764 digest
[0] -= SHA256M_A
;
9765 digest
[1] -= SHA256M_B
;
9766 digest
[2] -= SHA256M_C
;
9767 digest
[3] -= SHA256M_D
;
9768 digest
[4] -= SHA256M_E
;
9769 digest
[5] -= SHA256M_F
;
9770 digest
[6] -= SHA256M_G
;
9771 digest
[7] -= SHA256M_H
;
9776 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9778 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9780 u32
*digest
= (u32
*) hash_buf
->digest
;
9782 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9783 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9785 digest
[0] = byte_swap_32 (digest
[0]);
9786 digest
[1] = byte_swap_32 (digest
[1]);
9790 IP (digest
[0], digest
[1], tt
);
9792 digest
[0] = digest
[0];
9793 digest
[1] = digest
[1];
9800 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9802 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
9804 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
9806 u32
*digest
= (u32
*) hash_buf
->digest
;
9808 salt_t
*salt
= hash_buf
->salt
;
9810 char *hash_pos
= input_buf
+ 10;
9812 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9813 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9814 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9815 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9816 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9818 digest
[0] -= SHA1M_A
;
9819 digest
[1] -= SHA1M_B
;
9820 digest
[2] -= SHA1M_C
;
9821 digest
[3] -= SHA1M_D
;
9822 digest
[4] -= SHA1M_E
;
9826 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9828 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9830 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9832 salt
->salt_len
= salt_len
;
9837 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9839 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9841 u32
*digest
= (u32
*) hash_buf
->digest
;
9843 salt_t
*salt
= hash_buf
->salt
;
9845 char *hash_pos
= input_buf
+ 8;
9847 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9848 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9849 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9850 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9851 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9853 digest
[0] -= SHA1M_A
;
9854 digest
[1] -= SHA1M_B
;
9855 digest
[2] -= SHA1M_C
;
9856 digest
[3] -= SHA1M_D
;
9857 digest
[4] -= SHA1M_E
;
9861 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9863 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9865 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9867 salt
->salt_len
= salt_len
;
9872 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9874 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9876 u64
*digest
= (u64
*) hash_buf
->digest
;
9878 salt_t
*salt
= hash_buf
->salt
;
9880 char *hash_pos
= input_buf
+ 8;
9882 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9883 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9884 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9885 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9886 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9887 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9888 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9889 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9891 digest
[0] -= SHA512M_A
;
9892 digest
[1] -= SHA512M_B
;
9893 digest
[2] -= SHA512M_C
;
9894 digest
[3] -= SHA512M_D
;
9895 digest
[4] -= SHA512M_E
;
9896 digest
[5] -= SHA512M_F
;
9897 digest
[6] -= SHA512M_G
;
9898 digest
[7] -= SHA512M_H
;
9902 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9904 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9906 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9908 salt
->salt_len
= salt_len
;
9913 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9915 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9917 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9921 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9924 u32
*digest
= (u32
*) hash_buf
->digest
;
9926 salt_t
*salt
= hash_buf
->salt
;
9928 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9929 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9930 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9931 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9933 digest
[0] = byte_swap_32 (digest
[0]);
9934 digest
[1] = byte_swap_32 (digest
[1]);
9935 digest
[2] = byte_swap_32 (digest
[2]);
9936 digest
[3] = byte_swap_32 (digest
[3]);
9938 digest
[0] -= MD5M_A
;
9939 digest
[1] -= MD5M_B
;
9940 digest
[2] -= MD5M_C
;
9941 digest
[3] -= MD5M_D
;
9943 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9945 uint salt_len
= input_len
- 32 - 1;
9947 char *salt_buf
= input_buf
+ 32 + 1;
9949 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9951 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9953 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9955 salt
->salt_len
= salt_len
;
9960 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9962 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9964 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9968 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9973 char clean_input_buf
[32] = { 0 };
9975 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9976 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9978 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9982 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9988 clean_input_buf
[k
] = input_buf
[i
];
9996 u32
*digest
= (u32
*) hash_buf
->digest
;
9998 salt_t
*salt
= hash_buf
->salt
;
10000 u32 a
, b
, c
, d
, e
, f
;
10002 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10003 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10004 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10005 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10006 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10007 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10009 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10010 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10012 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10013 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10014 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10015 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10016 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10017 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10019 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10020 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10022 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10023 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10024 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10025 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10026 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10027 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10029 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10030 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10032 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10033 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10034 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10035 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10036 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10037 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10039 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10040 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10042 digest
[0] = byte_swap_32 (digest
[0]);
10043 digest
[1] = byte_swap_32 (digest
[1]);
10044 digest
[2] = byte_swap_32 (digest
[2]);
10045 digest
[3] = byte_swap_32 (digest
[3]);
10047 digest
[0] -= MD5M_A
;
10048 digest
[1] -= MD5M_B
;
10049 digest
[2] -= MD5M_C
;
10050 digest
[3] -= MD5M_D
;
10052 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10054 uint salt_len
= input_len
- 30 - 1;
10056 char *salt_buf
= input_buf
+ 30 + 1;
10058 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10060 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10062 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10063 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10065 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10067 salt
->salt_len
= salt_len
;
10069 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10071 salt
->salt_len
+= 22;
10073 return (PARSER_OK
);
10076 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10078 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10080 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10084 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10087 u32
*digest
= (u32
*) hash_buf
->digest
;
10089 salt_t
*salt
= hash_buf
->salt
;
10091 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10092 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10093 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10094 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10095 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10097 digest
[0] -= SHA1M_A
;
10098 digest
[1] -= SHA1M_B
;
10099 digest
[2] -= SHA1M_C
;
10100 digest
[3] -= SHA1M_D
;
10101 digest
[4] -= SHA1M_E
;
10103 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10105 uint salt_len
= input_len
- 40 - 1;
10107 char *salt_buf
= input_buf
+ 40 + 1;
10109 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10111 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10113 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10115 salt
->salt_len
= salt_len
;
10117 return (PARSER_OK
);
10120 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10122 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10124 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10128 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10131 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10133 char *iter_pos
= input_buf
+ 6;
10135 salt_t
*salt
= hash_buf
->salt
;
10137 uint iter
= atoi (iter_pos
);
10141 iter
= ROUNDS_DCC2
;
10144 salt
->salt_iter
= iter
- 1;
10146 char *salt_pos
= strchr (iter_pos
, '#');
10148 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10152 char *digest_pos
= strchr (salt_pos
, '#');
10154 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10158 uint salt_len
= digest_pos
- salt_pos
- 1;
10160 u32
*digest
= (u32
*) hash_buf
->digest
;
10162 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10163 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10164 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10165 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10167 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10169 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10171 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10173 salt
->salt_len
= salt_len
;
10175 return (PARSER_OK
);
10178 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10180 u32
*digest
= (u32
*) hash_buf
->digest
;
10182 salt_t
*salt
= hash_buf
->salt
;
10184 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10188 memcpy (&in
, input_buf
, input_len
);
10190 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10192 memcpy (digest
, in
.keymic
, 16);
10195 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10196 The phrase "Pairwise key expansion"
10197 Access Point Address (referred to as Authenticator Address AA)
10198 Supplicant Address (referred to as Supplicant Address SA)
10199 Access Point Nonce (referred to as Authenticator Anonce)
10200 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10203 uint salt_len
= strlen (in
.essid
);
10207 log_info ("WARNING: the length of the ESSID is too long. The hccap file may be invalid or corrupted");
10209 return (PARSER_SALT_LENGTH
);
10212 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10214 salt
->salt_len
= salt_len
;
10216 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10218 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10220 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10222 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10224 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10225 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10229 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10230 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10233 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10235 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10236 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10240 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10241 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10244 for (int i
= 0; i
< 25; i
++)
10246 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10249 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10250 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10251 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10252 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10254 wpa
->keyver
= in
.keyver
;
10256 if (wpa
->keyver
> 255)
10258 log_info ("ATTENTION!");
10259 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10260 log_info (" This could be due to a recent aircrack-ng bug.");
10261 log_info (" The key version was automatically reset to a reasonable value.");
10264 wpa
->keyver
&= 0xff;
10267 wpa
->eapol_size
= in
.eapol_size
;
10269 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10271 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10273 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10275 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10277 if (wpa
->keyver
== 1)
10283 digest
[0] = byte_swap_32 (digest
[0]);
10284 digest
[1] = byte_swap_32 (digest
[1]);
10285 digest
[2] = byte_swap_32 (digest
[2]);
10286 digest
[3] = byte_swap_32 (digest
[3]);
10288 for (int i
= 0; i
< 64; i
++)
10290 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10294 uint32_t *p0
= (uint32_t *) in
.essid
;
10298 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10299 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10301 salt
->salt_buf
[10] = c0
;
10302 salt
->salt_buf
[11] = c1
;
10304 return (PARSER_OK
);
10307 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10309 u32
*digest
= (u32
*) hash_buf
->digest
;
10311 salt_t
*salt
= hash_buf
->salt
;
10313 if (input_len
== 0)
10315 log_error ("Password Safe v2 container not specified");
10320 FILE *fp
= fopen (input_buf
, "rb");
10324 log_error ("%s: %s", input_buf
, strerror (errno
));
10331 memset (&buf
, 0, sizeof (psafe2_hdr
));
10333 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10337 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10339 salt
->salt_buf
[0] = buf
.random
[0];
10340 salt
->salt_buf
[1] = buf
.random
[1];
10342 salt
->salt_len
= 8;
10343 salt
->salt_iter
= 1000;
10345 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10346 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10347 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10348 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10349 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10351 return (PARSER_OK
);
10354 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10356 u32
*digest
= (u32
*) hash_buf
->digest
;
10358 salt_t
*salt
= hash_buf
->salt
;
10360 if (input_len
== 0)
10362 log_error (".psafe3 not specified");
10367 FILE *fp
= fopen (input_buf
, "rb");
10371 log_error ("%s: %s", input_buf
, strerror (errno
));
10378 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10382 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10384 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10386 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10388 salt
->salt_iter
= in
.iterations
+ 1;
10390 salt
->salt_buf
[0] = in
.salt_buf
[0];
10391 salt
->salt_buf
[1] = in
.salt_buf
[1];
10392 salt
->salt_buf
[2] = in
.salt_buf
[2];
10393 salt
->salt_buf
[3] = in
.salt_buf
[3];
10394 salt
->salt_buf
[4] = in
.salt_buf
[4];
10395 salt
->salt_buf
[5] = in
.salt_buf
[5];
10396 salt
->salt_buf
[6] = in
.salt_buf
[6];
10397 salt
->salt_buf
[7] = in
.salt_buf
[7];
10399 salt
->salt_len
= 32;
10401 digest
[0] = in
.hash_buf
[0];
10402 digest
[1] = in
.hash_buf
[1];
10403 digest
[2] = in
.hash_buf
[2];
10404 digest
[3] = in
.hash_buf
[3];
10405 digest
[4] = in
.hash_buf
[4];
10406 digest
[5] = in
.hash_buf
[5];
10407 digest
[6] = in
.hash_buf
[6];
10408 digest
[7] = in
.hash_buf
[7];
10410 digest
[0] = byte_swap_32 (digest
[0]);
10411 digest
[1] = byte_swap_32 (digest
[1]);
10412 digest
[2] = byte_swap_32 (digest
[2]);
10413 digest
[3] = byte_swap_32 (digest
[3]);
10414 digest
[4] = byte_swap_32 (digest
[4]);
10415 digest
[5] = byte_swap_32 (digest
[5]);
10416 digest
[6] = byte_swap_32 (digest
[6]);
10417 digest
[7] = byte_swap_32 (digest
[7]);
10419 return (PARSER_OK
);
10422 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10424 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10426 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10428 u32
*digest
= (u32
*) hash_buf
->digest
;
10430 salt_t
*salt
= hash_buf
->salt
;
10432 char *iter_pos
= input_buf
+ 3;
10434 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10436 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10438 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10440 salt
->salt_iter
= salt_iter
;
10442 char *salt_pos
= iter_pos
+ 1;
10446 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10448 salt
->salt_len
= salt_len
;
10450 char *hash_pos
= salt_pos
+ salt_len
;
10452 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10454 return (PARSER_OK
);
10457 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10459 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10461 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10463 u32
*digest
= (u32
*) hash_buf
->digest
;
10465 salt_t
*salt
= hash_buf
->salt
;
10467 char *salt_pos
= input_buf
+ 3;
10469 uint iterations_len
= 0;
10471 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10475 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10477 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10478 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10482 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10486 iterations_len
+= 8;
10490 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10493 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10495 char *hash_pos
= strchr (salt_pos
, '$');
10497 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10499 uint salt_len
= hash_pos
- salt_pos
;
10501 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10503 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10505 salt
->salt_len
= salt_len
;
10509 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10511 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10513 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10515 return (PARSER_OK
);
10518 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10520 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10522 u32
*digest
= (u32
*) hash_buf
->digest
;
10524 salt_t
*salt
= hash_buf
->salt
;
10526 char *salt_pos
= input_buf
+ 6;
10528 uint iterations_len
= 0;
10530 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10534 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10536 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10537 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10541 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10545 iterations_len
+= 8;
10549 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10552 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10554 char *hash_pos
= strchr (salt_pos
, '$');
10556 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10558 uint salt_len
= hash_pos
- salt_pos
;
10560 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10562 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10564 salt
->salt_len
= salt_len
;
10568 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10570 return (PARSER_OK
);
10573 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10575 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10577 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10579 u32
*digest
= (u32
*) hash_buf
->digest
;
10581 salt_t
*salt
= hash_buf
->salt
;
10583 char *salt_pos
= input_buf
+ 14;
10585 char *hash_pos
= strchr (salt_pos
, '*');
10587 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10591 uint salt_len
= hash_pos
- salt_pos
- 1;
10593 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10595 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10597 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10599 salt
->salt_len
= salt_len
;
10601 u8 tmp_buf
[100] = { 0 };
10603 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10605 memcpy (digest
, tmp_buf
, 20);
10607 digest
[0] = byte_swap_32 (digest
[0]);
10608 digest
[1] = byte_swap_32 (digest
[1]);
10609 digest
[2] = byte_swap_32 (digest
[2]);
10610 digest
[3] = byte_swap_32 (digest
[3]);
10611 digest
[4] = byte_swap_32 (digest
[4]);
10613 digest
[0] -= SHA1M_A
;
10614 digest
[1] -= SHA1M_B
;
10615 digest
[2] -= SHA1M_C
;
10616 digest
[3] -= SHA1M_D
;
10617 digest
[4] -= SHA1M_E
;
10619 return (PARSER_OK
);
10622 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10624 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10626 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10628 if (c12
& 3) return (PARSER_HASH_VALUE
);
10630 u32
*digest
= (u32
*) hash_buf
->digest
;
10632 salt_t
*salt
= hash_buf
->salt
;
10634 // for ascii_digest
10635 salt
->salt_sign
[0] = input_buf
[0];
10636 salt
->salt_sign
[1] = input_buf
[1];
10638 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10639 | itoa64_to_int (input_buf
[1]) << 6;
10641 salt
->salt_len
= 2;
10643 u8 tmp_buf
[100] = { 0 };
10645 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10647 memcpy (digest
, tmp_buf
, 8);
10651 IP (digest
[0], digest
[1], tt
);
10656 return (PARSER_OK
);
10659 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10661 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10663 u32
*digest
= (u32
*) hash_buf
->digest
;
10665 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10666 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10667 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10668 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10670 digest
[0] = byte_swap_32 (digest
[0]);
10671 digest
[1] = byte_swap_32 (digest
[1]);
10672 digest
[2] = byte_swap_32 (digest
[2]);
10673 digest
[3] = byte_swap_32 (digest
[3]);
10675 digest
[0] -= MD4M_A
;
10676 digest
[1] -= MD4M_B
;
10677 digest
[2] -= MD4M_C
;
10678 digest
[3] -= MD4M_D
;
10680 return (PARSER_OK
);
10683 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10685 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10687 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10691 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10694 u32
*digest
= (u32
*) hash_buf
->digest
;
10696 salt_t
*salt
= hash_buf
->salt
;
10698 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10699 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10700 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10701 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10703 digest
[0] = byte_swap_32 (digest
[0]);
10704 digest
[1] = byte_swap_32 (digest
[1]);
10705 digest
[2] = byte_swap_32 (digest
[2]);
10706 digest
[3] = byte_swap_32 (digest
[3]);
10708 digest
[0] -= MD4M_A
;
10709 digest
[1] -= MD4M_B
;
10710 digest
[2] -= MD4M_C
;
10711 digest
[3] -= MD4M_D
;
10713 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10715 uint salt_len
= input_len
- 32 - 1;
10717 char *salt_buf
= input_buf
+ 32 + 1;
10719 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10721 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10723 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10725 salt
->salt_len
= salt_len
;
10727 return (PARSER_OK
);
10730 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10732 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10734 u32
*digest
= (u32
*) hash_buf
->digest
;
10736 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10737 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10738 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10739 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10741 digest
[0] = byte_swap_32 (digest
[0]);
10742 digest
[1] = byte_swap_32 (digest
[1]);
10743 digest
[2] = byte_swap_32 (digest
[2]);
10744 digest
[3] = byte_swap_32 (digest
[3]);
10746 digest
[0] -= MD5M_A
;
10747 digest
[1] -= MD5M_B
;
10748 digest
[2] -= MD5M_C
;
10749 digest
[3] -= MD5M_D
;
10751 return (PARSER_OK
);
10754 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10756 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10758 u32
*digest
= (u32
*) hash_buf
->digest
;
10760 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10761 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10765 digest
[0] = byte_swap_32 (digest
[0]);
10766 digest
[1] = byte_swap_32 (digest
[1]);
10768 return (PARSER_OK
);
10771 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10773 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10775 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10779 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10782 u32
*digest
= (u32
*) hash_buf
->digest
;
10784 salt_t
*salt
= hash_buf
->salt
;
10786 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10787 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10788 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10789 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10791 digest
[0] = byte_swap_32 (digest
[0]);
10792 digest
[1] = byte_swap_32 (digest
[1]);
10793 digest
[2] = byte_swap_32 (digest
[2]);
10794 digest
[3] = byte_swap_32 (digest
[3]);
10796 digest
[0] -= MD5M_A
;
10797 digest
[1] -= MD5M_B
;
10798 digest
[2] -= MD5M_C
;
10799 digest
[3] -= MD5M_D
;
10801 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10803 uint salt_len
= input_len
- 32 - 1;
10805 char *salt_buf
= input_buf
+ 32 + 1;
10807 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10809 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10811 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10813 salt
->salt_len
= salt_len
;
10815 return (PARSER_OK
);
10818 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10820 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10822 u32
*digest
= (u32
*) hash_buf
->digest
;
10824 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10825 | itoa64_to_int (input_buf
[ 1]) << 6
10826 | itoa64_to_int (input_buf
[ 2]) << 12
10827 | itoa64_to_int (input_buf
[ 3]) << 18;
10828 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10829 | itoa64_to_int (input_buf
[ 5]) << 6
10830 | itoa64_to_int (input_buf
[ 6]) << 12
10831 | itoa64_to_int (input_buf
[ 7]) << 18;
10832 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10833 | itoa64_to_int (input_buf
[ 9]) << 6
10834 | itoa64_to_int (input_buf
[10]) << 12
10835 | itoa64_to_int (input_buf
[11]) << 18;
10836 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10837 | itoa64_to_int (input_buf
[13]) << 6
10838 | itoa64_to_int (input_buf
[14]) << 12
10839 | itoa64_to_int (input_buf
[15]) << 18;
10841 digest
[0] -= MD5M_A
;
10842 digest
[1] -= MD5M_B
;
10843 digest
[2] -= MD5M_C
;
10844 digest
[3] -= MD5M_D
;
10846 digest
[0] &= 0x00ffffff;
10847 digest
[1] &= 0x00ffffff;
10848 digest
[2] &= 0x00ffffff;
10849 digest
[3] &= 0x00ffffff;
10851 return (PARSER_OK
);
10854 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10856 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10858 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10862 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10865 u32
*digest
= (u32
*) hash_buf
->digest
;
10867 salt_t
*salt
= hash_buf
->salt
;
10869 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10870 | itoa64_to_int (input_buf
[ 1]) << 6
10871 | itoa64_to_int (input_buf
[ 2]) << 12
10872 | itoa64_to_int (input_buf
[ 3]) << 18;
10873 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10874 | itoa64_to_int (input_buf
[ 5]) << 6
10875 | itoa64_to_int (input_buf
[ 6]) << 12
10876 | itoa64_to_int (input_buf
[ 7]) << 18;
10877 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10878 | itoa64_to_int (input_buf
[ 9]) << 6
10879 | itoa64_to_int (input_buf
[10]) << 12
10880 | itoa64_to_int (input_buf
[11]) << 18;
10881 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10882 | itoa64_to_int (input_buf
[13]) << 6
10883 | itoa64_to_int (input_buf
[14]) << 12
10884 | itoa64_to_int (input_buf
[15]) << 18;
10886 digest
[0] -= MD5M_A
;
10887 digest
[1] -= MD5M_B
;
10888 digest
[2] -= MD5M_C
;
10889 digest
[3] -= MD5M_D
;
10891 digest
[0] &= 0x00ffffff;
10892 digest
[1] &= 0x00ffffff;
10893 digest
[2] &= 0x00ffffff;
10894 digest
[3] &= 0x00ffffff;
10896 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10898 uint salt_len
= input_len
- 16 - 1;
10900 char *salt_buf
= input_buf
+ 16 + 1;
10902 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10904 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10906 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10908 salt
->salt_len
= salt_len
;
10910 return (PARSER_OK
);
10913 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10915 key
[0] = (nthash
[0] >> 0);
10916 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10917 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10918 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10919 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10920 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10921 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10922 key
[7] = (nthash
[6] << 1);
10934 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10936 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10938 u32
*digest
= (u32
*) hash_buf
->digest
;
10940 salt_t
*salt
= hash_buf
->salt
;
10942 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10948 char *user_pos
= input_buf
;
10950 char *unused_pos
= strchr (user_pos
, ':');
10952 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10954 uint user_len
= unused_pos
- user_pos
;
10956 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10960 char *domain_pos
= strchr (unused_pos
, ':');
10962 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10964 uint unused_len
= domain_pos
- unused_pos
;
10966 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10970 char *srvchall_pos
= strchr (domain_pos
, ':');
10972 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10974 uint domain_len
= srvchall_pos
- domain_pos
;
10976 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10980 char *hash_pos
= strchr (srvchall_pos
, ':');
10982 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10984 uint srvchall_len
= hash_pos
- srvchall_pos
;
10986 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10990 char *clichall_pos
= strchr (hash_pos
, ':');
10992 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10994 uint hash_len
= clichall_pos
- hash_pos
;
10996 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11000 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11002 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11005 * store some data for later use
11008 netntlm
->user_len
= user_len
* 2;
11009 netntlm
->domain_len
= domain_len
* 2;
11010 netntlm
->srvchall_len
= srvchall_len
/ 2;
11011 netntlm
->clichall_len
= clichall_len
/ 2;
11013 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11014 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11017 * handle username and domainname
11020 for (uint i
= 0; i
< user_len
; i
++)
11022 *userdomain_ptr
++ = user_pos
[i
];
11023 *userdomain_ptr
++ = 0;
11026 for (uint i
= 0; i
< domain_len
; i
++)
11028 *userdomain_ptr
++ = domain_pos
[i
];
11029 *userdomain_ptr
++ = 0;
11033 * handle server challenge encoding
11036 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11038 const char p0
= srvchall_pos
[i
+ 0];
11039 const char p1
= srvchall_pos
[i
+ 1];
11041 *chall_ptr
++ = hex_convert (p1
) << 0
11042 | hex_convert (p0
) << 4;
11046 * handle client challenge encoding
11049 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11051 const char p0
= clichall_pos
[i
+ 0];
11052 const char p1
= clichall_pos
[i
+ 1];
11054 *chall_ptr
++ = hex_convert (p1
) << 0
11055 | hex_convert (p0
) << 4;
11062 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11064 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11066 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11068 salt
->salt_len
= salt_len
;
11070 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11071 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11072 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11073 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11075 digest
[0] = byte_swap_32 (digest
[0]);
11076 digest
[1] = byte_swap_32 (digest
[1]);
11077 digest
[2] = byte_swap_32 (digest
[2]);
11078 digest
[3] = byte_swap_32 (digest
[3]);
11080 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11082 uint digest_tmp
[2] = { 0 };
11084 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11085 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11087 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11088 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11090 /* special case 2: ESS */
11092 if (srvchall_len
== 48)
11094 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11096 uint w
[16] = { 0 };
11098 w
[ 0] = netntlm
->chall_buf
[6];
11099 w
[ 1] = netntlm
->chall_buf
[7];
11100 w
[ 2] = netntlm
->chall_buf
[0];
11101 w
[ 3] = netntlm
->chall_buf
[1];
11105 uint dgst
[4] = { 0 };
11114 salt
->salt_buf
[0] = dgst
[0];
11115 salt
->salt_buf
[1] = dgst
[1];
11119 /* precompute netntlmv1 exploit start */
11121 for (uint i
= 0; i
< 0x10000; i
++)
11123 uint key_md4
[2] = { i
, 0 };
11124 uint key_des
[2] = { 0, 0 };
11126 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11128 uint Kc
[16] = { 0 };
11129 uint Kd
[16] = { 0 };
11131 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11133 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11135 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11137 if (data3
[0] != digest_tmp
[0]) continue;
11138 if (data3
[1] != digest_tmp
[1]) continue;
11140 salt
->salt_buf
[2] = i
;
11142 salt
->salt_len
= 24;
11147 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11148 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11150 /* precompute netntlmv1 exploit stop */
11154 IP (digest
[0], digest
[1], tt
);
11155 IP (digest
[2], digest
[3], tt
);
11157 digest
[0] = rotr32 (digest
[0], 29);
11158 digest
[1] = rotr32 (digest
[1], 29);
11159 digest
[2] = rotr32 (digest
[2], 29);
11160 digest
[3] = rotr32 (digest
[3], 29);
11162 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11164 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11165 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11167 return (PARSER_OK
);
11170 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11172 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11174 u32
*digest
= (u32
*) hash_buf
->digest
;
11176 salt_t
*salt
= hash_buf
->salt
;
11178 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11184 char *user_pos
= input_buf
;
11186 char *unused_pos
= strchr (user_pos
, ':');
11188 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11190 uint user_len
= unused_pos
- user_pos
;
11192 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11196 char *domain_pos
= strchr (unused_pos
, ':');
11198 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11200 uint unused_len
= domain_pos
- unused_pos
;
11202 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11206 char *srvchall_pos
= strchr (domain_pos
, ':');
11208 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11210 uint domain_len
= srvchall_pos
- domain_pos
;
11212 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11216 char *hash_pos
= strchr (srvchall_pos
, ':');
11218 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11220 uint srvchall_len
= hash_pos
- srvchall_pos
;
11222 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11226 char *clichall_pos
= strchr (hash_pos
, ':');
11228 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11230 uint hash_len
= clichall_pos
- hash_pos
;
11232 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11236 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11238 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11240 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11243 * store some data for later use
11246 netntlm
->user_len
= user_len
* 2;
11247 netntlm
->domain_len
= domain_len
* 2;
11248 netntlm
->srvchall_len
= srvchall_len
/ 2;
11249 netntlm
->clichall_len
= clichall_len
/ 2;
11251 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11252 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11255 * handle username and domainname
11258 for (uint i
= 0; i
< user_len
; i
++)
11260 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11261 *userdomain_ptr
++ = 0;
11264 for (uint i
= 0; i
< domain_len
; i
++)
11266 *userdomain_ptr
++ = domain_pos
[i
];
11267 *userdomain_ptr
++ = 0;
11270 *userdomain_ptr
++ = 0x80;
11273 * handle server challenge encoding
11276 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11278 const char p0
= srvchall_pos
[i
+ 0];
11279 const char p1
= srvchall_pos
[i
+ 1];
11281 *chall_ptr
++ = hex_convert (p1
) << 0
11282 | hex_convert (p0
) << 4;
11286 * handle client challenge encoding
11289 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11291 const char p0
= clichall_pos
[i
+ 0];
11292 const char p1
= clichall_pos
[i
+ 1];
11294 *chall_ptr
++ = hex_convert (p1
) << 0
11295 | hex_convert (p0
) << 4;
11298 *chall_ptr
++ = 0x80;
11301 * handle hash itself
11304 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11305 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11306 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11307 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11309 digest
[0] = byte_swap_32 (digest
[0]);
11310 digest
[1] = byte_swap_32 (digest
[1]);
11311 digest
[2] = byte_swap_32 (digest
[2]);
11312 digest
[3] = byte_swap_32 (digest
[3]);
11315 * reuse challange data as salt_buf, its the buffer that is most likely unique
11318 salt
->salt_buf
[0] = 0;
11319 salt
->salt_buf
[1] = 0;
11320 salt
->salt_buf
[2] = 0;
11321 salt
->salt_buf
[3] = 0;
11322 salt
->salt_buf
[4] = 0;
11323 salt
->salt_buf
[5] = 0;
11324 salt
->salt_buf
[6] = 0;
11325 salt
->salt_buf
[7] = 0;
11329 uptr
= (uint
*) netntlm
->userdomain_buf
;
11331 for (uint i
= 0; i
< 16; i
+= 16)
11333 md5_64 (uptr
, salt
->salt_buf
);
11336 uptr
= (uint
*) netntlm
->chall_buf
;
11338 for (uint i
= 0; i
< 256; i
+= 16)
11340 md5_64 (uptr
, salt
->salt_buf
);
11343 salt
->salt_len
= 16;
11345 return (PARSER_OK
);
11348 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11350 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11352 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11356 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11359 u32
*digest
= (u32
*) hash_buf
->digest
;
11361 salt_t
*salt
= hash_buf
->salt
;
11363 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11364 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11365 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11366 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11368 digest
[0] = byte_swap_32 (digest
[0]);
11369 digest
[1] = byte_swap_32 (digest
[1]);
11370 digest
[2] = byte_swap_32 (digest
[2]);
11371 digest
[3] = byte_swap_32 (digest
[3]);
11373 digest
[0] -= MD5M_A
;
11374 digest
[1] -= MD5M_B
;
11375 digest
[2] -= MD5M_C
;
11376 digest
[3] -= MD5M_D
;
11378 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11380 uint salt_len
= input_len
- 32 - 1;
11382 char *salt_buf
= input_buf
+ 32 + 1;
11384 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11386 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11388 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11390 salt
->salt_len
= salt_len
;
11392 return (PARSER_OK
);
11395 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11397 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11399 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11403 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11406 u32
*digest
= (u32
*) hash_buf
->digest
;
11408 salt_t
*salt
= hash_buf
->salt
;
11410 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11411 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11412 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11413 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11415 digest
[0] = byte_swap_32 (digest
[0]);
11416 digest
[1] = byte_swap_32 (digest
[1]);
11417 digest
[2] = byte_swap_32 (digest
[2]);
11418 digest
[3] = byte_swap_32 (digest
[3]);
11420 digest
[0] -= MD5M_A
;
11421 digest
[1] -= MD5M_B
;
11422 digest
[2] -= MD5M_C
;
11423 digest
[3] -= MD5M_D
;
11425 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11427 uint salt_len
= input_len
- 32 - 1;
11429 char *salt_buf
= input_buf
+ 32 + 1;
11431 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11433 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11435 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11437 salt
->salt_len
= salt_len
;
11439 return (PARSER_OK
);
11442 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11444 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11446 u32
*digest
= (u32
*) hash_buf
->digest
;
11448 salt_t
*salt
= hash_buf
->salt
;
11450 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11451 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11452 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11453 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11455 digest
[0] = byte_swap_32 (digest
[0]);
11456 digest
[1] = byte_swap_32 (digest
[1]);
11457 digest
[2] = byte_swap_32 (digest
[2]);
11458 digest
[3] = byte_swap_32 (digest
[3]);
11460 digest
[0] -= MD5M_A
;
11461 digest
[1] -= MD5M_B
;
11462 digest
[2] -= MD5M_C
;
11463 digest
[3] -= MD5M_D
;
11466 * This is a virtual salt. While the algorithm is basically not salted
11467 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11468 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11471 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11473 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11475 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11477 salt
->salt_len
= salt_len
;
11479 return (PARSER_OK
);
11482 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11484 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11486 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11490 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11493 u32
*digest
= (u32
*) hash_buf
->digest
;
11495 salt_t
*salt
= hash_buf
->salt
;
11497 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11498 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11499 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11500 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11502 digest
[0] = byte_swap_32 (digest
[0]);
11503 digest
[1] = byte_swap_32 (digest
[1]);
11504 digest
[2] = byte_swap_32 (digest
[2]);
11505 digest
[3] = byte_swap_32 (digest
[3]);
11507 digest
[0] -= MD5M_A
;
11508 digest
[1] -= MD5M_B
;
11509 digest
[2] -= MD5M_C
;
11510 digest
[3] -= MD5M_D
;
11512 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11514 uint salt_len
= input_len
- 32 - 1;
11516 char *salt_buf
= input_buf
+ 32 + 1;
11518 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11520 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11522 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11524 salt
->salt_len
= salt_len
;
11526 return (PARSER_OK
);
11529 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11531 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11533 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11537 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11540 u32
*digest
= (u32
*) hash_buf
->digest
;
11542 salt_t
*salt
= hash_buf
->salt
;
11544 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11545 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11546 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11547 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11549 digest
[0] = byte_swap_32 (digest
[0]);
11550 digest
[1] = byte_swap_32 (digest
[1]);
11551 digest
[2] = byte_swap_32 (digest
[2]);
11552 digest
[3] = byte_swap_32 (digest
[3]);
11554 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11556 uint salt_len
= input_len
- 32 - 1;
11558 char *salt_buf
= input_buf
+ 32 + 1;
11560 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11562 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11564 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11566 salt
->salt_len
= salt_len
;
11568 return (PARSER_OK
);
11571 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11573 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11575 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11579 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11582 u32
*digest
= (u32
*) hash_buf
->digest
;
11584 salt_t
*salt
= hash_buf
->salt
;
11586 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11587 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11588 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11589 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11591 digest
[0] = byte_swap_32 (digest
[0]);
11592 digest
[1] = byte_swap_32 (digest
[1]);
11593 digest
[2] = byte_swap_32 (digest
[2]);
11594 digest
[3] = byte_swap_32 (digest
[3]);
11596 digest
[0] -= MD4M_A
;
11597 digest
[1] -= MD4M_B
;
11598 digest
[2] -= MD4M_C
;
11599 digest
[3] -= MD4M_D
;
11601 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11603 uint salt_len
= input_len
- 32 - 1;
11605 char *salt_buf
= input_buf
+ 32 + 1;
11607 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11609 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11611 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11613 salt
->salt_len
= salt_len
;
11615 return (PARSER_OK
);
11618 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11620 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11622 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11626 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11629 u32
*digest
= (u32
*) hash_buf
->digest
;
11631 salt_t
*salt
= hash_buf
->salt
;
11633 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11634 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11635 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11636 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11638 digest
[0] = byte_swap_32 (digest
[0]);
11639 digest
[1] = byte_swap_32 (digest
[1]);
11640 digest
[2] = byte_swap_32 (digest
[2]);
11641 digest
[3] = byte_swap_32 (digest
[3]);
11643 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11645 uint salt_len
= input_len
- 32 - 1;
11647 char *salt_buf
= input_buf
+ 32 + 1;
11649 uint salt_pc_block
[16] = { 0 };
11651 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11653 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11655 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11657 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11659 salt_pc_block
[14] = salt_len
* 8;
11661 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11663 md5_64 (salt_pc_block
, salt_pc_digest
);
11665 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11666 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11667 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11668 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11670 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11672 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11674 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11676 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11677 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11678 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11679 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11681 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11683 return (PARSER_OK
);
11686 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11688 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11690 u32
*digest
= (u32
*) hash_buf
->digest
;
11692 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11693 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11694 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11695 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11696 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11698 digest
[0] -= SHA1M_A
;
11699 digest
[1] -= SHA1M_B
;
11700 digest
[2] -= SHA1M_C
;
11701 digest
[3] -= SHA1M_D
;
11702 digest
[4] -= SHA1M_E
;
11704 return (PARSER_OK
);
11707 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11709 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11711 u32
*digest
= (u32
*) hash_buf
->digest
;
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]);
11717 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11719 return (PARSER_OK
);
11722 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11724 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
11726 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
11728 u32
*digest
= (u32
*) hash_buf
->digest
;
11732 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11733 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11734 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11735 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11736 digest
[4] = 0x00000000;
11738 return (PARSER_OK
);
11741 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11743 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11745 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11749 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11752 u32
*digest
= (u32
*) hash_buf
->digest
;
11754 salt_t
*salt
= hash_buf
->salt
;
11756 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11757 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11758 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11759 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11760 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11762 digest
[0] -= SHA1M_A
;
11763 digest
[1] -= SHA1M_B
;
11764 digest
[2] -= SHA1M_C
;
11765 digest
[3] -= SHA1M_D
;
11766 digest
[4] -= SHA1M_E
;
11768 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11770 uint salt_len
= input_len
- 40 - 1;
11772 char *salt_buf
= input_buf
+ 40 + 1;
11774 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11776 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11778 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11780 salt
->salt_len
= salt_len
;
11782 return (PARSER_OK
);
11785 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11787 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
11789 u32
*digest
= (u32
*) hash_buf
->digest
;
11791 salt_t
*salt
= hash_buf
->salt
;
11793 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
11795 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11796 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11797 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11798 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11799 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11801 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11803 uint salt_len
= input_len
- 40 - 1;
11805 char *salt_buf
= input_buf
+ 40 + 1;
11807 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
11809 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
11811 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
11813 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
11816 pstoken
->salt_len
= salt_len
/ 2;
11818 /* some fake salt for the sorting mechanisms */
11820 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
11821 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
11822 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
11823 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
11824 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
11825 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
11826 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
11827 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
11829 salt
->salt_len
= 32;
11831 /* we need to check if we can precompute some of the data --
11832 this is possible since the scheme is badly designed */
11834 pstoken
->pc_digest
[0] = SHA1M_A
;
11835 pstoken
->pc_digest
[1] = SHA1M_B
;
11836 pstoken
->pc_digest
[2] = SHA1M_C
;
11837 pstoken
->pc_digest
[3] = SHA1M_D
;
11838 pstoken
->pc_digest
[4] = SHA1M_E
;
11840 pstoken
->pc_offset
= 0;
11842 for (int i
= 0; i
< (int) pstoken
->salt_len
- 64; i
+= 64)
11846 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
11847 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
11848 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
11849 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
11850 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
11851 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
11852 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
11853 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
11854 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
11855 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
11856 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
11857 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
11858 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
11859 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
11860 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
11861 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
11863 sha1_64 (w
, pstoken
->pc_digest
);
11865 pstoken
->pc_offset
+= 16;
11868 return (PARSER_OK
);
11871 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11873 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11875 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11877 u32
*digest
= (u32
*) hash_buf
->digest
;
11879 u8 tmp_buf
[100] = { 0 };
11881 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11883 memcpy (digest
, tmp_buf
, 20);
11885 digest
[0] = byte_swap_32 (digest
[0]);
11886 digest
[1] = byte_swap_32 (digest
[1]);
11887 digest
[2] = byte_swap_32 (digest
[2]);
11888 digest
[3] = byte_swap_32 (digest
[3]);
11889 digest
[4] = byte_swap_32 (digest
[4]);
11891 digest
[0] -= SHA1M_A
;
11892 digest
[1] -= SHA1M_B
;
11893 digest
[2] -= SHA1M_C
;
11894 digest
[3] -= SHA1M_D
;
11895 digest
[4] -= SHA1M_E
;
11897 return (PARSER_OK
);
11900 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11902 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11904 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11906 u32
*digest
= (u32
*) hash_buf
->digest
;
11908 salt_t
*salt
= hash_buf
->salt
;
11910 u8 tmp_buf
[100] = { 0 };
11912 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11914 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
11916 memcpy (digest
, tmp_buf
, 20);
11918 int salt_len
= tmp_len
- 20;
11920 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
11922 salt
->salt_len
= salt_len
;
11924 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11926 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11928 char *ptr
= (char *) salt
->salt_buf
;
11930 ptr
[salt
->salt_len
] = 0x80;
11933 digest
[0] = byte_swap_32 (digest
[0]);
11934 digest
[1] = byte_swap_32 (digest
[1]);
11935 digest
[2] = byte_swap_32 (digest
[2]);
11936 digest
[3] = byte_swap_32 (digest
[3]);
11937 digest
[4] = byte_swap_32 (digest
[4]);
11939 digest
[0] -= SHA1M_A
;
11940 digest
[1] -= SHA1M_B
;
11941 digest
[2] -= SHA1M_C
;
11942 digest
[3] -= SHA1M_D
;
11943 digest
[4] -= SHA1M_E
;
11945 return (PARSER_OK
);
11948 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11950 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11952 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11954 u32
*digest
= (u32
*) hash_buf
->digest
;
11956 salt_t
*salt
= hash_buf
->salt
;
11958 char *salt_buf
= input_buf
+ 6;
11962 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11964 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11966 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11968 salt
->salt_len
= salt_len
;
11970 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11972 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11973 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11974 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11975 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11976 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[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 return (PARSER_OK
);
11987 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11989 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11991 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11993 u32
*digest
= (u32
*) hash_buf
->digest
;
11995 salt_t
*salt
= hash_buf
->salt
;
11997 char *salt_buf
= input_buf
+ 6;
12001 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12003 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12005 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12007 salt
->salt_len
= salt_len
;
12009 char *hash_pos
= input_buf
+ 6 + 8;
12011 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12012 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12013 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12014 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12015 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12017 digest
[0] -= SHA1M_A
;
12018 digest
[1] -= SHA1M_B
;
12019 digest
[2] -= SHA1M_C
;
12020 digest
[3] -= SHA1M_D
;
12021 digest
[4] -= SHA1M_E
;
12023 return (PARSER_OK
);
12026 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12028 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12030 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12032 u64
*digest
= (u64
*) hash_buf
->digest
;
12034 salt_t
*salt
= hash_buf
->salt
;
12036 char *salt_buf
= input_buf
+ 6;
12040 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12042 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12044 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12046 salt
->salt_len
= salt_len
;
12048 char *hash_pos
= input_buf
+ 6 + 8;
12050 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12051 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12052 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12053 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12054 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12055 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12056 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12057 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12059 digest
[0] -= SHA512M_A
;
12060 digest
[1] -= SHA512M_B
;
12061 digest
[2] -= SHA512M_C
;
12062 digest
[3] -= SHA512M_D
;
12063 digest
[4] -= SHA512M_E
;
12064 digest
[5] -= SHA512M_F
;
12065 digest
[6] -= SHA512M_G
;
12066 digest
[7] -= SHA512M_H
;
12068 return (PARSER_OK
);
12071 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12073 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12075 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12079 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12082 u32
*digest
= (u32
*) hash_buf
->digest
;
12084 salt_t
*salt
= hash_buf
->salt
;
12086 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12087 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12091 digest
[0] = byte_swap_32 (digest
[0]);
12092 digest
[1] = byte_swap_32 (digest
[1]);
12094 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12096 uint salt_len
= input_len
- 16 - 1;
12098 char *salt_buf
= input_buf
+ 16 + 1;
12100 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12102 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12104 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12106 salt
->salt_len
= salt_len
;
12108 return (PARSER_OK
);
12111 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12113 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12115 u32
*digest
= (u32
*) hash_buf
->digest
;
12117 salt_t
*salt
= hash_buf
->salt
;
12119 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12120 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12121 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12122 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12123 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12125 digest
[0] -= SHA1M_A
;
12126 digest
[1] -= SHA1M_B
;
12127 digest
[2] -= SHA1M_C
;
12128 digest
[3] -= SHA1M_D
;
12129 digest
[4] -= SHA1M_E
;
12131 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12133 uint salt_len
= input_len
- 40 - 1;
12135 char *salt_buf
= input_buf
+ 40 + 1;
12137 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12139 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12141 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12143 salt
->salt_len
= salt_len
;
12145 return (PARSER_OK
);
12148 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12150 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12152 u32
*digest
= (u32
*) hash_buf
->digest
;
12154 salt_t
*salt
= hash_buf
->salt
;
12156 char *hash_pos
= input_buf
;
12158 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12159 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12160 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12161 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12162 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12163 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12164 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12165 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12166 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12167 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12168 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12169 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12170 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12171 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12172 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12173 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12175 char *salt_pos
= input_buf
+ 128;
12177 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12178 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12179 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12180 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12182 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12183 salt
->salt_len
= 16;
12185 return (PARSER_OK
);
12188 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12190 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12192 u32
*digest
= (u32
*) hash_buf
->digest
;
12194 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12195 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12196 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12197 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12198 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12199 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12200 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12201 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12203 digest
[0] -= SHA256M_A
;
12204 digest
[1] -= SHA256M_B
;
12205 digest
[2] -= SHA256M_C
;
12206 digest
[3] -= SHA256M_D
;
12207 digest
[4] -= SHA256M_E
;
12208 digest
[5] -= SHA256M_F
;
12209 digest
[6] -= SHA256M_G
;
12210 digest
[7] -= SHA256M_H
;
12212 return (PARSER_OK
);
12215 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12217 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12219 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12223 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12226 u32
*digest
= (u32
*) hash_buf
->digest
;
12228 salt_t
*salt
= hash_buf
->salt
;
12230 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12231 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12232 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12233 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12234 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12235 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12236 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12237 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12239 digest
[0] -= SHA256M_A
;
12240 digest
[1] -= SHA256M_B
;
12241 digest
[2] -= SHA256M_C
;
12242 digest
[3] -= SHA256M_D
;
12243 digest
[4] -= SHA256M_E
;
12244 digest
[5] -= SHA256M_F
;
12245 digest
[6] -= SHA256M_G
;
12246 digest
[7] -= SHA256M_H
;
12248 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12250 uint salt_len
= input_len
- 64 - 1;
12252 char *salt_buf
= input_buf
+ 64 + 1;
12254 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12256 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12258 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12260 salt
->salt_len
= salt_len
;
12262 return (PARSER_OK
);
12265 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12267 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12269 u64
*digest
= (u64
*) hash_buf
->digest
;
12271 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12272 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12273 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12274 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12275 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12276 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12280 digest
[0] -= SHA384M_A
;
12281 digest
[1] -= SHA384M_B
;
12282 digest
[2] -= SHA384M_C
;
12283 digest
[3] -= SHA384M_D
;
12284 digest
[4] -= SHA384M_E
;
12285 digest
[5] -= SHA384M_F
;
12289 return (PARSER_OK
);
12292 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12294 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12296 u64
*digest
= (u64
*) hash_buf
->digest
;
12298 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12299 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12300 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12301 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12302 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12303 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12304 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12305 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12307 digest
[0] -= SHA512M_A
;
12308 digest
[1] -= SHA512M_B
;
12309 digest
[2] -= SHA512M_C
;
12310 digest
[3] -= SHA512M_D
;
12311 digest
[4] -= SHA512M_E
;
12312 digest
[5] -= SHA512M_F
;
12313 digest
[6] -= SHA512M_G
;
12314 digest
[7] -= SHA512M_H
;
12316 return (PARSER_OK
);
12319 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12321 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12323 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12327 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12330 u64
*digest
= (u64
*) hash_buf
->digest
;
12332 salt_t
*salt
= hash_buf
->salt
;
12334 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12335 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12336 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12337 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12338 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12339 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12340 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12341 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12343 digest
[0] -= SHA512M_A
;
12344 digest
[1] -= SHA512M_B
;
12345 digest
[2] -= SHA512M_C
;
12346 digest
[3] -= SHA512M_D
;
12347 digest
[4] -= SHA512M_E
;
12348 digest
[5] -= SHA512M_F
;
12349 digest
[6] -= SHA512M_G
;
12350 digest
[7] -= SHA512M_H
;
12352 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12354 uint salt_len
= input_len
- 128 - 1;
12356 char *salt_buf
= input_buf
+ 128 + 1;
12358 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12360 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12362 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12364 salt
->salt_len
= salt_len
;
12366 return (PARSER_OK
);
12369 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12371 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12373 u64
*digest
= (u64
*) hash_buf
->digest
;
12375 salt_t
*salt
= hash_buf
->salt
;
12377 char *salt_pos
= input_buf
+ 3;
12379 uint iterations_len
= 0;
12381 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12385 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12387 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12388 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12392 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12396 iterations_len
+= 8;
12400 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12403 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12405 char *hash_pos
= strchr (salt_pos
, '$');
12407 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12409 uint salt_len
= hash_pos
- salt_pos
;
12411 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12413 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12415 salt
->salt_len
= salt_len
;
12419 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12421 return (PARSER_OK
);
12424 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12426 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12428 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12430 u64
*digest
= (u64
*) hash_buf
->digest
;
12432 salt_t
*salt
= hash_buf
->salt
;
12434 uint keccak_mdlen
= input_len
/ 2;
12436 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12438 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12440 digest
[i
] = byte_swap_64 (digest
[i
]);
12443 salt
->keccak_mdlen
= keccak_mdlen
;
12445 return (PARSER_OK
);
12448 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12450 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12452 u32
*digest
= (u32
*) hash_buf
->digest
;
12454 salt_t
*salt
= hash_buf
->salt
;
12456 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12459 * Parse that strange long line
12464 size_t in_len
[9] = { 0 };
12466 in_off
[0] = strtok (input_buf
, ":");
12468 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12470 in_len
[0] = strlen (in_off
[0]);
12474 for (i
= 1; i
< 9; i
++)
12476 in_off
[i
] = strtok (NULL
, ":");
12478 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12480 in_len
[i
] = strlen (in_off
[i
]);
12483 char *ptr
= (char *) ikepsk
->msg_buf
;
12485 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12486 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12487 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12488 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12489 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12490 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12494 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12496 ptr
= (char *) ikepsk
->nr_buf
;
12498 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12499 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12503 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12506 * Store to database
12511 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12512 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12513 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12514 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12516 digest
[0] = byte_swap_32 (digest
[0]);
12517 digest
[1] = byte_swap_32 (digest
[1]);
12518 digest
[2] = byte_swap_32 (digest
[2]);
12519 digest
[3] = byte_swap_32 (digest
[3]);
12521 salt
->salt_len
= 32;
12523 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12524 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12525 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12526 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12527 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12528 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12529 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12530 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12532 return (PARSER_OK
);
12535 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12537 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12539 u32
*digest
= (u32
*) hash_buf
->digest
;
12541 salt_t
*salt
= hash_buf
->salt
;
12543 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12546 * Parse that strange long line
12551 size_t in_len
[9] = { 0 };
12553 in_off
[0] = strtok (input_buf
, ":");
12555 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12557 in_len
[0] = strlen (in_off
[0]);
12561 for (i
= 1; i
< 9; i
++)
12563 in_off
[i
] = strtok (NULL
, ":");
12565 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12567 in_len
[i
] = strlen (in_off
[i
]);
12570 char *ptr
= (char *) ikepsk
->msg_buf
;
12572 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12573 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12574 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12575 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12576 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12577 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12581 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12583 ptr
= (char *) ikepsk
->nr_buf
;
12585 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12586 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12590 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12593 * Store to database
12598 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12599 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12600 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12601 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12602 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12604 salt
->salt_len
= 32;
12606 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12607 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12608 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12609 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12610 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12611 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12612 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12613 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12615 return (PARSER_OK
);
12618 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12620 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12622 u32
*digest
= (u32
*) hash_buf
->digest
;
12624 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12625 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12626 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12627 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12628 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12630 digest
[0] = byte_swap_32 (digest
[0]);
12631 digest
[1] = byte_swap_32 (digest
[1]);
12632 digest
[2] = byte_swap_32 (digest
[2]);
12633 digest
[3] = byte_swap_32 (digest
[3]);
12634 digest
[4] = byte_swap_32 (digest
[4]);
12636 return (PARSER_OK
);
12639 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12641 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12643 u32
*digest
= (u32
*) hash_buf
->digest
;
12645 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12646 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12647 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12648 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12649 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12650 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12651 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12652 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12653 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12654 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12655 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12656 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12657 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12658 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12659 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12660 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12662 return (PARSER_OK
);
12665 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12667 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12669 u32
*digest
= (u32
*) hash_buf
->digest
;
12671 salt_t
*salt
= hash_buf
->salt
;
12673 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12674 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12675 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12676 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12677 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12679 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12681 uint salt_len
= input_len
- 40 - 1;
12683 char *salt_buf
= input_buf
+ 40 + 1;
12685 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12687 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12689 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12691 salt
->salt_len
= salt_len
;
12693 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12695 return (PARSER_OK
);
12698 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12700 u32
*digest
= (u32
*) hash_buf
->digest
;
12702 salt_t
*salt
= hash_buf
->salt
;
12704 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12706 if (input_len
== 0)
12708 log_error ("TrueCrypt container not specified");
12713 FILE *fp
= fopen (input_buf
, "rb");
12717 log_error ("%s: %s", input_buf
, strerror (errno
));
12722 char buf
[512] = { 0 };
12724 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12728 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12730 memcpy (tc
->salt_buf
, buf
, 64);
12732 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12734 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12736 salt
->salt_len
= 4;
12738 salt
->salt_iter
= 1000 - 1;
12740 digest
[0] = tc
->data_buf
[0];
12742 return (PARSER_OK
);
12745 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12747 u32
*digest
= (u32
*) hash_buf
->digest
;
12749 salt_t
*salt
= hash_buf
->salt
;
12751 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12753 if (input_len
== 0)
12755 log_error ("TrueCrypt container not specified");
12760 FILE *fp
= fopen (input_buf
, "rb");
12764 log_error ("%s: %s", input_buf
, strerror (errno
));
12769 char buf
[512] = { 0 };
12771 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12775 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12777 memcpy (tc
->salt_buf
, buf
, 64);
12779 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12781 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12783 salt
->salt_len
= 4;
12785 salt
->salt_iter
= 2000 - 1;
12787 digest
[0] = tc
->data_buf
[0];
12789 return (PARSER_OK
);
12792 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12794 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12796 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12798 u32
*digest
= (u32
*) hash_buf
->digest
;
12800 salt_t
*salt
= hash_buf
->salt
;
12802 char *salt_pos
= input_buf
+ 6;
12804 char *hash_pos
= strchr (salt_pos
, '$');
12806 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12808 uint salt_len
= hash_pos
- salt_pos
;
12810 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12812 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12814 salt
->salt_len
= salt_len
;
12816 salt
->salt_iter
= 1000;
12820 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12822 return (PARSER_OK
);
12825 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12827 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12829 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12831 u32
*digest
= (u32
*) hash_buf
->digest
;
12833 salt_t
*salt
= hash_buf
->salt
;
12835 char *iter_pos
= input_buf
+ 7;
12837 char *salt_pos
= strchr (iter_pos
, '$');
12839 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12843 char *hash_pos
= strchr (salt_pos
, '$');
12845 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12847 uint salt_len
= hash_pos
- salt_pos
;
12849 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12851 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12853 salt
->salt_len
= salt_len
;
12855 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12857 salt
->salt_sign
[0] = atoi (salt_iter
);
12859 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12863 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12865 digest
[0] = byte_swap_32 (digest
[0]);
12866 digest
[1] = byte_swap_32 (digest
[1]);
12867 digest
[2] = byte_swap_32 (digest
[2]);
12868 digest
[3] = byte_swap_32 (digest
[3]);
12869 digest
[4] = byte_swap_32 (digest
[4]);
12871 return (PARSER_OK
);
12874 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12876 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12878 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12880 u32
*digest
= (u32
*) hash_buf
->digest
;
12882 salt_t
*salt
= hash_buf
->salt
;
12884 char *iter_pos
= input_buf
+ 9;
12886 char *salt_pos
= strchr (iter_pos
, '$');
12888 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12892 char *hash_pos
= strchr (salt_pos
, '$');
12894 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12896 uint salt_len
= hash_pos
- salt_pos
;
12898 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12900 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12902 salt
->salt_len
= salt_len
;
12904 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12906 salt
->salt_sign
[0] = atoi (salt_iter
);
12908 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12912 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12914 digest
[0] = byte_swap_32 (digest
[0]);
12915 digest
[1] = byte_swap_32 (digest
[1]);
12916 digest
[2] = byte_swap_32 (digest
[2]);
12917 digest
[3] = byte_swap_32 (digest
[3]);
12918 digest
[4] = byte_swap_32 (digest
[4]);
12919 digest
[5] = byte_swap_32 (digest
[5]);
12920 digest
[6] = byte_swap_32 (digest
[6]);
12921 digest
[7] = byte_swap_32 (digest
[7]);
12923 return (PARSER_OK
);
12926 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12928 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12930 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12932 u64
*digest
= (u64
*) hash_buf
->digest
;
12934 salt_t
*salt
= hash_buf
->salt
;
12936 char *iter_pos
= input_buf
+ 9;
12938 char *salt_pos
= strchr (iter_pos
, '$');
12940 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12944 char *hash_pos
= strchr (salt_pos
, '$');
12946 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12948 uint salt_len
= hash_pos
- salt_pos
;
12950 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12952 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12954 salt
->salt_len
= salt_len
;
12956 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12958 salt
->salt_sign
[0] = atoi (salt_iter
);
12960 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12964 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12966 digest
[0] = byte_swap_64 (digest
[0]);
12967 digest
[1] = byte_swap_64 (digest
[1]);
12968 digest
[2] = byte_swap_64 (digest
[2]);
12969 digest
[3] = byte_swap_64 (digest
[3]);
12970 digest
[4] = byte_swap_64 (digest
[4]);
12971 digest
[5] = byte_swap_64 (digest
[5]);
12972 digest
[6] = byte_swap_64 (digest
[6]);
12973 digest
[7] = byte_swap_64 (digest
[7]);
12975 return (PARSER_OK
);
12978 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12980 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12982 u32
*digest
= (u32
*) hash_buf
->digest
;
12984 salt_t
*salt
= hash_buf
->salt
;
12986 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12992 char *iterations_pos
= input_buf
;
12994 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12996 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12998 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13000 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13004 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13006 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13008 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13010 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13012 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13014 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13019 * pbkdf2 iterations
13022 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13025 * handle salt encoding
13028 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13030 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13032 const char p0
= saltbuf_pos
[i
+ 0];
13033 const char p1
= saltbuf_pos
[i
+ 1];
13035 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13036 | hex_convert (p0
) << 4;
13039 salt
->salt_len
= saltbuf_len
/ 2;
13042 * handle cipher encoding
13045 uint
*tmp
= (uint
*) mymalloc (32);
13047 char *cipherbuf_ptr
= (char *) tmp
;
13049 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13051 const char p0
= cipherbuf_pos
[i
+ 0];
13052 const char p1
= cipherbuf_pos
[i
+ 1];
13054 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13055 | hex_convert (p0
) << 4;
13058 // iv is stored at salt_buf 4 (length 16)
13059 // data is stored at salt_buf 8 (length 16)
13061 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13062 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13063 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13064 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13066 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13067 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13068 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13069 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13073 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13075 const char p0
= cipherbuf_pos
[j
+ 0];
13076 const char p1
= cipherbuf_pos
[j
+ 1];
13078 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13079 | hex_convert (p0
) << 4;
13086 digest
[0] = 0x10101010;
13087 digest
[1] = 0x10101010;
13088 digest
[2] = 0x10101010;
13089 digest
[3] = 0x10101010;
13091 return (PARSER_OK
);
13094 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13096 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13098 u32
*digest
= (u32
*) hash_buf
->digest
;
13100 salt_t
*salt
= hash_buf
->salt
;
13102 char *hashbuf_pos
= input_buf
;
13104 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13106 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13108 uint hash_len
= iterations_pos
- hashbuf_pos
;
13110 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13114 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13116 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13118 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13122 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13124 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13126 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13128 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13130 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13132 salt
->salt_len
= salt_len
;
13134 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13136 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13137 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13138 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13139 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13141 return (PARSER_OK
);
13144 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13146 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13148 u32
*digest
= (u32
*) hash_buf
->digest
;
13150 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13151 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13152 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13153 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13154 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13155 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13156 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13157 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13159 digest
[0] = byte_swap_32 (digest
[0]);
13160 digest
[1] = byte_swap_32 (digest
[1]);
13161 digest
[2] = byte_swap_32 (digest
[2]);
13162 digest
[3] = byte_swap_32 (digest
[3]);
13163 digest
[4] = byte_swap_32 (digest
[4]);
13164 digest
[5] = byte_swap_32 (digest
[5]);
13165 digest
[6] = byte_swap_32 (digest
[6]);
13166 digest
[7] = byte_swap_32 (digest
[7]);
13168 return (PARSER_OK
);
13171 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13173 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13175 u32
*digest
= (u32
*) hash_buf
->digest
;
13177 salt_t
*salt
= hash_buf
->salt
;
13179 char *salt_pos
= input_buf
+ 3;
13181 uint iterations_len
= 0;
13183 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13187 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13189 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13190 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13194 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13198 iterations_len
+= 8;
13202 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13205 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13207 char *hash_pos
= strchr (salt_pos
, '$');
13209 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13211 uint salt_len
= hash_pos
- salt_pos
;
13213 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13215 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13217 salt
->salt_len
= salt_len
;
13221 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13223 return (PARSER_OK
);
13226 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13228 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13230 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13232 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13234 u64
*digest
= (u64
*) hash_buf
->digest
;
13236 salt_t
*salt
= hash_buf
->salt
;
13238 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13240 char *iter_pos
= input_buf
+ 4;
13242 char *salt_pos
= strchr (iter_pos
, '$');
13244 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13248 char *hash_pos
= strchr (salt_pos
, '$');
13250 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13252 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13256 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13257 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13258 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13259 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13260 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13261 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13262 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13263 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13265 uint salt_len
= hash_pos
- salt_pos
- 1;
13267 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13269 salt
->salt_len
= salt_len
/ 2;
13271 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13272 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13273 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13274 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13275 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13276 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13277 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13278 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13280 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13281 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13282 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13283 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13284 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13285 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13286 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13287 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13288 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13289 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13291 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13293 salt
->salt_iter
= atoi (iter_pos
) - 1;
13295 return (PARSER_OK
);
13298 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13300 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13302 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13304 u32
*digest
= (u32
*) hash_buf
->digest
;
13306 salt_t
*salt
= hash_buf
->salt
;
13308 char *salt_pos
= input_buf
+ 14;
13310 char *hash_pos
= strchr (salt_pos
, '*');
13312 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13316 uint salt_len
= hash_pos
- salt_pos
- 1;
13318 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13320 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13322 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13324 salt
->salt_len
= salt_len
;
13326 u8 tmp_buf
[100] = { 0 };
13328 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13330 memcpy (digest
, tmp_buf
, 32);
13332 digest
[0] = byte_swap_32 (digest
[0]);
13333 digest
[1] = byte_swap_32 (digest
[1]);
13334 digest
[2] = byte_swap_32 (digest
[2]);
13335 digest
[3] = byte_swap_32 (digest
[3]);
13336 digest
[4] = byte_swap_32 (digest
[4]);
13337 digest
[5] = byte_swap_32 (digest
[5]);
13338 digest
[6] = byte_swap_32 (digest
[6]);
13339 digest
[7] = byte_swap_32 (digest
[7]);
13341 digest
[0] -= SHA256M_A
;
13342 digest
[1] -= SHA256M_B
;
13343 digest
[2] -= SHA256M_C
;
13344 digest
[3] -= SHA256M_D
;
13345 digest
[4] -= SHA256M_E
;
13346 digest
[5] -= SHA256M_F
;
13347 digest
[6] -= SHA256M_G
;
13348 digest
[7] -= SHA256M_H
;
13350 return (PARSER_OK
);
13353 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13355 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13357 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13359 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13361 u64
*digest
= (u64
*) hash_buf
->digest
;
13363 salt_t
*salt
= hash_buf
->salt
;
13365 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13367 char *iter_pos
= input_buf
+ 19;
13369 char *salt_pos
= strchr (iter_pos
, '.');
13371 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13375 char *hash_pos
= strchr (salt_pos
, '.');
13377 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13379 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13383 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13384 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13385 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13386 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13387 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13388 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13389 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13390 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13392 uint salt_len
= hash_pos
- salt_pos
- 1;
13396 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13400 for (i
= 0; i
< salt_len
; i
++)
13402 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13405 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13406 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13408 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13410 salt
->salt_len
= salt_len
;
13412 salt
->salt_iter
= atoi (iter_pos
) - 1;
13414 return (PARSER_OK
);
13417 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13419 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13421 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13423 u64
*digest
= (u64
*) hash_buf
->digest
;
13425 salt_t
*salt
= hash_buf
->salt
;
13427 u8 tmp_buf
[120] = { 0 };
13429 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13431 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13433 memcpy (digest
, tmp_buf
, 64);
13435 digest
[0] = byte_swap_64 (digest
[0]);
13436 digest
[1] = byte_swap_64 (digest
[1]);
13437 digest
[2] = byte_swap_64 (digest
[2]);
13438 digest
[3] = byte_swap_64 (digest
[3]);
13439 digest
[4] = byte_swap_64 (digest
[4]);
13440 digest
[5] = byte_swap_64 (digest
[5]);
13441 digest
[6] = byte_swap_64 (digest
[6]);
13442 digest
[7] = byte_swap_64 (digest
[7]);
13444 digest
[0] -= SHA512M_A
;
13445 digest
[1] -= SHA512M_B
;
13446 digest
[2] -= SHA512M_C
;
13447 digest
[3] -= SHA512M_D
;
13448 digest
[4] -= SHA512M_E
;
13449 digest
[5] -= SHA512M_F
;
13450 digest
[6] -= SHA512M_G
;
13451 digest
[7] -= SHA512M_H
;
13453 int salt_len
= tmp_len
- 64;
13455 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13457 salt
->salt_len
= salt_len
;
13459 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13461 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13463 char *ptr
= (char *) salt
->salt_buf
;
13465 ptr
[salt
->salt_len
] = 0x80;
13468 return (PARSER_OK
);
13471 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13473 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13475 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13479 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13482 u32
*digest
= (u32
*) hash_buf
->digest
;
13484 salt_t
*salt
= hash_buf
->salt
;
13486 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13487 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13488 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13489 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13491 digest
[0] = byte_swap_32 (digest
[0]);
13492 digest
[1] = byte_swap_32 (digest
[1]);
13493 digest
[2] = byte_swap_32 (digest
[2]);
13494 digest
[3] = byte_swap_32 (digest
[3]);
13496 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13498 uint salt_len
= input_len
- 32 - 1;
13500 char *salt_buf
= input_buf
+ 32 + 1;
13502 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13504 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13506 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13508 salt
->salt_len
= salt_len
;
13510 return (PARSER_OK
);
13513 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13515 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13517 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13521 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13524 u32
*digest
= (u32
*) hash_buf
->digest
;
13526 salt_t
*salt
= hash_buf
->salt
;
13528 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13529 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13530 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13531 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13532 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13534 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13536 uint salt_len
= input_len
- 40 - 1;
13538 char *salt_buf
= input_buf
+ 40 + 1;
13540 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13542 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13544 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13546 salt
->salt_len
= salt_len
;
13548 return (PARSER_OK
);
13551 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13553 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13555 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13559 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13562 u32
*digest
= (u32
*) hash_buf
->digest
;
13564 salt_t
*salt
= hash_buf
->salt
;
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 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13577 uint salt_len
= input_len
- 64 - 1;
13579 char *salt_buf
= input_buf
+ 64 + 1;
13581 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13583 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13585 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13587 salt
->salt_len
= salt_len
;
13589 return (PARSER_OK
);
13592 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13594 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13596 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13600 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13603 u64
*digest
= (u64
*) hash_buf
->digest
;
13605 salt_t
*salt
= hash_buf
->salt
;
13607 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13608 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13609 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13610 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13611 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13612 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13613 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13614 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13616 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13618 uint salt_len
= input_len
- 128 - 1;
13620 char *salt_buf
= input_buf
+ 128 + 1;
13622 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13624 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13626 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13628 salt
->salt_len
= salt_len
;
13630 return (PARSER_OK
);
13633 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13635 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13637 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13639 u32
*digest
= (u32
*) hash_buf
->digest
;
13641 salt_t
*salt
= hash_buf
->salt
;
13643 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13649 char *user_pos
= input_buf
+ 10 + 1;
13651 char *realm_pos
= strchr (user_pos
, '$');
13653 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13655 uint user_len
= realm_pos
- user_pos
;
13657 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13661 char *salt_pos
= strchr (realm_pos
, '$');
13663 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13665 uint realm_len
= salt_pos
- realm_pos
;
13667 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13671 char *data_pos
= strchr (salt_pos
, '$');
13673 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13675 uint salt_len
= data_pos
- salt_pos
;
13677 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13681 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13683 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13689 memcpy (krb5pa
->user
, user_pos
, user_len
);
13690 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13691 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13693 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13695 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13697 const char p0
= data_pos
[i
+ 0];
13698 const char p1
= data_pos
[i
+ 1];
13700 *timestamp_ptr
++ = hex_convert (p1
) << 0
13701 | hex_convert (p0
) << 4;
13704 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13706 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13708 const char p0
= data_pos
[i
+ 0];
13709 const char p1
= data_pos
[i
+ 1];
13711 *checksum_ptr
++ = hex_convert (p1
) << 0
13712 | hex_convert (p0
) << 4;
13716 * copy some data to generic buffers to make sorting happy
13719 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13720 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13721 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13722 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13723 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13724 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13725 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13726 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13727 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13729 salt
->salt_len
= 36;
13731 digest
[0] = krb5pa
->checksum
[0];
13732 digest
[1] = krb5pa
->checksum
[1];
13733 digest
[2] = krb5pa
->checksum
[2];
13734 digest
[3] = krb5pa
->checksum
[3];
13736 return (PARSER_OK
);
13739 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13741 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13743 u32
*digest
= (u32
*) hash_buf
->digest
;
13745 salt_t
*salt
= hash_buf
->salt
;
13751 char *salt_pos
= input_buf
;
13753 char *hash_pos
= strchr (salt_pos
, '$');
13755 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13757 uint salt_len
= hash_pos
- salt_pos
;
13759 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13763 uint hash_len
= input_len
- 1 - salt_len
;
13765 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13773 for (uint i
= 0; i
< salt_len
; i
++)
13775 if (salt_pos
[i
] == ' ') continue;
13780 // SAP user names cannot be longer than 12 characters
13781 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13783 // SAP user name cannot start with ! or ?
13784 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13790 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13792 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13794 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13796 salt
->salt_len
= salt_len
;
13798 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13799 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13803 digest
[0] = byte_swap_32 (digest
[0]);
13804 digest
[1] = byte_swap_32 (digest
[1]);
13806 return (PARSER_OK
);
13809 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13811 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13813 u32
*digest
= (u32
*) hash_buf
->digest
;
13815 salt_t
*salt
= hash_buf
->salt
;
13821 char *salt_pos
= input_buf
;
13823 char *hash_pos
= strchr (salt_pos
, '$');
13825 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13827 uint salt_len
= hash_pos
- salt_pos
;
13829 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13833 uint hash_len
= input_len
- 1 - salt_len
;
13835 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13843 for (uint i
= 0; i
< salt_len
; i
++)
13845 if (salt_pos
[i
] == ' ') continue;
13850 // SAP user names cannot be longer than 12 characters
13851 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13852 // so far nobody complained so we stay with this because it helps in optimization
13853 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13855 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13857 // SAP user name cannot start with ! or ?
13858 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13864 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13866 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13868 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13870 salt
->salt_len
= salt_len
;
13872 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13873 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13874 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13875 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13876 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13878 return (PARSER_OK
);
13881 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13883 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13885 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13887 u64
*digest
= (u64
*) hash_buf
->digest
;
13889 salt_t
*salt
= hash_buf
->salt
;
13891 char *iter_pos
= input_buf
+ 3;
13893 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13895 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13897 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13899 salt
->salt_iter
= salt_iter
;
13901 char *salt_pos
= iter_pos
+ 1;
13905 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13907 salt
->salt_len
= salt_len
;
13909 char *hash_pos
= salt_pos
+ salt_len
;
13911 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13915 char *tmp
= (char *) salt
->salt_buf_pc
;
13917 tmp
[0] = hash_pos
[42];
13921 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13922 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13923 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13924 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13930 return (PARSER_OK
);
13933 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13935 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13937 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13939 u32
*digest
= (u32
*) hash_buf
->digest
;
13941 salt_t
*salt
= hash_buf
->salt
;
13943 char *salt_buf
= input_buf
+ 6;
13945 uint salt_len
= 16;
13947 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13949 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13951 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13953 salt
->salt_len
= salt_len
;
13955 char *hash_pos
= input_buf
+ 6 + 16;
13957 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13958 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13959 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13960 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13961 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13962 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13963 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13964 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13966 return (PARSER_OK
);
13969 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13971 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13973 u32
*digest
= (u32
*) hash_buf
->digest
;
13975 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13976 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13980 return (PARSER_OK
);
13983 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13985 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13987 u32
*digest
= (u32
*) hash_buf
->digest
;
13989 salt_t
*salt
= hash_buf
->salt
;
13991 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13993 char *saltbuf_pos
= input_buf
;
13995 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13997 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13999 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14001 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14002 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14004 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14008 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14010 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14012 char *salt_ptr
= (char *) saltbuf_pos
;
14013 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14018 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14020 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14023 rakp_ptr
[j
] = 0x80;
14025 rakp
->salt_len
= j
;
14027 for (i
= 0; i
< 64; i
++)
14029 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14032 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14033 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14034 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14035 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14036 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14037 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14038 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14039 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14041 salt
->salt_len
= 32; // muss min. 32 haben
14043 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14044 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14045 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14046 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14047 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14049 return (PARSER_OK
);
14052 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14054 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14056 u32
*digest
= (u32
*) hash_buf
->digest
;
14058 salt_t
*salt
= hash_buf
->salt
;
14060 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14062 char *salt_pos
= input_buf
+ 1;
14064 memcpy (salt
->salt_buf
, salt_pos
, 8);
14066 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14067 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14069 salt
->salt_len
= 8;
14071 char *hash_pos
= salt_pos
+ 8;
14073 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14074 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14075 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14076 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14077 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14079 digest
[0] -= SHA1M_A
;
14080 digest
[1] -= SHA1M_B
;
14081 digest
[2] -= SHA1M_C
;
14082 digest
[3] -= SHA1M_D
;
14083 digest
[4] -= SHA1M_E
;
14085 return (PARSER_OK
);
14088 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14090 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14092 u32
*digest
= (u32
*) hash_buf
->digest
;
14094 salt_t
*salt
= hash_buf
->salt
;
14096 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14097 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14098 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14099 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14101 digest
[0] = byte_swap_32 (digest
[0]);
14102 digest
[1] = byte_swap_32 (digest
[1]);
14103 digest
[2] = byte_swap_32 (digest
[2]);
14104 digest
[3] = byte_swap_32 (digest
[3]);
14106 digest
[0] -= MD5M_A
;
14107 digest
[1] -= MD5M_B
;
14108 digest
[2] -= MD5M_C
;
14109 digest
[3] -= MD5M_D
;
14111 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14113 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14115 u32
*salt_buf
= salt
->salt_buf
;
14117 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14118 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14119 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14120 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14122 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14123 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14124 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14125 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14127 salt
->salt_len
= 16 + 1;
14129 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14131 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14133 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14135 return (PARSER_OK
);
14138 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14140 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14142 u32
*digest
= (u32
*) hash_buf
->digest
;
14144 salt_t
*salt
= hash_buf
->salt
;
14146 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14152 char *hashbuf_pos
= input_buf
;
14154 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14156 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14158 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14160 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14164 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14166 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14168 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14170 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14174 char *databuf_pos
= strchr (iteration_pos
, ':');
14176 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14178 const uint iteration_len
= databuf_pos
- iteration_pos
;
14180 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14181 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14183 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14185 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14186 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14192 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14193 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14194 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14195 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14196 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14197 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14198 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14199 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14203 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14205 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14207 const char p0
= saltbuf_pos
[i
+ 0];
14208 const char p1
= saltbuf_pos
[i
+ 1];
14210 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14211 | hex_convert (p0
) << 4;
14214 salt
->salt_buf
[4] = 0x01000000;
14215 salt
->salt_buf
[5] = 0x80;
14217 salt
->salt_len
= saltbuf_len
/ 2;
14221 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14225 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14227 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14229 const char p0
= databuf_pos
[i
+ 0];
14230 const char p1
= databuf_pos
[i
+ 1];
14232 *databuf_ptr
++ = hex_convert (p1
) << 0
14233 | hex_convert (p0
) << 4;
14236 *databuf_ptr
++ = 0x80;
14238 for (uint i
= 0; i
< 512; i
++)
14240 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14243 cloudkey
->data_len
= databuf_len
/ 2;
14245 return (PARSER_OK
);
14248 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14250 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14252 u32
*digest
= (u32
*) hash_buf
->digest
;
14254 salt_t
*salt
= hash_buf
->salt
;
14260 char *hashbuf_pos
= input_buf
;
14262 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14264 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14266 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14268 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14272 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14274 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14276 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14278 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14280 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14284 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14286 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14288 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14290 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14292 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14296 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14298 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14299 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14301 // ok, the plan for this algorithm is the following:
14302 // we have 2 salts here, the domain-name and a random salt
14303 // while both are used in the initial transformation,
14304 // only the random salt is used in the following iterations
14305 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14306 // and one that includes only the real salt (stored into salt_buf[]).
14307 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14309 u8 tmp_buf
[100] = { 0 };
14311 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14313 memcpy (digest
, tmp_buf
, 20);
14315 digest
[0] = byte_swap_32 (digest
[0]);
14316 digest
[1] = byte_swap_32 (digest
[1]);
14317 digest
[2] = byte_swap_32 (digest
[2]);
14318 digest
[3] = byte_swap_32 (digest
[3]);
14319 digest
[4] = byte_swap_32 (digest
[4]);
14323 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14325 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14327 char *len_ptr
= NULL
;
14329 for (uint i
= 0; i
< domainbuf_len
; i
++)
14331 if (salt_buf_pc_ptr
[i
] == '.')
14333 len_ptr
= &salt_buf_pc_ptr
[i
];
14343 salt
->salt_buf_pc
[7] = domainbuf_len
;
14347 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14349 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14351 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14353 salt
->salt_len
= salt_len
;
14357 salt
->salt_iter
= atoi (iteration_pos
);
14359 return (PARSER_OK
);
14362 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14364 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14366 u32
*digest
= (u32
*) hash_buf
->digest
;
14368 salt_t
*salt
= hash_buf
->salt
;
14370 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14371 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14372 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14373 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14374 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14376 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14378 uint salt_len
= input_len
- 40 - 1;
14380 char *salt_buf
= input_buf
+ 40 + 1;
14382 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14384 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14386 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14388 salt
->salt_len
= salt_len
;
14390 return (PARSER_OK
);
14393 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14395 const u8 ascii_to_ebcdic
[] =
14397 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14398 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14399 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14400 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14401 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14402 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14403 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14404 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14405 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14406 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14407 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14408 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14409 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14410 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14411 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14412 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14415 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14417 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14419 u32
*digest
= (u32
*) hash_buf
->digest
;
14421 salt_t
*salt
= hash_buf
->salt
;
14423 char *salt_pos
= input_buf
+ 6 + 1;
14425 char *digest_pos
= strchr (salt_pos
, '*');
14427 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14429 uint salt_len
= digest_pos
- salt_pos
;
14431 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14433 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14435 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14439 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14440 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14442 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14444 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14446 salt
->salt_len
= salt_len
;
14448 for (uint i
= 0; i
< salt_len
; i
++)
14450 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14452 for (uint i
= salt_len
; i
< 8; i
++)
14454 salt_buf_pc_ptr
[i
] = 0x40;
14459 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14461 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14462 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14464 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14465 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14467 digest
[0] = byte_swap_32 (digest
[0]);
14468 digest
[1] = byte_swap_32 (digest
[1]);
14470 IP (digest
[0], digest
[1], tt
);
14472 digest
[0] = rotr32 (digest
[0], 29);
14473 digest
[1] = rotr32 (digest
[1], 29);
14477 return (PARSER_OK
);
14480 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14482 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14484 u32
*digest
= (u32
*) hash_buf
->digest
;
14486 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14487 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14488 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14489 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14491 digest
[0] = byte_swap_32 (digest
[0]);
14492 digest
[1] = byte_swap_32 (digest
[1]);
14493 digest
[2] = byte_swap_32 (digest
[2]);
14494 digest
[3] = byte_swap_32 (digest
[3]);
14496 return (PARSER_OK
);
14499 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14501 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14503 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14505 u32
*digest
= (u32
*) hash_buf
->digest
;
14507 salt_t
*salt
= hash_buf
->salt
;
14509 u8 tmp_buf
[120] = { 0 };
14511 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14513 tmp_buf
[3] += -4; // dont ask!
14515 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14517 salt
->salt_len
= 5;
14519 memcpy (digest
, tmp_buf
+ 5, 9);
14521 // yes, only 9 byte are needed to crack, but 10 to display
14523 salt
->salt_buf_pc
[7] = input_buf
[20];
14525 return (PARSER_OK
);
14528 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14530 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14532 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14534 u32
*digest
= (u32
*) hash_buf
->digest
;
14536 salt_t
*salt
= hash_buf
->salt
;
14538 u8 tmp_buf
[120] = { 0 };
14540 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14542 tmp_buf
[3] += -4; // dont ask!
14546 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14548 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)
14552 char tmp_iter_buf
[11] = { 0 };
14554 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14556 tmp_iter_buf
[10] = 0;
14558 salt
->salt_iter
= atoi (tmp_iter_buf
);
14560 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14562 return (PARSER_SALT_ITERATION
);
14565 salt
->salt_iter
--; // first round in init
14567 // 2 additional bytes for display only
14569 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14570 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14574 memcpy (digest
, tmp_buf
+ 28, 8);
14576 digest
[0] = byte_swap_32 (digest
[0]);
14577 digest
[1] = byte_swap_32 (digest
[1]);
14581 return (PARSER_OK
);
14584 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14586 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14588 u32
*digest
= (u32
*) hash_buf
->digest
;
14590 salt_t
*salt
= hash_buf
->salt
;
14592 char *salt_buf_pos
= input_buf
;
14594 char *hash_buf_pos
= salt_buf_pos
+ 6;
14596 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14597 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14598 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14599 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14600 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14601 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14602 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14603 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14605 digest
[0] -= SHA256M_A
;
14606 digest
[1] -= SHA256M_B
;
14607 digest
[2] -= SHA256M_C
;
14608 digest
[3] -= SHA256M_D
;
14609 digest
[4] -= SHA256M_E
;
14610 digest
[5] -= SHA256M_F
;
14611 digest
[6] -= SHA256M_G
;
14612 digest
[7] -= SHA256M_H
;
14614 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14616 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14618 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14620 salt
->salt_len
= salt_len
;
14622 return (PARSER_OK
);
14625 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14627 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14629 u32
*digest
= (u32
*) hash_buf
->digest
;
14631 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14633 salt_t
*salt
= hash_buf
->salt
;
14635 char *salt_buf
= input_buf
+ 6;
14637 char *digest_buf
= strchr (salt_buf
, '$');
14639 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14641 uint salt_len
= digest_buf
- salt_buf
;
14643 digest_buf
++; // skip the '$' symbol
14645 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14647 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14649 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14651 salt
->salt_len
= salt_len
;
14653 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14654 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14655 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14656 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14658 digest
[0] = byte_swap_32 (digest
[0]);
14659 digest
[1] = byte_swap_32 (digest
[1]);
14660 digest
[2] = byte_swap_32 (digest
[2]);
14661 digest
[3] = byte_swap_32 (digest
[3]);
14663 digest
[0] -= MD5M_A
;
14664 digest
[1] -= MD5M_B
;
14665 digest
[2] -= MD5M_C
;
14666 digest
[3] -= MD5M_D
;
14668 return (PARSER_OK
);
14671 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14673 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14675 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14677 u32
*digest
= (u32
*) hash_buf
->digest
;
14679 salt_t
*salt
= hash_buf
->salt
;
14681 char *salt_buf
= input_buf
+ 3;
14683 char *digest_buf
= strchr (salt_buf
, '$');
14685 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14687 uint salt_len
= digest_buf
- salt_buf
;
14689 digest_buf
++; // skip the '$' symbol
14691 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14693 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14695 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14697 salt_buf_ptr
[salt_len
] = 0x2d;
14699 salt
->salt_len
= salt_len
+ 1;
14701 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14702 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14703 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14704 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14706 digest
[0] = byte_swap_32 (digest
[0]);
14707 digest
[1] = byte_swap_32 (digest
[1]);
14708 digest
[2] = byte_swap_32 (digest
[2]);
14709 digest
[3] = byte_swap_32 (digest
[3]);
14711 digest
[0] -= MD5M_A
;
14712 digest
[1] -= MD5M_B
;
14713 digest
[2] -= MD5M_C
;
14714 digest
[3] -= MD5M_D
;
14716 return (PARSER_OK
);
14719 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14721 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14723 u32
*digest
= (u32
*) hash_buf
->digest
;
14725 salt_t
*salt
= hash_buf
->salt
;
14727 u8 tmp_buf
[100] = { 0 };
14729 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14731 memcpy (digest
, tmp_buf
, 20);
14733 digest
[0] = byte_swap_32 (digest
[0]);
14734 digest
[1] = byte_swap_32 (digest
[1]);
14735 digest
[2] = byte_swap_32 (digest
[2]);
14736 digest
[3] = byte_swap_32 (digest
[3]);
14737 digest
[4] = byte_swap_32 (digest
[4]);
14739 digest
[0] -= SHA1M_A
;
14740 digest
[1] -= SHA1M_B
;
14741 digest
[2] -= SHA1M_C
;
14742 digest
[3] -= SHA1M_D
;
14743 digest
[4] -= SHA1M_E
;
14745 salt
->salt_buf
[0] = 0x80;
14747 salt
->salt_len
= 0;
14749 return (PARSER_OK
);
14752 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14754 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14756 u32
*digest
= (u32
*) hash_buf
->digest
;
14758 salt_t
*salt
= hash_buf
->salt
;
14760 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14761 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14762 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14763 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14765 digest
[0] = byte_swap_32 (digest
[0]);
14766 digest
[1] = byte_swap_32 (digest
[1]);
14767 digest
[2] = byte_swap_32 (digest
[2]);
14768 digest
[3] = byte_swap_32 (digest
[3]);
14770 digest
[0] -= MD5M_A
;
14771 digest
[1] -= MD5M_B
;
14772 digest
[2] -= MD5M_C
;
14773 digest
[3] -= MD5M_D
;
14775 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14777 uint salt_len
= input_len
- 32 - 1;
14779 char *salt_buf
= input_buf
+ 32 + 1;
14781 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14783 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14785 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14788 * add static "salt" part
14791 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14795 salt
->salt_len
= salt_len
;
14797 return (PARSER_OK
);
14800 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14802 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14804 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14806 u32
*digest
= (u32
*) hash_buf
->digest
;
14808 salt_t
*salt
= hash_buf
->salt
;
14810 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14816 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14818 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14820 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14822 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14824 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14828 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14830 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14832 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14834 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14838 char *keybuf_pos
= strchr (keylen_pos
, '$');
14840 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14842 uint keylen_len
= keybuf_pos
- keylen_pos
;
14844 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14848 char *databuf_pos
= strchr (keybuf_pos
, '$');
14850 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14852 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14854 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14858 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14860 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14866 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14867 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14868 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14869 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14871 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14872 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14873 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14874 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14876 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14877 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14878 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14879 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14881 salt
->salt_len
= 16;
14882 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14884 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14886 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14889 return (PARSER_OK
);
14892 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14894 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14896 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14898 u32
*digest
= (u32
*) hash_buf
->digest
;
14900 salt_t
*salt
= hash_buf
->salt
;
14906 // first is the N salt parameter
14908 char *N_pos
= input_buf
+ 6;
14910 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14914 salt
->scrypt_N
= atoi (N_pos
);
14918 char *r_pos
= strchr (N_pos
, ':');
14920 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14924 salt
->scrypt_r
= atoi (r_pos
);
14928 char *p_pos
= strchr (r_pos
, ':');
14930 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14934 salt
->scrypt_p
= atoi (p_pos
);
14938 char *saltbuf_pos
= strchr (p_pos
, ':');
14940 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14944 char *hash_pos
= strchr (saltbuf_pos
, ':');
14946 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14952 int salt_len_base64
= hash_pos
- saltbuf_pos
;
14954 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
14956 u8 tmp_buf
[33] = { 0 };
14958 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
14960 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14962 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14964 salt
->salt_len
= tmp_len
;
14965 salt
->salt_iter
= 1;
14967 // digest - base64 decode
14969 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14971 tmp_len
= input_len
- (hash_pos
- input_buf
);
14973 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14975 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14977 memcpy (digest
, tmp_buf
, 32);
14979 return (PARSER_OK
);
14982 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14984 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14986 u32
*digest
= (u32
*) hash_buf
->digest
;
14988 salt_t
*salt
= hash_buf
->salt
;
14994 char decrypted
[76] = { 0 }; // iv + hash
14996 juniper_decrypt_hash (input_buf
, decrypted
);
14998 char *md5crypt_hash
= decrypted
+ 12;
15000 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15002 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15004 char *salt_pos
= md5crypt_hash
+ 3;
15006 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15008 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15010 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15014 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15016 return (PARSER_OK
);
15019 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15021 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15023 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15025 u32
*digest
= (u32
*) hash_buf
->digest
;
15027 salt_t
*salt
= hash_buf
->salt
;
15029 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15035 // first is *raw* salt
15037 char *salt_pos
= input_buf
+ 3;
15039 char *hash_pos
= strchr (salt_pos
, '$');
15041 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15043 uint salt_len
= hash_pos
- salt_pos
;
15045 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15049 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15051 memcpy (salt_buf_ptr
, salt_pos
, 14);
15053 salt_buf_ptr
[17] = 0x01;
15054 salt_buf_ptr
[18] = 0x80;
15056 // add some stuff to normal salt to make sorted happy
15058 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15059 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15060 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15061 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15063 salt
->salt_len
= salt_len
;
15064 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15066 // base64 decode hash
15068 u8 tmp_buf
[100] = { 0 };
15070 uint hash_len
= input_len
- 3 - salt_len
- 1;
15072 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15074 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15076 memcpy (digest
, tmp_buf
, 32);
15078 digest
[0] = byte_swap_32 (digest
[0]);
15079 digest
[1] = byte_swap_32 (digest
[1]);
15080 digest
[2] = byte_swap_32 (digest
[2]);
15081 digest
[3] = byte_swap_32 (digest
[3]);
15082 digest
[4] = byte_swap_32 (digest
[4]);
15083 digest
[5] = byte_swap_32 (digest
[5]);
15084 digest
[6] = byte_swap_32 (digest
[6]);
15085 digest
[7] = byte_swap_32 (digest
[7]);
15087 return (PARSER_OK
);
15090 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15092 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15094 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15096 u32
*digest
= (u32
*) hash_buf
->digest
;
15098 salt_t
*salt
= hash_buf
->salt
;
15104 // first is *raw* salt
15106 char *salt_pos
= input_buf
+ 3;
15108 char *hash_pos
= strchr (salt_pos
, '$');
15110 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15112 uint salt_len
= hash_pos
- salt_pos
;
15114 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15116 salt
->salt_len
= salt_len
;
15119 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15121 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15122 salt_buf_ptr
[salt_len
] = 0;
15124 // base64 decode hash
15126 u8 tmp_buf
[100] = { 0 };
15128 uint hash_len
= input_len
- 3 - salt_len
- 1;
15130 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15132 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15134 memcpy (digest
, tmp_buf
, 32);
15137 salt
->scrypt_N
= 16384;
15138 salt
->scrypt_r
= 1;
15139 salt
->scrypt_p
= 1;
15140 salt
->salt_iter
= 1;
15142 return (PARSER_OK
);
15145 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15147 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15149 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15151 u32
*digest
= (u32
*) hash_buf
->digest
;
15153 salt_t
*salt
= hash_buf
->salt
;
15155 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15161 char *version_pos
= input_buf
+ 8 + 1;
15163 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15165 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15167 u32 version_len
= verifierHashSize_pos
- version_pos
;
15169 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15171 verifierHashSize_pos
++;
15173 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15175 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15177 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15179 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15183 char *saltSize_pos
= strchr (keySize_pos
, '*');
15185 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15187 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15189 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15193 char *osalt_pos
= strchr (saltSize_pos
, '*');
15195 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15197 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15199 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15203 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15205 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15207 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15209 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15211 encryptedVerifier_pos
++;
15213 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15215 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15217 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15219 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15221 encryptedVerifierHash_pos
++;
15223 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;
15225 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15227 const uint version
= atoi (version_pos
);
15229 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15231 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15233 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15235 const uint keySize
= atoi (keySize_pos
);
15237 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15239 office2007
->keySize
= keySize
;
15241 const uint saltSize
= atoi (saltSize_pos
);
15243 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15249 salt
->salt_len
= 16;
15250 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15252 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15253 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15254 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15255 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15261 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15262 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15263 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15264 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15266 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15267 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15268 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15269 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15270 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15276 digest
[0] = office2007
->encryptedVerifierHash
[0];
15277 digest
[1] = office2007
->encryptedVerifierHash
[1];
15278 digest
[2] = office2007
->encryptedVerifierHash
[2];
15279 digest
[3] = office2007
->encryptedVerifierHash
[3];
15281 return (PARSER_OK
);
15284 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15286 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15288 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15290 u32
*digest
= (u32
*) hash_buf
->digest
;
15292 salt_t
*salt
= hash_buf
->salt
;
15294 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15300 char *version_pos
= input_buf
+ 8 + 1;
15302 char *spinCount_pos
= strchr (version_pos
, '*');
15304 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15306 u32 version_len
= spinCount_pos
- version_pos
;
15308 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15312 char *keySize_pos
= strchr (spinCount_pos
, '*');
15314 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15316 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15318 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15322 char *saltSize_pos
= strchr (keySize_pos
, '*');
15324 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15326 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15328 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15332 char *osalt_pos
= strchr (saltSize_pos
, '*');
15334 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15336 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15338 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15342 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15344 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15346 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15348 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15350 encryptedVerifier_pos
++;
15352 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15354 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15356 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15358 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15360 encryptedVerifierHash_pos
++;
15362 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;
15364 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15366 const uint version
= atoi (version_pos
);
15368 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15370 const uint spinCount
= atoi (spinCount_pos
);
15372 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15374 const uint keySize
= atoi (keySize_pos
);
15376 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15378 const uint saltSize
= atoi (saltSize_pos
);
15380 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15386 salt
->salt_len
= 16;
15387 salt
->salt_iter
= spinCount
;
15389 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15390 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15391 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15392 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15398 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15399 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15400 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15401 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15403 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15404 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15405 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15406 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15407 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15408 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15409 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15410 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15416 digest
[0] = office2010
->encryptedVerifierHash
[0];
15417 digest
[1] = office2010
->encryptedVerifierHash
[1];
15418 digest
[2] = office2010
->encryptedVerifierHash
[2];
15419 digest
[3] = office2010
->encryptedVerifierHash
[3];
15421 return (PARSER_OK
);
15424 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15426 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15428 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15430 u32
*digest
= (u32
*) hash_buf
->digest
;
15432 salt_t
*salt
= hash_buf
->salt
;
15434 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15440 char *version_pos
= input_buf
+ 8 + 1;
15442 char *spinCount_pos
= strchr (version_pos
, '*');
15444 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15446 u32 version_len
= spinCount_pos
- version_pos
;
15448 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15452 char *keySize_pos
= strchr (spinCount_pos
, '*');
15454 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15456 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15458 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15462 char *saltSize_pos
= strchr (keySize_pos
, '*');
15464 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15466 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15468 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15472 char *osalt_pos
= strchr (saltSize_pos
, '*');
15474 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15476 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15478 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15482 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15484 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15486 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15488 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15490 encryptedVerifier_pos
++;
15492 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15494 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15496 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15498 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15500 encryptedVerifierHash_pos
++;
15502 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;
15504 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15506 const uint version
= atoi (version_pos
);
15508 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15510 const uint spinCount
= atoi (spinCount_pos
);
15512 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15514 const uint keySize
= atoi (keySize_pos
);
15516 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15518 const uint saltSize
= atoi (saltSize_pos
);
15520 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15526 salt
->salt_len
= 16;
15527 salt
->salt_iter
= spinCount
;
15529 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15530 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15531 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15532 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15538 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15539 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15540 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15541 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15543 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15544 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15545 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15546 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15547 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15548 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15549 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15550 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15556 digest
[0] = office2013
->encryptedVerifierHash
[0];
15557 digest
[1] = office2013
->encryptedVerifierHash
[1];
15558 digest
[2] = office2013
->encryptedVerifierHash
[2];
15559 digest
[3] = office2013
->encryptedVerifierHash
[3];
15561 return (PARSER_OK
);
15564 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15566 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15568 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15570 u32
*digest
= (u32
*) hash_buf
->digest
;
15572 salt_t
*salt
= hash_buf
->salt
;
15574 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15580 char *version_pos
= input_buf
+ 11;
15582 char *osalt_pos
= strchr (version_pos
, '*');
15584 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15586 u32 version_len
= osalt_pos
- version_pos
;
15588 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15592 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15594 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15596 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15598 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15600 encryptedVerifier_pos
++;
15602 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15604 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15606 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15608 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15610 encryptedVerifierHash_pos
++;
15612 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15614 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15616 const uint version
= *version_pos
- 0x30;
15618 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15624 oldoffice01
->version
= version
;
15626 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15627 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15628 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15629 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15631 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15632 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15633 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15634 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15636 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15637 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15638 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15639 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15641 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15642 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15643 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15644 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15650 salt
->salt_len
= 16;
15652 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15653 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15654 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15655 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15657 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15658 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15659 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15660 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15662 // this is a workaround as office produces multiple documents with the same salt
15664 salt
->salt_len
+= 32;
15666 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15667 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15668 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15669 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15670 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15671 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15672 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15673 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15679 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15680 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15681 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15682 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15684 return (PARSER_OK
);
15687 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15689 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15692 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15694 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15696 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15698 u32
*digest
= (u32
*) hash_buf
->digest
;
15700 salt_t
*salt
= hash_buf
->salt
;
15702 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15708 char *version_pos
= input_buf
+ 11;
15710 char *osalt_pos
= strchr (version_pos
, '*');
15712 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15714 u32 version_len
= osalt_pos
- version_pos
;
15716 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15720 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15722 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15724 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15726 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15728 encryptedVerifier_pos
++;
15730 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15732 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15734 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15736 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15738 encryptedVerifierHash_pos
++;
15740 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15742 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15744 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15746 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15750 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15752 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15754 const uint version
= *version_pos
- 0x30;
15756 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15762 oldoffice01
->version
= version
;
15764 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15765 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15766 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15767 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15769 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15770 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15771 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15772 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15774 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15775 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15776 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15777 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15779 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15780 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15781 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15782 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15784 oldoffice01
->rc4key
[1] = 0;
15785 oldoffice01
->rc4key
[0] = 0;
15787 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15788 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15789 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15790 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15791 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15792 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15793 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15794 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15795 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15796 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15798 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15799 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15805 salt
->salt_len
= 16;
15807 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15808 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15809 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15810 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15812 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15813 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15814 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15815 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15817 // this is a workaround as office produces multiple documents with the same salt
15819 salt
->salt_len
+= 32;
15821 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15822 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15823 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15824 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15825 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15826 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15827 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15828 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15834 digest
[0] = oldoffice01
->rc4key
[0];
15835 digest
[1] = oldoffice01
->rc4key
[1];
15839 return (PARSER_OK
);
15842 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15844 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15846 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15848 u32
*digest
= (u32
*) hash_buf
->digest
;
15850 salt_t
*salt
= hash_buf
->salt
;
15852 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15858 char *version_pos
= input_buf
+ 11;
15860 char *osalt_pos
= strchr (version_pos
, '*');
15862 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15864 u32 version_len
= osalt_pos
- version_pos
;
15866 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15870 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15872 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15874 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15876 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15878 encryptedVerifier_pos
++;
15880 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15882 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15884 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15886 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15888 encryptedVerifierHash_pos
++;
15890 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15892 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15894 const uint version
= *version_pos
- 0x30;
15896 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15902 oldoffice34
->version
= version
;
15904 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15905 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15906 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15907 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15909 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15910 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15911 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15912 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15914 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15915 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15916 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15917 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15918 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15920 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15921 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15922 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15923 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15924 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15930 salt
->salt_len
= 16;
15932 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15933 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15934 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15935 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15937 // this is a workaround as office produces multiple documents with the same salt
15939 salt
->salt_len
+= 32;
15941 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15942 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15943 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15944 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15945 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15946 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15947 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15948 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15954 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15955 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15956 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15957 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15959 return (PARSER_OK
);
15962 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15964 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15966 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15969 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15971 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15973 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15975 u32
*digest
= (u32
*) hash_buf
->digest
;
15977 salt_t
*salt
= hash_buf
->salt
;
15979 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15985 char *version_pos
= input_buf
+ 11;
15987 char *osalt_pos
= strchr (version_pos
, '*');
15989 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15991 u32 version_len
= osalt_pos
- version_pos
;
15993 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15997 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15999 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16001 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16003 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16005 encryptedVerifier_pos
++;
16007 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16009 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16011 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16013 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16015 encryptedVerifierHash_pos
++;
16017 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16019 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16021 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16023 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16027 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16029 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16031 const uint version
= *version_pos
- 0x30;
16033 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16039 oldoffice34
->version
= version
;
16041 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16042 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16043 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16044 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16046 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16047 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16048 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16049 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16051 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16052 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16053 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16054 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16055 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16057 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16058 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16059 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16060 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16061 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16063 oldoffice34
->rc4key
[1] = 0;
16064 oldoffice34
->rc4key
[0] = 0;
16066 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16067 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16068 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16069 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16070 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16071 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16072 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16073 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16074 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16075 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16077 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16078 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16084 salt
->salt_len
= 16;
16086 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16087 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16088 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16089 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16091 // this is a workaround as office produces multiple documents with the same salt
16093 salt
->salt_len
+= 32;
16095 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16096 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16097 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16098 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16099 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16100 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16101 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16102 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16108 digest
[0] = oldoffice34
->rc4key
[0];
16109 digest
[1] = oldoffice34
->rc4key
[1];
16113 return (PARSER_OK
);
16116 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16118 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16120 u32
*digest
= (u32
*) hash_buf
->digest
;
16122 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16123 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16124 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16125 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16127 digest
[0] = byte_swap_32 (digest
[0]);
16128 digest
[1] = byte_swap_32 (digest
[1]);
16129 digest
[2] = byte_swap_32 (digest
[2]);
16130 digest
[3] = byte_swap_32 (digest
[3]);
16132 return (PARSER_OK
);
16135 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16137 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16139 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16141 u32
*digest
= (u32
*) hash_buf
->digest
;
16143 salt_t
*salt
= hash_buf
->salt
;
16145 char *signature_pos
= input_buf
;
16147 char *salt_pos
= strchr (signature_pos
, '$');
16149 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16151 u32 signature_len
= salt_pos
- signature_pos
;
16153 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16157 char *hash_pos
= strchr (salt_pos
, '$');
16159 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16161 u32 salt_len
= hash_pos
- salt_pos
;
16163 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16167 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16169 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16171 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16172 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16173 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16174 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16175 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16177 digest
[0] -= SHA1M_A
;
16178 digest
[1] -= SHA1M_B
;
16179 digest
[2] -= SHA1M_C
;
16180 digest
[3] -= SHA1M_D
;
16181 digest
[4] -= SHA1M_E
;
16183 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16185 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16187 salt
->salt_len
= salt_len
;
16189 return (PARSER_OK
);
16192 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16194 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16196 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16198 u32
*digest
= (u32
*) hash_buf
->digest
;
16200 salt_t
*salt
= hash_buf
->salt
;
16202 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16208 char *iter_pos
= input_buf
+ 14;
16210 const int iter
= atoi (iter_pos
);
16212 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16214 salt
->salt_iter
= iter
- 1;
16216 char *salt_pos
= strchr (iter_pos
, '$');
16218 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16222 char *hash_pos
= strchr (salt_pos
, '$');
16224 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16226 const uint salt_len
= hash_pos
- salt_pos
;
16230 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16232 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16234 salt
->salt_len
= salt_len
;
16236 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16237 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16239 // add some stuff to normal salt to make sorted happy
16241 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16242 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16243 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16244 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16245 salt
->salt_buf
[4] = salt
->salt_iter
;
16247 // base64 decode hash
16249 u8 tmp_buf
[100] = { 0 };
16251 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16253 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16255 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16257 memcpy (digest
, tmp_buf
, 32);
16259 digest
[0] = byte_swap_32 (digest
[0]);
16260 digest
[1] = byte_swap_32 (digest
[1]);
16261 digest
[2] = byte_swap_32 (digest
[2]);
16262 digest
[3] = byte_swap_32 (digest
[3]);
16263 digest
[4] = byte_swap_32 (digest
[4]);
16264 digest
[5] = byte_swap_32 (digest
[5]);
16265 digest
[6] = byte_swap_32 (digest
[6]);
16266 digest
[7] = byte_swap_32 (digest
[7]);
16268 return (PARSER_OK
);
16271 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16273 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16275 u32
*digest
= (u32
*) hash_buf
->digest
;
16277 salt_t
*salt
= hash_buf
->salt
;
16279 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16280 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16284 digest
[0] = byte_swap_32 (digest
[0]);
16285 digest
[1] = byte_swap_32 (digest
[1]);
16287 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16288 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16289 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16291 char iter_c
= input_buf
[17];
16292 char iter_d
= input_buf
[19];
16294 // atm only defaults, let's see if there's more request
16295 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16296 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16298 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16300 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16301 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16302 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16303 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16305 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16306 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16307 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16308 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16310 salt
->salt_len
= 16;
16312 return (PARSER_OK
);
16315 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16317 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16319 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16321 u32
*digest
= (u32
*) hash_buf
->digest
;
16323 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16325 salt_t
*salt
= hash_buf
->salt
;
16327 char *salt_pos
= input_buf
+ 10;
16329 char *hash_pos
= strchr (salt_pos
, '$');
16331 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16333 uint salt_len
= hash_pos
- salt_pos
;
16337 uint hash_len
= input_len
- 10 - salt_len
- 1;
16339 // base64 decode salt
16341 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16343 u8 tmp_buf
[100] = { 0 };
16345 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16347 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16349 tmp_buf
[salt_len
] = 0x80;
16351 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16353 salt
->salt_len
= salt_len
;
16355 // base64 decode hash
16357 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16359 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16361 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16363 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16365 uint user_len
= hash_len
- 32;
16367 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16369 user_len
--; // skip the trailing space
16371 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16372 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16373 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16374 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16376 digest
[0] = byte_swap_32 (digest
[0]);
16377 digest
[1] = byte_swap_32 (digest
[1]);
16378 digest
[2] = byte_swap_32 (digest
[2]);
16379 digest
[3] = byte_swap_32 (digest
[3]);
16381 // store username for host only (output hash if cracked)
16383 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16384 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16386 return (PARSER_OK
);
16389 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16391 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16393 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16395 u32
*digest
= (u32
*) hash_buf
->digest
;
16397 salt_t
*salt
= hash_buf
->salt
;
16399 char *iter_pos
= input_buf
+ 10;
16401 u32 iter
= atoi (iter_pos
);
16405 return (PARSER_SALT_ITERATION
);
16408 iter
--; // first iteration is special
16410 salt
->salt_iter
= iter
;
16412 char *base64_pos
= strchr (iter_pos
, '}');
16414 if (base64_pos
== NULL
)
16416 return (PARSER_SIGNATURE_UNMATCHED
);
16421 // base64 decode salt
16423 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16425 u8 tmp_buf
[100] = { 0 };
16427 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16429 if (decoded_len
< 24)
16431 return (PARSER_SALT_LENGTH
);
16436 uint salt_len
= decoded_len
- 20;
16438 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16439 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16441 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16443 salt
->salt_len
= salt_len
;
16447 u32
*digest_ptr
= (u32
*) tmp_buf
;
16449 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16450 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16451 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16452 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16453 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16455 return (PARSER_OK
);
16458 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16460 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16462 u32
*digest
= (u32
*) hash_buf
->digest
;
16464 salt_t
*salt
= hash_buf
->salt
;
16466 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16467 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16468 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16469 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16470 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16472 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16474 uint salt_len
= input_len
- 40 - 1;
16476 char *salt_buf
= input_buf
+ 40 + 1;
16478 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16480 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16482 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16484 salt
->salt_len
= salt_len
;
16486 return (PARSER_OK
);
16489 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16491 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16493 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16495 u32
*digest
= (u32
*) hash_buf
->digest
;
16497 salt_t
*salt
= hash_buf
->salt
;
16499 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16505 char *V_pos
= input_buf
+ 5;
16507 char *R_pos
= strchr (V_pos
, '*');
16509 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16511 u32 V_len
= R_pos
- V_pos
;
16515 char *bits_pos
= strchr (R_pos
, '*');
16517 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16519 u32 R_len
= bits_pos
- R_pos
;
16523 char *P_pos
= strchr (bits_pos
, '*');
16525 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16527 u32 bits_len
= P_pos
- bits_pos
;
16531 char *enc_md_pos
= strchr (P_pos
, '*');
16533 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16535 u32 P_len
= enc_md_pos
- P_pos
;
16539 char *id_len_pos
= strchr (enc_md_pos
, '*');
16541 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16543 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16547 char *id_buf_pos
= strchr (id_len_pos
, '*');
16549 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16551 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16555 char *u_len_pos
= strchr (id_buf_pos
, '*');
16557 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16559 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16561 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16565 char *u_buf_pos
= strchr (u_len_pos
, '*');
16567 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16569 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16573 char *o_len_pos
= strchr (u_buf_pos
, '*');
16575 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16577 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16579 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16583 char *o_buf_pos
= strchr (o_len_pos
, '*');
16585 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16587 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16591 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;
16593 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16597 const int V
= atoi (V_pos
);
16598 const int R
= atoi (R_pos
);
16599 const int P
= atoi (P_pos
);
16601 if (V
!= 1) return (PARSER_SALT_VALUE
);
16602 if (R
!= 2) return (PARSER_SALT_VALUE
);
16604 const int enc_md
= atoi (enc_md_pos
);
16606 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16608 const int id_len
= atoi (id_len_pos
);
16609 const int u_len
= atoi (u_len_pos
);
16610 const int o_len
= atoi (o_len_pos
);
16612 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16613 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16614 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16616 const int bits
= atoi (bits_pos
);
16618 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16620 // copy data to esalt
16626 pdf
->enc_md
= enc_md
;
16628 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16629 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16630 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16631 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16632 pdf
->id_len
= id_len
;
16634 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16635 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16636 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16637 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16638 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16639 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16640 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16641 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16642 pdf
->u_len
= u_len
;
16644 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16645 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16646 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16647 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16648 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16649 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16650 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16651 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16652 pdf
->o_len
= o_len
;
16654 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16655 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16656 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16657 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16659 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16660 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16661 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16662 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16663 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16664 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16665 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16666 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16668 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16669 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16670 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16671 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16672 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16673 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16674 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16675 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16677 // we use ID for salt, maybe needs to change, we will see...
16679 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16680 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16681 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16682 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16683 salt
->salt_len
= pdf
->id_len
;
16685 digest
[0] = pdf
->u_buf
[0];
16686 digest
[1] = pdf
->u_buf
[1];
16687 digest
[2] = pdf
->u_buf
[2];
16688 digest
[3] = pdf
->u_buf
[3];
16690 return (PARSER_OK
);
16693 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16695 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16698 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16700 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16702 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16704 u32
*digest
= (u32
*) hash_buf
->digest
;
16706 salt_t
*salt
= hash_buf
->salt
;
16708 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16714 char *V_pos
= input_buf
+ 5;
16716 char *R_pos
= strchr (V_pos
, '*');
16718 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16720 u32 V_len
= R_pos
- V_pos
;
16724 char *bits_pos
= strchr (R_pos
, '*');
16726 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16728 u32 R_len
= bits_pos
- R_pos
;
16732 char *P_pos
= strchr (bits_pos
, '*');
16734 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16736 u32 bits_len
= P_pos
- bits_pos
;
16740 char *enc_md_pos
= strchr (P_pos
, '*');
16742 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16744 u32 P_len
= enc_md_pos
- P_pos
;
16748 char *id_len_pos
= strchr (enc_md_pos
, '*');
16750 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16752 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16756 char *id_buf_pos
= strchr (id_len_pos
, '*');
16758 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16760 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16764 char *u_len_pos
= strchr (id_buf_pos
, '*');
16766 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16768 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16770 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16774 char *u_buf_pos
= strchr (u_len_pos
, '*');
16776 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16778 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16782 char *o_len_pos
= strchr (u_buf_pos
, '*');
16784 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16786 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16788 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16792 char *o_buf_pos
= strchr (o_len_pos
, '*');
16794 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16796 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16800 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16802 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16804 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16806 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16810 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;
16812 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16816 const int V
= atoi (V_pos
);
16817 const int R
= atoi (R_pos
);
16818 const int P
= atoi (P_pos
);
16820 if (V
!= 1) return (PARSER_SALT_VALUE
);
16821 if (R
!= 2) return (PARSER_SALT_VALUE
);
16823 const int enc_md
= atoi (enc_md_pos
);
16825 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16827 const int id_len
= atoi (id_len_pos
);
16828 const int u_len
= atoi (u_len_pos
);
16829 const int o_len
= atoi (o_len_pos
);
16831 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16832 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16833 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16835 const int bits
= atoi (bits_pos
);
16837 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16839 // copy data to esalt
16845 pdf
->enc_md
= enc_md
;
16847 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16848 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16849 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16850 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16851 pdf
->id_len
= id_len
;
16853 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16854 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16855 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16856 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16857 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16858 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16859 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16860 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16861 pdf
->u_len
= u_len
;
16863 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16864 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16865 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16866 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16867 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16868 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16869 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16870 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16871 pdf
->o_len
= o_len
;
16873 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16874 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16875 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16876 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16878 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16879 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16880 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16881 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16882 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16883 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16884 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16885 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16887 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16888 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16889 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16890 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16891 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16892 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16893 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16894 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16896 pdf
->rc4key
[1] = 0;
16897 pdf
->rc4key
[0] = 0;
16899 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16900 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16901 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16902 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16903 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16904 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16905 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16906 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16907 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16908 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16910 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16911 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16913 // we use ID for salt, maybe needs to change, we will see...
16915 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16916 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16917 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16918 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16919 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16920 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16921 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16922 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16923 salt
->salt_len
= pdf
->id_len
+ 16;
16925 digest
[0] = pdf
->rc4key
[0];
16926 digest
[1] = pdf
->rc4key
[1];
16930 return (PARSER_OK
);
16933 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16935 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16937 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16939 u32
*digest
= (u32
*) hash_buf
->digest
;
16941 salt_t
*salt
= hash_buf
->salt
;
16943 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16949 char *V_pos
= input_buf
+ 5;
16951 char *R_pos
= strchr (V_pos
, '*');
16953 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16955 u32 V_len
= R_pos
- V_pos
;
16959 char *bits_pos
= strchr (R_pos
, '*');
16961 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16963 u32 R_len
= bits_pos
- R_pos
;
16967 char *P_pos
= strchr (bits_pos
, '*');
16969 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16971 u32 bits_len
= P_pos
- bits_pos
;
16975 char *enc_md_pos
= strchr (P_pos
, '*');
16977 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16979 u32 P_len
= enc_md_pos
- P_pos
;
16983 char *id_len_pos
= strchr (enc_md_pos
, '*');
16985 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16987 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16991 char *id_buf_pos
= strchr (id_len_pos
, '*');
16993 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16995 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16999 char *u_len_pos
= strchr (id_buf_pos
, '*');
17001 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17003 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17005 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17009 char *u_buf_pos
= strchr (u_len_pos
, '*');
17011 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17013 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17017 char *o_len_pos
= strchr (u_buf_pos
, '*');
17019 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17021 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17023 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17027 char *o_buf_pos
= strchr (o_len_pos
, '*');
17029 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17031 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17035 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;
17037 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17041 const int V
= atoi (V_pos
);
17042 const int R
= atoi (R_pos
);
17043 const int P
= atoi (P_pos
);
17047 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17048 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17050 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17052 const int id_len
= atoi (id_len_pos
);
17053 const int u_len
= atoi (u_len_pos
);
17054 const int o_len
= atoi (o_len_pos
);
17056 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17058 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17059 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17061 const int bits
= atoi (bits_pos
);
17063 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17069 enc_md
= atoi (enc_md_pos
);
17072 // copy data to esalt
17078 pdf
->enc_md
= enc_md
;
17080 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17081 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17082 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17083 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17087 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17088 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17089 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17090 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17093 pdf
->id_len
= id_len
;
17095 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17096 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17097 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17098 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17099 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17100 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17101 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17102 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17103 pdf
->u_len
= u_len
;
17105 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17106 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17107 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17108 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17109 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17110 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17111 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17112 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17113 pdf
->o_len
= o_len
;
17115 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17116 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17117 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17118 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17122 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17123 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17124 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17125 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17128 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17129 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17130 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17131 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17132 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17133 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17134 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17135 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17137 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17138 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17139 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17140 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17141 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17142 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17143 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17144 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17146 // precompute rc4 data for later use
17162 uint salt_pc_block
[32] = { 0 };
17164 char *salt_pc_ptr
= (char *) salt_pc_block
;
17166 memcpy (salt_pc_ptr
, padding
, 32);
17167 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17169 uint salt_pc_digest
[4] = { 0 };
17171 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17173 pdf
->rc4data
[0] = salt_pc_digest
[0];
17174 pdf
->rc4data
[1] = salt_pc_digest
[1];
17176 // we use ID for salt, maybe needs to change, we will see...
17178 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17179 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17180 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17181 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17182 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17183 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17184 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17185 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17186 salt
->salt_len
= pdf
->id_len
+ 16;
17188 salt
->salt_iter
= ROUNDS_PDF14
;
17190 digest
[0] = pdf
->u_buf
[0];
17191 digest
[1] = pdf
->u_buf
[1];
17195 return (PARSER_OK
);
17198 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17200 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17202 if (ret
!= PARSER_OK
)
17207 u32
*digest
= (u32
*) hash_buf
->digest
;
17209 salt_t
*salt
= hash_buf
->salt
;
17211 digest
[0] -= SHA256M_A
;
17212 digest
[1] -= SHA256M_B
;
17213 digest
[2] -= SHA256M_C
;
17214 digest
[3] -= SHA256M_D
;
17215 digest
[4] -= SHA256M_E
;
17216 digest
[5] -= SHA256M_F
;
17217 digest
[6] -= SHA256M_G
;
17218 digest
[7] -= SHA256M_H
;
17220 salt
->salt_buf
[2] = 0x80;
17222 return (PARSER_OK
);
17225 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17227 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17229 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17231 u32
*digest
= (u32
*) hash_buf
->digest
;
17233 salt_t
*salt
= hash_buf
->salt
;
17235 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17241 char *V_pos
= input_buf
+ 5;
17243 char *R_pos
= strchr (V_pos
, '*');
17245 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17247 u32 V_len
= R_pos
- V_pos
;
17251 char *bits_pos
= strchr (R_pos
, '*');
17253 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17255 u32 R_len
= bits_pos
- R_pos
;
17259 char *P_pos
= strchr (bits_pos
, '*');
17261 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17263 u32 bits_len
= P_pos
- bits_pos
;
17267 char *enc_md_pos
= strchr (P_pos
, '*');
17269 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17271 u32 P_len
= enc_md_pos
- P_pos
;
17275 char *id_len_pos
= strchr (enc_md_pos
, '*');
17277 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17279 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17283 char *id_buf_pos
= strchr (id_len_pos
, '*');
17285 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17287 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17291 char *u_len_pos
= strchr (id_buf_pos
, '*');
17293 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17295 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17299 char *u_buf_pos
= strchr (u_len_pos
, '*');
17301 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17303 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17307 char *o_len_pos
= strchr (u_buf_pos
, '*');
17309 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17311 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17315 char *o_buf_pos
= strchr (o_len_pos
, '*');
17317 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17319 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17323 char *last
= strchr (o_buf_pos
, '*');
17325 if (last
== NULL
) last
= input_buf
+ input_len
;
17327 u32 o_buf_len
= last
- o_buf_pos
;
17331 const int V
= atoi (V_pos
);
17332 const int R
= atoi (R_pos
);
17336 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17337 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17339 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17341 const int bits
= atoi (bits_pos
);
17343 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17345 int enc_md
= atoi (enc_md_pos
);
17347 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17349 const uint id_len
= atoi (id_len_pos
);
17350 const uint u_len
= atoi (u_len_pos
);
17351 const uint o_len
= atoi (o_len_pos
);
17353 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17354 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17355 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17356 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17357 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17358 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17359 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17360 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17362 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17363 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17364 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17366 // copy data to esalt
17368 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17370 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17372 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17375 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17376 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17378 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17379 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17381 salt
->salt_len
= 8;
17382 salt
->salt_iter
= ROUNDS_PDF17L8
;
17384 digest
[0] = pdf
->u_buf
[0];
17385 digest
[1] = pdf
->u_buf
[1];
17386 digest
[2] = pdf
->u_buf
[2];
17387 digest
[3] = pdf
->u_buf
[3];
17388 digest
[4] = pdf
->u_buf
[4];
17389 digest
[5] = pdf
->u_buf
[5];
17390 digest
[6] = pdf
->u_buf
[6];
17391 digest
[7] = pdf
->u_buf
[7];
17393 return (PARSER_OK
);
17396 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17398 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17400 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17402 u32
*digest
= (u32
*) hash_buf
->digest
;
17404 salt_t
*salt
= hash_buf
->salt
;
17406 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17414 char *iter_pos
= input_buf
+ 7;
17416 u32 iter
= atoi (iter_pos
);
17418 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17419 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17421 // first is *raw* salt
17423 char *salt_pos
= strchr (iter_pos
, ':');
17425 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17429 char *hash_pos
= strchr (salt_pos
, ':');
17431 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17433 u32 salt_len
= hash_pos
- salt_pos
;
17435 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17439 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17441 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17445 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17447 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17449 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17451 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17452 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17454 salt
->salt_len
= salt_len
;
17455 salt
->salt_iter
= iter
- 1;
17459 u8 tmp_buf
[100] = { 0 };
17461 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17463 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17465 memcpy (digest
, tmp_buf
, 16);
17467 digest
[0] = byte_swap_32 (digest
[0]);
17468 digest
[1] = byte_swap_32 (digest
[1]);
17469 digest
[2] = byte_swap_32 (digest
[2]);
17470 digest
[3] = byte_swap_32 (digest
[3]);
17472 // add some stuff to normal salt to make sorted happy
17474 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17475 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17476 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17477 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17478 salt
->salt_buf
[4] = salt
->salt_iter
;
17480 return (PARSER_OK
);
17483 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17485 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17487 u32
*digest
= (u32
*) hash_buf
->digest
;
17489 salt_t
*salt
= hash_buf
->salt
;
17491 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17492 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17493 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17494 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17496 digest
[0] = byte_swap_32 (digest
[0]);
17497 digest
[1] = byte_swap_32 (digest
[1]);
17498 digest
[2] = byte_swap_32 (digest
[2]);
17499 digest
[3] = byte_swap_32 (digest
[3]);
17501 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17503 uint salt_len
= input_len
- 32 - 1;
17505 char *salt_buf
= input_buf
+ 32 + 1;
17507 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17509 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17511 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17513 salt
->salt_len
= salt_len
;
17515 return (PARSER_OK
);
17518 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17520 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17522 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17524 u32
*digest
= (u32
*) hash_buf
->digest
;
17526 salt_t
*salt
= hash_buf
->salt
;
17528 char *user_pos
= input_buf
+ 10;
17530 char *salt_pos
= strchr (user_pos
, '*');
17532 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17536 char *hash_pos
= strchr (salt_pos
, '*');
17540 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17542 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17544 uint user_len
= salt_pos
- user_pos
- 1;
17546 uint salt_len
= hash_pos
- salt_pos
- 1;
17548 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17554 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17555 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17556 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17557 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17559 digest
[0] = byte_swap_32 (digest
[0]);
17560 digest
[1] = byte_swap_32 (digest
[1]);
17561 digest
[2] = byte_swap_32 (digest
[2]);
17562 digest
[3] = byte_swap_32 (digest
[3]);
17564 digest
[0] -= MD5M_A
;
17565 digest
[1] -= MD5M_B
;
17566 digest
[2] -= MD5M_C
;
17567 digest
[3] -= MD5M_D
;
17573 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17575 // first 4 bytes are the "challenge"
17577 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17578 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17579 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17580 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17582 // append the user name
17584 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17586 salt
->salt_len
= 4 + user_len
;
17588 return (PARSER_OK
);
17591 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17593 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17595 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17597 u32
*digest
= (u32
*) hash_buf
->digest
;
17599 salt_t
*salt
= hash_buf
->salt
;
17601 char *salt_pos
= input_buf
+ 9;
17603 char *hash_pos
= strchr (salt_pos
, '*');
17605 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17609 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17611 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17613 uint salt_len
= hash_pos
- salt_pos
- 1;
17615 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17621 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17622 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17623 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17624 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17625 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17631 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17633 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17635 salt
->salt_len
= salt_len
;
17637 return (PARSER_OK
);
17640 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17642 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17644 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17646 u32
*digest
= (u32
*) hash_buf
->digest
;
17648 salt_t
*salt
= hash_buf
->salt
;
17650 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17656 char *cry_master_len_pos
= input_buf
+ 9;
17658 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17660 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17662 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17664 cry_master_buf_pos
++;
17666 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17668 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17670 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17672 cry_salt_len_pos
++;
17674 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17676 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17678 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17680 cry_salt_buf_pos
++;
17682 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17684 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17686 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17690 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17692 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17694 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17698 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17700 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17702 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17706 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17708 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17710 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17712 public_key_len_pos
++;
17714 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17716 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17718 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17720 public_key_buf_pos
++;
17722 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;
17724 const uint cry_master_len
= atoi (cry_master_len_pos
);
17725 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17726 const uint ckey_len
= atoi (ckey_len_pos
);
17727 const uint public_key_len
= atoi (public_key_len_pos
);
17729 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17730 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17731 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17732 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17734 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17736 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17738 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17741 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17743 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17745 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17748 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17750 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17752 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17755 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17756 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17757 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17760 * store digest (should be unique enought, hopefully)
17763 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17764 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17765 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17766 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17772 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17774 const uint cry_rounds
= atoi (cry_rounds_pos
);
17776 salt
->salt_iter
= cry_rounds
- 1;
17778 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17780 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17782 salt
->salt_len
= salt_len
;
17784 return (PARSER_OK
);
17787 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17789 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17791 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17793 u32
*digest
= (u32
*) hash_buf
->digest
;
17795 salt_t
*salt
= hash_buf
->salt
;
17797 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17799 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17801 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17803 memcpy (temp_input_buf
, input_buf
, input_len
);
17807 char *URI_server_pos
= temp_input_buf
+ 6;
17809 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17811 if (URI_client_pos
== NULL
)
17813 myfree (temp_input_buf
);
17815 return (PARSER_SEPARATOR_UNMATCHED
);
17818 URI_client_pos
[0] = 0;
17821 uint URI_server_len
= strlen (URI_server_pos
);
17823 if (URI_server_len
> 512)
17825 myfree (temp_input_buf
);
17827 return (PARSER_SALT_LENGTH
);
17832 char *user_pos
= strchr (URI_client_pos
, '*');
17834 if (user_pos
== NULL
)
17836 myfree (temp_input_buf
);
17838 return (PARSER_SEPARATOR_UNMATCHED
);
17844 uint URI_client_len
= strlen (URI_client_pos
);
17846 if (URI_client_len
> 512)
17848 myfree (temp_input_buf
);
17850 return (PARSER_SALT_LENGTH
);
17855 char *realm_pos
= strchr (user_pos
, '*');
17857 if (realm_pos
== NULL
)
17859 myfree (temp_input_buf
);
17861 return (PARSER_SEPARATOR_UNMATCHED
);
17867 uint user_len
= strlen (user_pos
);
17869 if (user_len
> 116)
17871 myfree (temp_input_buf
);
17873 return (PARSER_SALT_LENGTH
);
17878 char *method_pos
= strchr (realm_pos
, '*');
17880 if (method_pos
== NULL
)
17882 myfree (temp_input_buf
);
17884 return (PARSER_SEPARATOR_UNMATCHED
);
17890 uint realm_len
= strlen (realm_pos
);
17892 if (realm_len
> 116)
17894 myfree (temp_input_buf
);
17896 return (PARSER_SALT_LENGTH
);
17901 char *URI_prefix_pos
= strchr (method_pos
, '*');
17903 if (URI_prefix_pos
== NULL
)
17905 myfree (temp_input_buf
);
17907 return (PARSER_SEPARATOR_UNMATCHED
);
17910 URI_prefix_pos
[0] = 0;
17913 uint method_len
= strlen (method_pos
);
17915 if (method_len
> 246)
17917 myfree (temp_input_buf
);
17919 return (PARSER_SALT_LENGTH
);
17924 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17926 if (URI_resource_pos
== NULL
)
17928 myfree (temp_input_buf
);
17930 return (PARSER_SEPARATOR_UNMATCHED
);
17933 URI_resource_pos
[0] = 0;
17934 URI_resource_pos
++;
17936 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17938 if (URI_prefix_len
> 245)
17940 myfree (temp_input_buf
);
17942 return (PARSER_SALT_LENGTH
);
17947 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17949 if (URI_suffix_pos
== NULL
)
17951 myfree (temp_input_buf
);
17953 return (PARSER_SEPARATOR_UNMATCHED
);
17956 URI_suffix_pos
[0] = 0;
17959 uint URI_resource_len
= strlen (URI_resource_pos
);
17961 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17963 myfree (temp_input_buf
);
17965 return (PARSER_SALT_LENGTH
);
17970 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17972 if (nonce_pos
== NULL
)
17974 myfree (temp_input_buf
);
17976 return (PARSER_SEPARATOR_UNMATCHED
);
17982 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17984 if (URI_suffix_len
> 245)
17986 myfree (temp_input_buf
);
17988 return (PARSER_SALT_LENGTH
);
17993 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17995 if (nonce_client_pos
== NULL
)
17997 myfree (temp_input_buf
);
17999 return (PARSER_SEPARATOR_UNMATCHED
);
18002 nonce_client_pos
[0] = 0;
18003 nonce_client_pos
++;
18005 uint nonce_len
= strlen (nonce_pos
);
18007 if (nonce_len
< 1 || nonce_len
> 50)
18009 myfree (temp_input_buf
);
18011 return (PARSER_SALT_LENGTH
);
18016 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18018 if (nonce_count_pos
== NULL
)
18020 myfree (temp_input_buf
);
18022 return (PARSER_SEPARATOR_UNMATCHED
);
18025 nonce_count_pos
[0] = 0;
18028 uint nonce_client_len
= strlen (nonce_client_pos
);
18030 if (nonce_client_len
> 50)
18032 myfree (temp_input_buf
);
18034 return (PARSER_SALT_LENGTH
);
18039 char *qop_pos
= strchr (nonce_count_pos
, '*');
18041 if (qop_pos
== NULL
)
18043 myfree (temp_input_buf
);
18045 return (PARSER_SEPARATOR_UNMATCHED
);
18051 uint nonce_count_len
= strlen (nonce_count_pos
);
18053 if (nonce_count_len
> 50)
18055 myfree (temp_input_buf
);
18057 return (PARSER_SALT_LENGTH
);
18062 char *directive_pos
= strchr (qop_pos
, '*');
18064 if (directive_pos
== NULL
)
18066 myfree (temp_input_buf
);
18068 return (PARSER_SEPARATOR_UNMATCHED
);
18071 directive_pos
[0] = 0;
18074 uint qop_len
= strlen (qop_pos
);
18078 myfree (temp_input_buf
);
18080 return (PARSER_SALT_LENGTH
);
18085 char *digest_pos
= strchr (directive_pos
, '*');
18087 if (digest_pos
== NULL
)
18089 myfree (temp_input_buf
);
18091 return (PARSER_SEPARATOR_UNMATCHED
);
18097 uint directive_len
= strlen (directive_pos
);
18099 if (directive_len
!= 3)
18101 myfree (temp_input_buf
);
18103 return (PARSER_SALT_LENGTH
);
18106 if (memcmp (directive_pos
, "MD5", 3))
18108 log_info ("ERROR: only the MD5 directive is currently supported\n");
18110 myfree (temp_input_buf
);
18112 return (PARSER_SIP_AUTH_DIRECTIVE
);
18116 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18121 uint md5_max_len
= 4 * 64;
18123 uint md5_remaining_len
= md5_max_len
;
18125 uint tmp_md5_buf
[64] = { 0 };
18127 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18129 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18131 md5_len
+= method_len
+ 1;
18132 tmp_md5_ptr
+= method_len
+ 1;
18134 if (URI_prefix_len
> 0)
18136 md5_remaining_len
= md5_max_len
- md5_len
;
18138 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18140 md5_len
+= URI_prefix_len
+ 1;
18141 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18144 md5_remaining_len
= md5_max_len
- md5_len
;
18146 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18148 md5_len
+= URI_resource_len
;
18149 tmp_md5_ptr
+= URI_resource_len
;
18151 if (URI_suffix_len
> 0)
18153 md5_remaining_len
= md5_max_len
- md5_len
;
18155 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18157 md5_len
+= 1 + URI_suffix_len
;
18160 uint tmp_digest
[4] = { 0 };
18162 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18164 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18165 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18166 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18167 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18173 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18175 uint esalt_len
= 0;
18177 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18179 // there are 2 possibilities for the esalt:
18181 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18183 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18185 if (esalt_len
> max_esalt_len
)
18187 myfree (temp_input_buf
);
18189 return (PARSER_SALT_LENGTH
);
18192 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18204 esalt_len
= 1 + nonce_len
+ 1 + 32;
18206 if (esalt_len
> max_esalt_len
)
18208 myfree (temp_input_buf
);
18210 return (PARSER_SALT_LENGTH
);
18213 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18221 // add 0x80 to esalt
18223 esalt_buf_ptr
[esalt_len
] = 0x80;
18225 sip
->esalt_len
= esalt_len
;
18231 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18233 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18235 uint max_salt_len
= 119;
18237 if (salt_len
> max_salt_len
)
18239 myfree (temp_input_buf
);
18241 return (PARSER_SALT_LENGTH
);
18244 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18246 sip
->salt_len
= salt_len
;
18249 * fake salt (for sorting)
18252 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18256 uint fake_salt_len
= salt_len
;
18258 if (fake_salt_len
> max_salt_len
)
18260 fake_salt_len
= max_salt_len
;
18263 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18265 salt
->salt_len
= fake_salt_len
;
18271 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18272 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18273 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18274 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18276 digest
[0] = byte_swap_32 (digest
[0]);
18277 digest
[1] = byte_swap_32 (digest
[1]);
18278 digest
[2] = byte_swap_32 (digest
[2]);
18279 digest
[3] = byte_swap_32 (digest
[3]);
18281 myfree (temp_input_buf
);
18283 return (PARSER_OK
);
18286 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18288 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18290 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18292 u32
*digest
= (u32
*) hash_buf
->digest
;
18294 salt_t
*salt
= hash_buf
->salt
;
18298 char *digest_pos
= input_buf
;
18300 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18307 char *salt_buf
= input_buf
+ 8 + 1;
18311 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18313 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18315 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18317 salt
->salt_len
= salt_len
;
18319 return (PARSER_OK
);
18322 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18324 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18326 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18328 u32
*digest
= (u32
*) hash_buf
->digest
;
18330 salt_t
*salt
= hash_buf
->salt
;
18332 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18338 char *p_buf_pos
= input_buf
+ 4;
18340 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18342 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18344 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18346 NumCyclesPower_pos
++;
18348 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18350 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18352 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18356 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18358 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18360 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18364 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18366 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18368 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18372 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18374 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18376 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18380 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18382 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18384 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18388 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18390 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18392 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18396 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18398 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18400 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18404 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18406 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18408 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18412 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;
18414 const uint iter
= atoi (NumCyclesPower_pos
);
18415 const uint crc
= atoi (crc_buf_pos
);
18416 const uint p_buf
= atoi (p_buf_pos
);
18417 const uint salt_len
= atoi (salt_len_pos
);
18418 const uint iv_len
= atoi (iv_len_pos
);
18419 const uint unpack_size
= atoi (unpack_size_pos
);
18420 const uint data_len
= atoi (data_len_pos
);
18426 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18427 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18429 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18431 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18433 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18439 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18440 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18441 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18442 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18444 seven_zip
->iv_len
= iv_len
;
18446 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18448 seven_zip
->salt_len
= 0;
18450 seven_zip
->crc
= crc
;
18452 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18454 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18456 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18459 seven_zip
->data_len
= data_len
;
18461 seven_zip
->unpack_size
= unpack_size
;
18465 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18466 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18467 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18468 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18470 salt
->salt_len
= 16;
18472 salt
->salt_sign
[0] = iter
;
18474 salt
->salt_iter
= 1 << iter
;
18485 return (PARSER_OK
);
18488 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18490 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18492 u32
*digest
= (u32
*) hash_buf
->digest
;
18494 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18495 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18496 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18497 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18498 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18499 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18500 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18501 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18503 digest
[0] = byte_swap_32 (digest
[0]);
18504 digest
[1] = byte_swap_32 (digest
[1]);
18505 digest
[2] = byte_swap_32 (digest
[2]);
18506 digest
[3] = byte_swap_32 (digest
[3]);
18507 digest
[4] = byte_swap_32 (digest
[4]);
18508 digest
[5] = byte_swap_32 (digest
[5]);
18509 digest
[6] = byte_swap_32 (digest
[6]);
18510 digest
[7] = byte_swap_32 (digest
[7]);
18512 return (PARSER_OK
);
18515 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18517 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18519 u32
*digest
= (u32
*) hash_buf
->digest
;
18521 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18522 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18523 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18524 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18525 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18526 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18527 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18528 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18529 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18530 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18531 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18532 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18533 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18534 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18535 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18536 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18538 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18539 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18540 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18541 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18542 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18543 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18544 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18545 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18546 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18547 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18548 digest
[10] = byte_swap_32 (digest
[10]);
18549 digest
[11] = byte_swap_32 (digest
[11]);
18550 digest
[12] = byte_swap_32 (digest
[12]);
18551 digest
[13] = byte_swap_32 (digest
[13]);
18552 digest
[14] = byte_swap_32 (digest
[14]);
18553 digest
[15] = byte_swap_32 (digest
[15]);
18555 return (PARSER_OK
);
18558 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18560 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18562 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18564 u32
*digest
= (u32
*) hash_buf
->digest
;
18566 salt_t
*salt
= hash_buf
->salt
;
18568 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18576 char *iter_pos
= input_buf
+ 4;
18578 u32 iter
= atoi (iter_pos
);
18580 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18581 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18583 // first is *raw* salt
18585 char *salt_pos
= strchr (iter_pos
, ':');
18587 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18591 char *hash_pos
= strchr (salt_pos
, ':');
18593 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18595 u32 salt_len
= hash_pos
- salt_pos
;
18597 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18601 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18603 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18607 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18609 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18611 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18613 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18614 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18616 salt
->salt_len
= salt_len
;
18617 salt
->salt_iter
= iter
- 1;
18621 u8 tmp_buf
[100] = { 0 };
18623 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18625 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18627 memcpy (digest
, tmp_buf
, 16);
18629 // add some stuff to normal salt to make sorted happy
18631 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18632 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18633 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18634 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18635 salt
->salt_buf
[4] = salt
->salt_iter
;
18637 return (PARSER_OK
);
18640 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18642 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18644 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18646 u32
*digest
= (u32
*) hash_buf
->digest
;
18648 salt_t
*salt
= hash_buf
->salt
;
18650 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18658 char *iter_pos
= input_buf
+ 5;
18660 u32 iter
= atoi (iter_pos
);
18662 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18663 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18665 // first is *raw* salt
18667 char *salt_pos
= strchr (iter_pos
, ':');
18669 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18673 char *hash_pos
= strchr (salt_pos
, ':');
18675 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18677 u32 salt_len
= hash_pos
- salt_pos
;
18679 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18683 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18685 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18689 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18691 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18693 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18695 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18696 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18698 salt
->salt_len
= salt_len
;
18699 salt
->salt_iter
= iter
- 1;
18703 u8 tmp_buf
[100] = { 0 };
18705 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18707 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18709 memcpy (digest
, tmp_buf
, 16);
18711 digest
[0] = byte_swap_32 (digest
[0]);
18712 digest
[1] = byte_swap_32 (digest
[1]);
18713 digest
[2] = byte_swap_32 (digest
[2]);
18714 digest
[3] = byte_swap_32 (digest
[3]);
18716 // add some stuff to normal salt to make sorted happy
18718 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18719 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18720 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18721 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18722 salt
->salt_buf
[4] = salt
->salt_iter
;
18724 return (PARSER_OK
);
18727 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18729 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18731 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18733 u64
*digest
= (u64
*) hash_buf
->digest
;
18735 salt_t
*salt
= hash_buf
->salt
;
18737 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18745 char *iter_pos
= input_buf
+ 7;
18747 u32 iter
= atoi (iter_pos
);
18749 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18750 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18752 // first is *raw* salt
18754 char *salt_pos
= strchr (iter_pos
, ':');
18756 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18760 char *hash_pos
= strchr (salt_pos
, ':');
18762 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18764 u32 salt_len
= hash_pos
- salt_pos
;
18766 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18770 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18772 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18776 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18778 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18780 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18782 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18783 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18785 salt
->salt_len
= salt_len
;
18786 salt
->salt_iter
= iter
- 1;
18790 u8 tmp_buf
[100] = { 0 };
18792 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18794 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18796 memcpy (digest
, tmp_buf
, 64);
18798 digest
[0] = byte_swap_64 (digest
[0]);
18799 digest
[1] = byte_swap_64 (digest
[1]);
18800 digest
[2] = byte_swap_64 (digest
[2]);
18801 digest
[3] = byte_swap_64 (digest
[3]);
18802 digest
[4] = byte_swap_64 (digest
[4]);
18803 digest
[5] = byte_swap_64 (digest
[5]);
18804 digest
[6] = byte_swap_64 (digest
[6]);
18805 digest
[7] = byte_swap_64 (digest
[7]);
18807 // add some stuff to normal salt to make sorted happy
18809 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18810 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18811 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18812 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18813 salt
->salt_buf
[4] = salt
->salt_iter
;
18815 return (PARSER_OK
);
18818 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18820 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18822 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18824 uint
*digest
= (uint
*) hash_buf
->digest
;
18826 salt_t
*salt
= hash_buf
->salt
;
18832 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18834 char *hash_pos
= strchr (salt_pos
, '$');
18836 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18838 u32 salt_len
= hash_pos
- salt_pos
;
18840 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18844 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18846 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18850 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18851 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18869 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18870 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18872 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18873 salt
->salt_len
= 8;
18875 return (PARSER_OK
);
18878 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18880 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18882 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18884 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18886 if (c19
& 3) return (PARSER_HASH_VALUE
);
18888 salt_t
*salt
= hash_buf
->salt
;
18890 u32
*digest
= (u32
*) hash_buf
->digest
;
18894 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18895 | itoa64_to_int (input_buf
[2]) << 6
18896 | itoa64_to_int (input_buf
[3]) << 12
18897 | itoa64_to_int (input_buf
[4]) << 18;
18901 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18902 | itoa64_to_int (input_buf
[6]) << 6
18903 | itoa64_to_int (input_buf
[7]) << 12
18904 | itoa64_to_int (input_buf
[8]) << 18;
18906 salt
->salt_len
= 4;
18908 u8 tmp_buf
[100] = { 0 };
18910 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18912 memcpy (digest
, tmp_buf
, 8);
18916 IP (digest
[0], digest
[1], tt
);
18918 digest
[0] = rotr32 (digest
[0], 31);
18919 digest
[1] = rotr32 (digest
[1], 31);
18923 return (PARSER_OK
);
18926 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18928 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18930 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18932 u32
*digest
= (u32
*) hash_buf
->digest
;
18934 salt_t
*salt
= hash_buf
->salt
;
18940 char *type_pos
= input_buf
+ 6 + 1;
18942 char *salt_pos
= strchr (type_pos
, '*');
18944 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18946 u32 type_len
= salt_pos
- type_pos
;
18948 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18952 char *crypted_pos
= strchr (salt_pos
, '*');
18954 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18956 u32 salt_len
= crypted_pos
- salt_pos
;
18958 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18962 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18964 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18970 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18971 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18973 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18974 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18976 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18977 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18978 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18979 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18981 salt
->salt_len
= 24;
18982 salt
->salt_iter
= ROUNDS_RAR3
;
18984 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18985 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18987 digest
[0] = 0xc43d7b00;
18988 digest
[1] = 0x40070000;
18992 return (PARSER_OK
);
18995 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18997 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18999 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19001 u32
*digest
= (u32
*) hash_buf
->digest
;
19003 salt_t
*salt
= hash_buf
->salt
;
19005 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19011 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19013 char *param1_pos
= strchr (param0_pos
, '$');
19015 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19017 u32 param0_len
= param1_pos
- param0_pos
;
19021 char *param2_pos
= strchr (param1_pos
, '$');
19023 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19025 u32 param1_len
= param2_pos
- param1_pos
;
19029 char *param3_pos
= strchr (param2_pos
, '$');
19031 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19033 u32 param2_len
= param3_pos
- param2_pos
;
19037 char *param4_pos
= strchr (param3_pos
, '$');
19039 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19041 u32 param3_len
= param4_pos
- param3_pos
;
19045 char *param5_pos
= strchr (param4_pos
, '$');
19047 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19049 u32 param4_len
= param5_pos
- param4_pos
;
19053 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19055 char *salt_buf
= param1_pos
;
19056 char *iv
= param3_pos
;
19057 char *pswcheck
= param5_pos
;
19059 const uint salt_len
= atoi (param0_pos
);
19060 const uint iterations
= atoi (param2_pos
);
19061 const uint pswcheck_len
= atoi (param4_pos
);
19067 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19068 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19069 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19071 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19072 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19073 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19079 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19080 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19081 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19082 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19084 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19085 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19086 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19087 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19089 salt
->salt_len
= 16;
19091 salt
->salt_sign
[0] = iterations
;
19093 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19099 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19100 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19104 return (PARSER_OK
);
19107 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19109 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19111 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19113 u32
*digest
= (u32
*) hash_buf
->digest
;
19115 salt_t
*salt
= hash_buf
->salt
;
19117 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19124 char *account_pos
= input_buf
+ 11 + 1;
19130 if (account_pos
[0] == '*')
19134 data_pos
= strchr (account_pos
, '*');
19139 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19141 uint account_len
= data_pos
- account_pos
+ 1;
19143 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19148 data_len
= input_len
- 11 - 1 - account_len
- 2;
19150 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19154 /* assume $krb5tgs$23$checksum$edata2 */
19155 data_pos
= account_pos
;
19157 memcpy (krb5tgs
->account_info
, "**", 3);
19159 data_len
= input_len
- 11 - 1 - 1;
19162 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19164 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19166 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19168 const char p0
= data_pos
[i
+ 0];
19169 const char p1
= data_pos
[i
+ 1];
19171 *checksum_ptr
++ = hex_convert (p1
) << 0
19172 | hex_convert (p0
) << 4;
19175 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19177 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19180 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19182 const char p0
= data_pos
[i
+ 0];
19183 const char p1
= data_pos
[i
+ 1];
19184 *edata_ptr
++ = hex_convert (p1
) << 0
19185 | hex_convert (p0
) << 4;
19188 /* this is needed for hmac_md5 */
19189 *edata_ptr
++ = 0x80;
19191 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19192 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19193 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19194 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19196 salt
->salt_len
= 32;
19198 digest
[0] = krb5tgs
->checksum
[0];
19199 digest
[1] = krb5tgs
->checksum
[1];
19200 digest
[2] = krb5tgs
->checksum
[2];
19201 digest
[3] = krb5tgs
->checksum
[3];
19203 return (PARSER_OK
);
19206 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19208 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19210 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19212 u32
*digest
= (u32
*) hash_buf
->digest
;
19214 salt_t
*salt
= hash_buf
->salt
;
19221 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19225 char *wrapped_key_pos
;
19229 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19231 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19233 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19235 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19240 data_pos
= salt_pos
;
19242 wrapped_key_pos
= strchr (salt_pos
, '*');
19244 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19246 uint salt_len
= wrapped_key_pos
- salt_pos
;
19248 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19253 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19255 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19257 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19258 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19259 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19260 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19264 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19265 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19266 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19267 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19268 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19269 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19271 salt
->salt_len
= 40;
19273 digest
[0] = salt
->salt_buf
[0];
19274 digest
[1] = salt
->salt_buf
[1];
19275 digest
[2] = salt
->salt_buf
[2];
19276 digest
[3] = salt
->salt_buf
[3];
19278 return (PARSER_OK
);
19281 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19283 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19285 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19287 u32
*digest
= (u32
*) hash_buf
->digest
;
19289 salt_t
*salt
= hash_buf
->salt
;
19291 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19301 char *algorithm_pos
;
19303 char *final_random_seed_pos
;
19304 u32 final_random_seed_len
;
19306 char *transf_random_seed_pos
;
19307 u32 transf_random_seed_len
;
19312 /* default is no keyfile provided */
19313 char *keyfile_len_pos
;
19314 u32 keyfile_len
= 0;
19315 u32 is_keyfile_present
= 0;
19316 char *keyfile_inline_pos
;
19319 /* specific to version 1 */
19320 char *contents_len_pos
;
19322 char *contents_pos
;
19324 /* specific to version 2 */
19325 char *expected_bytes_pos
;
19326 u32 expected_bytes_len
;
19328 char *contents_hash_pos
;
19329 u32 contents_hash_len
;
19331 version_pos
= input_buf
+ 8 + 1 + 1;
19333 keepass
->version
= atoi (version_pos
);
19335 rounds_pos
= strchr (version_pos
, '*');
19337 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19341 salt
->salt_iter
= (atoi (rounds_pos
));
19343 algorithm_pos
= strchr (rounds_pos
, '*');
19345 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19349 keepass
->algorithm
= atoi (algorithm_pos
);
19351 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19353 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19355 final_random_seed_pos
++;
19357 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19358 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19359 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19360 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19362 if (keepass
->version
== 2)
19364 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19365 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19366 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19367 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19370 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19372 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19374 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19376 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19377 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19379 transf_random_seed_pos
++;
19381 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19382 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19383 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19384 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19385 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19386 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19387 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19388 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19390 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19392 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19394 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19396 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19400 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19401 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19402 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19403 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19405 if (keepass
->version
== 1)
19407 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19409 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19411 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19413 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19415 contents_hash_pos
++;
19417 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19418 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19419 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19420 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19421 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19422 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19423 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19424 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19426 /* get length of contents following */
19427 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19429 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19431 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19433 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19437 u32 inline_flag
= atoi (inline_flag_pos
);
19439 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19441 contents_len_pos
= strchr (inline_flag_pos
, '*');
19443 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19445 contents_len_pos
++;
19447 contents_len
= atoi (contents_len_pos
);
19449 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19451 contents_pos
= strchr (contents_len_pos
, '*');
19453 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19459 keepass
->contents_len
= contents_len
;
19461 contents_len
= contents_len
/ 4;
19463 keyfile_inline_pos
= strchr (contents_pos
, '*');
19465 u32 real_contents_len
;
19467 if (keyfile_inline_pos
== NULL
)
19468 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19471 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19472 keyfile_inline_pos
++;
19473 is_keyfile_present
= 1;
19476 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
19478 for (i
= 0; i
< contents_len
; i
++)
19479 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
19481 else if (keepass
->version
== 2)
19483 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
19485 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19487 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
19489 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19491 expected_bytes_pos
++;
19493 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
19494 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
19495 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
19496 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
19497 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
19498 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
19499 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
19500 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
19502 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
19504 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19506 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
19508 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
19510 contents_hash_pos
++;
19512 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19513 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19514 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19515 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19516 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19517 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19518 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19519 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19521 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
19523 if (keyfile_inline_pos
== NULL
)
19524 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
19527 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
19528 keyfile_inline_pos
++;
19529 is_keyfile_present
= 1;
19531 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19534 if (is_keyfile_present
!= 0)
19536 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
19540 keyfile_len
= atoi (keyfile_len_pos
);
19542 keepass
->keyfile_len
= keyfile_len
;
19544 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19546 keyfile_pos
= strchr (keyfile_len_pos
, '*');
19548 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19552 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
19554 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19556 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
19557 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
19558 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
19559 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
19560 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
19561 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
19562 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
19563 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
19566 digest
[0] = keepass
->enc_iv
[0];
19567 digest
[1] = keepass
->enc_iv
[1];
19568 digest
[2] = keepass
->enc_iv
[2];
19569 digest
[3] = keepass
->enc_iv
[3];
19571 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
19572 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
19573 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
19574 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
19575 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
19576 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
19577 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
19578 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
19580 return (PARSER_OK
);
19583 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19585 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
19587 u32
*digest
= (u32
*) hash_buf
->digest
;
19589 salt_t
*salt
= hash_buf
->salt
;
19591 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19592 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19593 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19594 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19595 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19596 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19597 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19598 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19600 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
19602 uint salt_len
= input_len
- 64 - 1;
19604 char *salt_buf
= input_buf
+ 64 + 1;
19606 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
19608 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
19610 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19612 salt
->salt_len
= salt_len
;
19615 * we can precompute the first sha256 transform
19618 uint w
[16] = { 0 };
19620 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
19621 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
19622 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
19623 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
19624 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
19625 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
19626 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
19627 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
19628 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
19629 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
19630 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
19631 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
19632 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
19633 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
19634 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
19635 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
19637 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
19639 sha256_64 (w
, pc256
);
19641 salt
->salt_buf_pc
[0] = pc256
[0];
19642 salt
->salt_buf_pc
[1] = pc256
[1];
19643 salt
->salt_buf_pc
[2] = pc256
[2];
19644 salt
->salt_buf_pc
[3] = pc256
[3];
19645 salt
->salt_buf_pc
[4] = pc256
[4];
19646 salt
->salt_buf_pc
[5] = pc256
[5];
19647 salt
->salt_buf_pc
[6] = pc256
[6];
19648 salt
->salt_buf_pc
[7] = pc256
[7];
19650 digest
[0] -= pc256
[0];
19651 digest
[1] -= pc256
[1];
19652 digest
[2] -= pc256
[2];
19653 digest
[3] -= pc256
[3];
19654 digest
[4] -= pc256
[4];
19655 digest
[5] -= pc256
[5];
19656 digest
[6] -= pc256
[6];
19657 digest
[7] -= pc256
[7];
19659 return (PARSER_OK
);
19662 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19664 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
19666 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
19668 u32
*digest
= (u32
*) hash_buf
->digest
;
19670 salt_t
*salt
= hash_buf
->salt
;
19676 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
19678 char *data_buf_pos
= strchr (data_len_pos
, '$');
19680 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19682 u32 data_len_len
= data_buf_pos
- data_len_pos
;
19684 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
19685 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
19689 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
19691 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
19693 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
19695 u32 data_len
= atoi (data_len_pos
);
19697 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
19703 char *salt_pos
= data_buf_pos
;
19705 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19706 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19707 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
19708 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
19710 // this is actually the CT, which is also the hash later (if matched)
19712 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
19713 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
19714 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
19715 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
19717 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
19719 salt
->salt_iter
= 10 - 1;
19725 digest
[0] = salt
->salt_buf
[4];
19726 digest
[1] = salt
->salt_buf
[5];
19727 digest
[2] = salt
->salt_buf
[6];
19728 digest
[3] = salt
->salt_buf
[7];
19730 return (PARSER_OK
);
19733 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19735 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
19737 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19739 u32
*digest
= (u32
*) hash_buf
->digest
;
19741 salt_t
*salt
= hash_buf
->salt
;
19747 char *salt_pos
= input_buf
+ 11 + 1;
19749 char *iter_pos
= strchr (salt_pos
, ',');
19751 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19753 u32 salt_len
= iter_pos
- salt_pos
;
19755 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
19759 char *hash_pos
= strchr (iter_pos
, ',');
19761 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19763 u32 iter_len
= hash_pos
- iter_pos
;
19765 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
19769 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
19771 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
19777 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19778 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19779 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
19780 salt
->salt_buf
[3] = 0x00018000;
19782 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19783 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19784 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
19785 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
19787 salt
->salt_len
= salt_len
/ 2;
19789 salt
->salt_iter
= atoi (iter_pos
) - 1;
19795 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19796 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19797 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19798 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19799 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19800 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19801 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19802 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19804 return (PARSER_OK
);
19807 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19809 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
19811 u32
*digest
= (u32
*) hash_buf
->digest
;
19813 salt_t
*salt
= hash_buf
->salt
;
19819 char *hash_pos
= input_buf
+ 64;
19820 char *salt1_pos
= input_buf
+ 128;
19821 char *salt2_pos
= input_buf
;
19827 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
19828 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
19829 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
19830 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
19832 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
19833 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
19834 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
19835 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
19837 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
19838 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
19839 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
19840 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
19842 salt
->salt_len
= 48;
19844 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
19850 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19851 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19852 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19853 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19854 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19855 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19856 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19857 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19859 return (PARSER_OK
);
19863 * parallel running threads
19868 BOOL WINAPI
sigHandler_default (DWORD sig
)
19872 case CTRL_CLOSE_EVENT
:
19875 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
19876 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
19877 * function otherwise it is too late (e.g. after returning from this function)
19882 SetConsoleCtrlHandler (NULL
, TRUE
);
19889 case CTRL_LOGOFF_EVENT
:
19890 case CTRL_SHUTDOWN_EVENT
:
19894 SetConsoleCtrlHandler (NULL
, TRUE
);
19902 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19906 case CTRL_CLOSE_EVENT
:
19910 SetConsoleCtrlHandler (NULL
, TRUE
);
19917 case CTRL_LOGOFF_EVENT
:
19918 case CTRL_SHUTDOWN_EVENT
:
19922 SetConsoleCtrlHandler (NULL
, TRUE
);
19930 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19932 if (callback
== NULL
)
19934 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19938 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19944 void sigHandler_default (int sig
)
19948 signal (sig
, NULL
);
19951 void sigHandler_benchmark (int sig
)
19955 signal (sig
, NULL
);
19958 void hc_signal (void (callback
) (int))
19960 if (callback
== NULL
) callback
= SIG_DFL
;
19962 signal (SIGINT
, callback
);
19963 signal (SIGTERM
, callback
);
19964 signal (SIGABRT
, callback
);
19969 void status_display ();
19971 void *thread_keypress (void *p
)
19973 int benchmark
= *((int *) p
);
19975 uint quiet
= data
.quiet
;
19979 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19981 int ch
= tty_getchar();
19983 if (ch
== -1) break;
19985 if (ch
== 0) continue;
19987 //https://github.com/hashcat/oclHashcat/issues/302
19992 hc_thread_mutex_lock (mux_display
);
20008 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20009 if (quiet
== 0) fflush (stdout
);
20021 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20022 if (quiet
== 0) fflush (stdout
);
20034 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20035 if (quiet
== 0) fflush (stdout
);
20047 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20048 if (quiet
== 0) fflush (stdout
);
20056 if (benchmark
== 1) break;
20058 stop_at_checkpoint ();
20062 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20063 if (quiet
== 0) fflush (stdout
);
20071 if (benchmark
== 1)
20083 //https://github.com/hashcat/oclHashcat/issues/302
20088 hc_thread_mutex_unlock (mux_display
);
20100 bool class_num (const u8 c
)
20102 return ((c
>= '0') && (c
<= '9'));
20105 bool class_lower (const u8 c
)
20107 return ((c
>= 'a') && (c
<= 'z'));
20110 bool class_upper (const u8 c
)
20112 return ((c
>= 'A') && (c
<= 'Z'));
20115 bool class_alpha (const u8 c
)
20117 return (class_lower (c
) || class_upper (c
));
20120 int conv_ctoi (const u8 c
)
20126 else if (class_upper (c
))
20128 return c
- 'A' + 10;
20134 int conv_itoc (const u8 c
)
20142 return c
+ 'A' - 10;
20152 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20153 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20154 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20155 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20156 #define MAX_KERNEL_RULES 255
20157 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20158 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20159 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20161 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20162 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20163 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20164 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20166 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20171 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20173 switch (rule_buf
[rule_pos
])
20179 case RULE_OP_MANGLE_NOOP
:
20180 SET_NAME (rule
, rule_buf
[rule_pos
]);
20183 case RULE_OP_MANGLE_LREST
:
20184 SET_NAME (rule
, rule_buf
[rule_pos
]);
20187 case RULE_OP_MANGLE_UREST
:
20188 SET_NAME (rule
, rule_buf
[rule_pos
]);
20191 case RULE_OP_MANGLE_LREST_UFIRST
:
20192 SET_NAME (rule
, rule_buf
[rule_pos
]);
20195 case RULE_OP_MANGLE_UREST_LFIRST
:
20196 SET_NAME (rule
, rule_buf
[rule_pos
]);
20199 case RULE_OP_MANGLE_TREST
:
20200 SET_NAME (rule
, rule_buf
[rule_pos
]);
20203 case RULE_OP_MANGLE_TOGGLE_AT
:
20204 SET_NAME (rule
, rule_buf
[rule_pos
]);
20205 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20208 case RULE_OP_MANGLE_REVERSE
:
20209 SET_NAME (rule
, rule_buf
[rule_pos
]);
20212 case RULE_OP_MANGLE_DUPEWORD
:
20213 SET_NAME (rule
, rule_buf
[rule_pos
]);
20216 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20217 SET_NAME (rule
, rule_buf
[rule_pos
]);
20218 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20221 case RULE_OP_MANGLE_REFLECT
:
20222 SET_NAME (rule
, rule_buf
[rule_pos
]);
20225 case RULE_OP_MANGLE_ROTATE_LEFT
:
20226 SET_NAME (rule
, rule_buf
[rule_pos
]);
20229 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20230 SET_NAME (rule
, rule_buf
[rule_pos
]);
20233 case RULE_OP_MANGLE_APPEND
:
20234 SET_NAME (rule
, rule_buf
[rule_pos
]);
20235 SET_P0 (rule
, rule_buf
[rule_pos
]);
20238 case RULE_OP_MANGLE_PREPEND
:
20239 SET_NAME (rule
, rule_buf
[rule_pos
]);
20240 SET_P0 (rule
, rule_buf
[rule_pos
]);
20243 case RULE_OP_MANGLE_DELETE_FIRST
:
20244 SET_NAME (rule
, rule_buf
[rule_pos
]);
20247 case RULE_OP_MANGLE_DELETE_LAST
:
20248 SET_NAME (rule
, rule_buf
[rule_pos
]);
20251 case RULE_OP_MANGLE_DELETE_AT
:
20252 SET_NAME (rule
, rule_buf
[rule_pos
]);
20253 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20256 case RULE_OP_MANGLE_EXTRACT
:
20257 SET_NAME (rule
, rule_buf
[rule_pos
]);
20258 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20259 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20262 case RULE_OP_MANGLE_OMIT
:
20263 SET_NAME (rule
, rule_buf
[rule_pos
]);
20264 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20265 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20268 case RULE_OP_MANGLE_INSERT
:
20269 SET_NAME (rule
, rule_buf
[rule_pos
]);
20270 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20271 SET_P1 (rule
, rule_buf
[rule_pos
]);
20274 case RULE_OP_MANGLE_OVERSTRIKE
:
20275 SET_NAME (rule
, rule_buf
[rule_pos
]);
20276 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20277 SET_P1 (rule
, rule_buf
[rule_pos
]);
20280 case RULE_OP_MANGLE_TRUNCATE_AT
:
20281 SET_NAME (rule
, rule_buf
[rule_pos
]);
20282 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20285 case RULE_OP_MANGLE_REPLACE
:
20286 SET_NAME (rule
, rule_buf
[rule_pos
]);
20287 SET_P0 (rule
, rule_buf
[rule_pos
]);
20288 SET_P1 (rule
, rule_buf
[rule_pos
]);
20291 case RULE_OP_MANGLE_PURGECHAR
:
20295 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20299 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20300 SET_NAME (rule
, rule_buf
[rule_pos
]);
20301 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20304 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20305 SET_NAME (rule
, rule_buf
[rule_pos
]);
20306 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20309 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20310 SET_NAME (rule
, rule_buf
[rule_pos
]);
20313 case RULE_OP_MANGLE_SWITCH_FIRST
:
20314 SET_NAME (rule
, rule_buf
[rule_pos
]);
20317 case RULE_OP_MANGLE_SWITCH_LAST
:
20318 SET_NAME (rule
, rule_buf
[rule_pos
]);
20321 case RULE_OP_MANGLE_SWITCH_AT
:
20322 SET_NAME (rule
, rule_buf
[rule_pos
]);
20323 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20324 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20327 case RULE_OP_MANGLE_CHR_SHIFTL
:
20328 SET_NAME (rule
, rule_buf
[rule_pos
]);
20329 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20332 case RULE_OP_MANGLE_CHR_SHIFTR
:
20333 SET_NAME (rule
, rule_buf
[rule_pos
]);
20334 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20337 case RULE_OP_MANGLE_CHR_INCR
:
20338 SET_NAME (rule
, rule_buf
[rule_pos
]);
20339 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20342 case RULE_OP_MANGLE_CHR_DECR
:
20343 SET_NAME (rule
, rule_buf
[rule_pos
]);
20344 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20347 case RULE_OP_MANGLE_REPLACE_NP1
:
20348 SET_NAME (rule
, rule_buf
[rule_pos
]);
20349 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20352 case RULE_OP_MANGLE_REPLACE_NM1
:
20353 SET_NAME (rule
, rule_buf
[rule_pos
]);
20354 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20357 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20358 SET_NAME (rule
, rule_buf
[rule_pos
]);
20359 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20362 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20363 SET_NAME (rule
, rule_buf
[rule_pos
]);
20364 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20367 case RULE_OP_MANGLE_TITLE
:
20368 SET_NAME (rule
, rule_buf
[rule_pos
]);
20377 if (rule_pos
< rule_len
) return (-1);
20382 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
20386 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
20390 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20394 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
20398 case RULE_OP_MANGLE_NOOP
:
20399 rule_buf
[rule_pos
] = rule_cmd
;
20402 case RULE_OP_MANGLE_LREST
:
20403 rule_buf
[rule_pos
] = rule_cmd
;
20406 case RULE_OP_MANGLE_UREST
:
20407 rule_buf
[rule_pos
] = rule_cmd
;
20410 case RULE_OP_MANGLE_LREST_UFIRST
:
20411 rule_buf
[rule_pos
] = rule_cmd
;
20414 case RULE_OP_MANGLE_UREST_LFIRST
:
20415 rule_buf
[rule_pos
] = rule_cmd
;
20418 case RULE_OP_MANGLE_TREST
:
20419 rule_buf
[rule_pos
] = rule_cmd
;
20422 case RULE_OP_MANGLE_TOGGLE_AT
:
20423 rule_buf
[rule_pos
] = rule_cmd
;
20424 GET_P0_CONV (rule
);
20427 case RULE_OP_MANGLE_REVERSE
:
20428 rule_buf
[rule_pos
] = rule_cmd
;
20431 case RULE_OP_MANGLE_DUPEWORD
:
20432 rule_buf
[rule_pos
] = rule_cmd
;
20435 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20436 rule_buf
[rule_pos
] = rule_cmd
;
20437 GET_P0_CONV (rule
);
20440 case RULE_OP_MANGLE_REFLECT
:
20441 rule_buf
[rule_pos
] = rule_cmd
;
20444 case RULE_OP_MANGLE_ROTATE_LEFT
:
20445 rule_buf
[rule_pos
] = rule_cmd
;
20448 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20449 rule_buf
[rule_pos
] = rule_cmd
;
20452 case RULE_OP_MANGLE_APPEND
:
20453 rule_buf
[rule_pos
] = rule_cmd
;
20457 case RULE_OP_MANGLE_PREPEND
:
20458 rule_buf
[rule_pos
] = rule_cmd
;
20462 case RULE_OP_MANGLE_DELETE_FIRST
:
20463 rule_buf
[rule_pos
] = rule_cmd
;
20466 case RULE_OP_MANGLE_DELETE_LAST
:
20467 rule_buf
[rule_pos
] = rule_cmd
;
20470 case RULE_OP_MANGLE_DELETE_AT
:
20471 rule_buf
[rule_pos
] = rule_cmd
;
20472 GET_P0_CONV (rule
);
20475 case RULE_OP_MANGLE_EXTRACT
:
20476 rule_buf
[rule_pos
] = rule_cmd
;
20477 GET_P0_CONV (rule
);
20478 GET_P1_CONV (rule
);
20481 case RULE_OP_MANGLE_OMIT
:
20482 rule_buf
[rule_pos
] = rule_cmd
;
20483 GET_P0_CONV (rule
);
20484 GET_P1_CONV (rule
);
20487 case RULE_OP_MANGLE_INSERT
:
20488 rule_buf
[rule_pos
] = rule_cmd
;
20489 GET_P0_CONV (rule
);
20493 case RULE_OP_MANGLE_OVERSTRIKE
:
20494 rule_buf
[rule_pos
] = rule_cmd
;
20495 GET_P0_CONV (rule
);
20499 case RULE_OP_MANGLE_TRUNCATE_AT
:
20500 rule_buf
[rule_pos
] = rule_cmd
;
20501 GET_P0_CONV (rule
);
20504 case RULE_OP_MANGLE_REPLACE
:
20505 rule_buf
[rule_pos
] = rule_cmd
;
20510 case RULE_OP_MANGLE_PURGECHAR
:
20514 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20518 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20519 rule_buf
[rule_pos
] = rule_cmd
;
20520 GET_P0_CONV (rule
);
20523 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20524 rule_buf
[rule_pos
] = rule_cmd
;
20525 GET_P0_CONV (rule
);
20528 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20529 rule_buf
[rule_pos
] = rule_cmd
;
20532 case RULE_OP_MANGLE_SWITCH_FIRST
:
20533 rule_buf
[rule_pos
] = rule_cmd
;
20536 case RULE_OP_MANGLE_SWITCH_LAST
:
20537 rule_buf
[rule_pos
] = rule_cmd
;
20540 case RULE_OP_MANGLE_SWITCH_AT
:
20541 rule_buf
[rule_pos
] = rule_cmd
;
20542 GET_P0_CONV (rule
);
20543 GET_P1_CONV (rule
);
20546 case RULE_OP_MANGLE_CHR_SHIFTL
:
20547 rule_buf
[rule_pos
] = rule_cmd
;
20548 GET_P0_CONV (rule
);
20551 case RULE_OP_MANGLE_CHR_SHIFTR
:
20552 rule_buf
[rule_pos
] = rule_cmd
;
20553 GET_P0_CONV (rule
);
20556 case RULE_OP_MANGLE_CHR_INCR
:
20557 rule_buf
[rule_pos
] = rule_cmd
;
20558 GET_P0_CONV (rule
);
20561 case RULE_OP_MANGLE_CHR_DECR
:
20562 rule_buf
[rule_pos
] = rule_cmd
;
20563 GET_P0_CONV (rule
);
20566 case RULE_OP_MANGLE_REPLACE_NP1
:
20567 rule_buf
[rule_pos
] = rule_cmd
;
20568 GET_P0_CONV (rule
);
20571 case RULE_OP_MANGLE_REPLACE_NM1
:
20572 rule_buf
[rule_pos
] = rule_cmd
;
20573 GET_P0_CONV (rule
);
20576 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20577 rule_buf
[rule_pos
] = rule_cmd
;
20578 GET_P0_CONV (rule
);
20581 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20582 rule_buf
[rule_pos
] = rule_cmd
;
20583 GET_P0_CONV (rule
);
20586 case RULE_OP_MANGLE_TITLE
:
20587 rule_buf
[rule_pos
] = rule_cmd
;
20591 return rule_pos
- 1;
20609 * CPU rules : this is from hashcat sources, cpu based rules
20612 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
20613 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
20615 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
20616 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
20617 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
20619 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
20620 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
20621 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
20623 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
20627 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
20632 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
20636 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
20641 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
20645 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
20650 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
20655 for (l
= 0; l
< arr_len
; l
++)
20657 r
= arr_len
- 1 - l
;
20661 MANGLE_SWITCH (arr
, l
, r
);
20667 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
20669 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20671 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
20673 return (arr_len
* 2);
20676 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
20678 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20680 int orig_len
= arr_len
;
20684 for (i
= 0; i
< times
; i
++)
20686 memcpy (&arr
[arr_len
], arr
, orig_len
);
20688 arr_len
+= orig_len
;
20694 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
20696 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20698 mangle_double (arr
, arr_len
);
20700 mangle_reverse (arr
+ arr_len
, arr_len
);
20702 return (arr_len
* 2);
20705 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
20710 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
20712 MANGLE_SWITCH (arr
, l
, r
);
20718 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
20723 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
20725 MANGLE_SWITCH (arr
, l
, r
);
20731 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20733 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20737 return (arr_len
+ 1);
20740 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20742 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20746 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20748 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20753 return (arr_len
+ 1);
20756 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20758 if (upos
>= arr_len
) return (arr_len
);
20762 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
20764 arr
[arr_pos
] = arr
[arr_pos
+ 1];
20767 return (arr_len
- 1);
20770 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20772 if (upos
>= arr_len
) return (arr_len
);
20774 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
20778 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
20780 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
20786 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20788 if (upos
>= arr_len
) return (arr_len
);
20790 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
20794 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
20796 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
20799 return (arr_len
- ulen
);
20802 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20804 if (upos
>= arr_len
) return (arr_len
);
20806 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20810 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
20812 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20817 return (arr_len
+ 1);
20820 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
)
20822 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20824 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
20826 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
20828 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
20830 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
20832 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
20834 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
20836 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
20838 return (arr_len
+ arr2_cpy
);
20841 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20843 if (upos
>= arr_len
) return (arr_len
);
20850 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20852 if (upos
>= arr_len
) return (arr_len
);
20854 memset (arr
+ upos
, 0, arr_len
- upos
);
20859 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
20863 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20865 if (arr
[arr_pos
] != oldc
) continue;
20867 arr
[arr_pos
] = newc
;
20873 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20879 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20881 if (arr
[arr_pos
] == c
) continue;
20883 arr
[ret_len
] = arr
[arr_pos
];
20891 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20893 if (ulen
> arr_len
) return (arr_len
);
20895 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20897 char cs
[100] = { 0 };
20899 memcpy (cs
, arr
, ulen
);
20903 for (i
= 0; i
< ulen
; i
++)
20907 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20913 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20915 if (ulen
> arr_len
) return (arr_len
);
20917 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20919 int upos
= arr_len
- ulen
;
20923 for (i
= 0; i
< ulen
; i
++)
20925 char c
= arr
[upos
+ i
];
20927 arr_len
= mangle_append (arr
, arr_len
, c
);
20933 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20935 if ( arr_len
== 0) return (arr_len
);
20936 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20938 char c
= arr
[upos
];
20942 for (i
= 0; i
< ulen
; i
++)
20944 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20950 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20952 if ( arr_len
== 0) return (arr_len
);
20953 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20957 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20959 int new_pos
= arr_pos
* 2;
20961 arr
[new_pos
] = arr
[arr_pos
];
20963 arr
[new_pos
+ 1] = arr
[arr_pos
];
20966 return (arr_len
* 2);
20969 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20971 if (upos
>= arr_len
) return (arr_len
);
20972 if (upos2
>= arr_len
) return (arr_len
);
20974 MANGLE_SWITCH (arr
, upos
, upos2
);
20979 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20981 MANGLE_SWITCH (arr
, upos
, upos2
);
20986 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20988 if (upos
>= arr_len
) return (arr_len
);
20995 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20997 if (upos
>= arr_len
) return (arr_len
);
21004 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21006 if (upos
>= arr_len
) return (arr_len
);
21013 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21015 if (upos
>= arr_len
) return (arr_len
);
21022 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21024 int upper_next
= 1;
21028 for (pos
= 0; pos
< arr_len
; pos
++)
21030 if (arr
[pos
] == ' ')
21041 MANGLE_UPPER_AT (arr
, pos
);
21045 MANGLE_LOWER_AT (arr
, pos
);
21052 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21054 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21060 for (j
= 0; j
< rp_gen_num
; j
++)
21067 switch ((char) get_random_num (0, 9))
21070 r
= get_random_num (0, sizeof (grp_op_nop
));
21071 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21075 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21076 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21077 p1
= get_random_num (0, sizeof (grp_pos
));
21078 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21082 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21083 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21084 p1
= get_random_num (1, 6);
21085 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21089 r
= get_random_num (0, sizeof (grp_op_chr
));
21090 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21091 p1
= get_random_num (0x20, 0x7e);
21092 rule_buf
[rule_pos
++] = (char) p1
;
21096 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21097 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21098 p1
= get_random_num (0x20, 0x7e);
21099 rule_buf
[rule_pos
++] = (char) p1
;
21100 p2
= get_random_num (0x20, 0x7e);
21102 p2
= get_random_num (0x20, 0x7e);
21103 rule_buf
[rule_pos
++] = (char) p2
;
21107 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21108 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21109 p1
= get_random_num (0, sizeof (grp_pos
));
21110 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21111 p2
= get_random_num (0x20, 0x7e);
21112 rule_buf
[rule_pos
++] = (char) p2
;
21116 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21117 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21118 p1
= get_random_num (0, sizeof (grp_pos
));
21119 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21120 p2
= get_random_num (0, sizeof (grp_pos
));
21122 p2
= get_random_num (0, sizeof (grp_pos
));
21123 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21127 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21128 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21129 p1
= get_random_num (0, sizeof (grp_pos
));
21130 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21131 p2
= get_random_num (1, sizeof (grp_pos
));
21133 p2
= get_random_num (1, sizeof (grp_pos
));
21134 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21138 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21139 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21140 p1
= get_random_num (0, sizeof (grp_pos
));
21141 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21142 p2
= get_random_num (1, sizeof (grp_pos
));
21143 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21144 p3
= get_random_num (0, sizeof (grp_pos
));
21145 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21153 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21155 char mem
[BLOCK_SIZE
] = { 0 };
21157 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21159 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21161 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21163 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21165 int out_len
= in_len
;
21166 int mem_len
= in_len
;
21168 memcpy (out
, in
, out_len
);
21172 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21177 switch (rule
[rule_pos
])
21182 case RULE_OP_MANGLE_NOOP
:
21185 case RULE_OP_MANGLE_LREST
:
21186 out_len
= mangle_lrest (out
, out_len
);
21189 case RULE_OP_MANGLE_UREST
:
21190 out_len
= mangle_urest (out
, out_len
);
21193 case RULE_OP_MANGLE_LREST_UFIRST
:
21194 out_len
= mangle_lrest (out
, out_len
);
21195 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21198 case RULE_OP_MANGLE_UREST_LFIRST
:
21199 out_len
= mangle_urest (out
, out_len
);
21200 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21203 case RULE_OP_MANGLE_TREST
:
21204 out_len
= mangle_trest (out
, out_len
);
21207 case RULE_OP_MANGLE_TOGGLE_AT
:
21208 NEXT_RULEPOS (rule_pos
);
21209 NEXT_RPTOI (rule
, rule_pos
, upos
);
21210 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21213 case RULE_OP_MANGLE_REVERSE
:
21214 out_len
= mangle_reverse (out
, out_len
);
21217 case RULE_OP_MANGLE_DUPEWORD
:
21218 out_len
= mangle_double (out
, out_len
);
21221 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21222 NEXT_RULEPOS (rule_pos
);
21223 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21224 out_len
= mangle_double_times (out
, out_len
, ulen
);
21227 case RULE_OP_MANGLE_REFLECT
:
21228 out_len
= mangle_reflect (out
, out_len
);
21231 case RULE_OP_MANGLE_ROTATE_LEFT
:
21232 mangle_rotate_left (out
, out_len
);
21235 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21236 mangle_rotate_right (out
, out_len
);
21239 case RULE_OP_MANGLE_APPEND
:
21240 NEXT_RULEPOS (rule_pos
);
21241 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
21244 case RULE_OP_MANGLE_PREPEND
:
21245 NEXT_RULEPOS (rule_pos
);
21246 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
21249 case RULE_OP_MANGLE_DELETE_FIRST
:
21250 out_len
= mangle_delete_at (out
, out_len
, 0);
21253 case RULE_OP_MANGLE_DELETE_LAST
:
21254 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
21257 case RULE_OP_MANGLE_DELETE_AT
:
21258 NEXT_RULEPOS (rule_pos
);
21259 NEXT_RPTOI (rule
, rule_pos
, upos
);
21260 out_len
= mangle_delete_at (out
, out_len
, upos
);
21263 case RULE_OP_MANGLE_EXTRACT
:
21264 NEXT_RULEPOS (rule_pos
);
21265 NEXT_RPTOI (rule
, rule_pos
, upos
);
21266 NEXT_RULEPOS (rule_pos
);
21267 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21268 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
21271 case RULE_OP_MANGLE_OMIT
:
21272 NEXT_RULEPOS (rule_pos
);
21273 NEXT_RPTOI (rule
, rule_pos
, upos
);
21274 NEXT_RULEPOS (rule_pos
);
21275 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21276 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
21279 case RULE_OP_MANGLE_INSERT
:
21280 NEXT_RULEPOS (rule_pos
);
21281 NEXT_RPTOI (rule
, rule_pos
, upos
);
21282 NEXT_RULEPOS (rule_pos
);
21283 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
21286 case RULE_OP_MANGLE_OVERSTRIKE
:
21287 NEXT_RULEPOS (rule_pos
);
21288 NEXT_RPTOI (rule
, rule_pos
, upos
);
21289 NEXT_RULEPOS (rule_pos
);
21290 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
21293 case RULE_OP_MANGLE_TRUNCATE_AT
:
21294 NEXT_RULEPOS (rule_pos
);
21295 NEXT_RPTOI (rule
, rule_pos
, upos
);
21296 out_len
= mangle_truncate_at (out
, out_len
, upos
);
21299 case RULE_OP_MANGLE_REPLACE
:
21300 NEXT_RULEPOS (rule_pos
);
21301 NEXT_RULEPOS (rule_pos
);
21302 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
21305 case RULE_OP_MANGLE_PURGECHAR
:
21306 NEXT_RULEPOS (rule_pos
);
21307 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
21310 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21314 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21315 NEXT_RULEPOS (rule_pos
);
21316 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21317 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
21320 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21321 NEXT_RULEPOS (rule_pos
);
21322 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21323 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
21326 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21327 out_len
= mangle_dupechar (out
, out_len
);
21330 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21331 NEXT_RULEPOS (rule_pos
);
21332 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21333 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
21336 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21337 NEXT_RULEPOS (rule_pos
);
21338 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21339 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
21342 case RULE_OP_MANGLE_SWITCH_FIRST
:
21343 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
21346 case RULE_OP_MANGLE_SWITCH_LAST
:
21347 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
21350 case RULE_OP_MANGLE_SWITCH_AT
:
21351 NEXT_RULEPOS (rule_pos
);
21352 NEXT_RPTOI (rule
, rule_pos
, upos
);
21353 NEXT_RULEPOS (rule_pos
);
21354 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21355 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
21358 case RULE_OP_MANGLE_CHR_SHIFTL
:
21359 NEXT_RULEPOS (rule_pos
);
21360 NEXT_RPTOI (rule
, rule_pos
, upos
);
21361 mangle_chr_shiftl (out
, out_len
, upos
);
21364 case RULE_OP_MANGLE_CHR_SHIFTR
:
21365 NEXT_RULEPOS (rule_pos
);
21366 NEXT_RPTOI (rule
, rule_pos
, upos
);
21367 mangle_chr_shiftr (out
, out_len
, upos
);
21370 case RULE_OP_MANGLE_CHR_INCR
:
21371 NEXT_RULEPOS (rule_pos
);
21372 NEXT_RPTOI (rule
, rule_pos
, upos
);
21373 mangle_chr_incr (out
, out_len
, upos
);
21376 case RULE_OP_MANGLE_CHR_DECR
:
21377 NEXT_RULEPOS (rule_pos
);
21378 NEXT_RPTOI (rule
, rule_pos
, upos
);
21379 mangle_chr_decr (out
, out_len
, upos
);
21382 case RULE_OP_MANGLE_REPLACE_NP1
:
21383 NEXT_RULEPOS (rule_pos
);
21384 NEXT_RPTOI (rule
, rule_pos
, upos
);
21385 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
21388 case RULE_OP_MANGLE_REPLACE_NM1
:
21389 NEXT_RULEPOS (rule_pos
);
21390 NEXT_RPTOI (rule
, rule_pos
, upos
);
21391 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
21394 case RULE_OP_MANGLE_TITLE
:
21395 out_len
= mangle_title (out
, out_len
);
21398 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
21399 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21400 NEXT_RULEPOS (rule_pos
);
21401 NEXT_RPTOI (rule
, rule_pos
, upos
);
21402 NEXT_RULEPOS (rule_pos
);
21403 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21404 NEXT_RULEPOS (rule_pos
);
21405 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21406 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
21409 case RULE_OP_MANGLE_APPEND_MEMORY
:
21410 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21411 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21412 memcpy (out
+ out_len
, mem
, mem_len
);
21413 out_len
+= mem_len
;
21416 case RULE_OP_MANGLE_PREPEND_MEMORY
:
21417 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21418 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21419 memcpy (mem
+ mem_len
, out
, out_len
);
21420 out_len
+= mem_len
;
21421 memcpy (out
, mem
, out_len
);
21424 case RULE_OP_MEMORIZE_WORD
:
21425 memcpy (mem
, out
, out_len
);
21429 case RULE_OP_REJECT_LESS
:
21430 NEXT_RULEPOS (rule_pos
);
21431 NEXT_RPTOI (rule
, rule_pos
, upos
);
21432 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
21435 case RULE_OP_REJECT_GREATER
:
21436 NEXT_RULEPOS (rule_pos
);
21437 NEXT_RPTOI (rule
, rule_pos
, upos
);
21438 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
21441 case RULE_OP_REJECT_CONTAIN
:
21442 NEXT_RULEPOS (rule_pos
);
21443 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
21446 case RULE_OP_REJECT_NOT_CONTAIN
:
21447 NEXT_RULEPOS (rule_pos
);
21448 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
21451 case RULE_OP_REJECT_EQUAL_FIRST
:
21452 NEXT_RULEPOS (rule_pos
);
21453 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21456 case RULE_OP_REJECT_EQUAL_LAST
:
21457 NEXT_RULEPOS (rule_pos
);
21458 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21461 case RULE_OP_REJECT_EQUAL_AT
:
21462 NEXT_RULEPOS (rule_pos
);
21463 NEXT_RPTOI (rule
, rule_pos
, upos
);
21464 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
21465 NEXT_RULEPOS (rule_pos
);
21466 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21469 case RULE_OP_REJECT_CONTAINS
:
21470 NEXT_RULEPOS (rule_pos
);
21471 NEXT_RPTOI (rule
, rule_pos
, upos
);
21472 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
21473 NEXT_RULEPOS (rule_pos
);
21474 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
21475 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
21478 case RULE_OP_REJECT_MEMORY
:
21479 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
21483 return (RULE_RC_SYNTAX_ERROR
);
21488 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);