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
);
2676 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2680 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nv
, nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2684 log_info ("WARN: No NvAPI adapters found");
2694 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2698 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2700 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nv
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2702 // can be used to determine if the device by index matches the cuda device by index
2703 // char name[100]; memset (name, 0, sizeof (name));
2704 // hm_NVML_nvmlDeviceGetName (data.hm_nv, nvGPUHandle[i], name, sizeof (name) - 1);
2711 log_info ("WARN: No NVML adapters found");
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_get_supported
= 1;
2976 hm_device
[opencl_device_index
].fan_get_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_get_supported
= 1;
2995 hm_device
[opencl_device_index
].fan_get_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
;
3059 int hm_get_threshold_slowdown_with_device_id (const uint device_id
)
3061 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3063 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3067 if (data
.hm_device
[device_id
].od_version
== 5)
3071 else if (data
.hm_device
[device_id
].od_version
== 6)
3073 int CurrentValue
= 0;
3074 int DefaultValue
= 0;
3076 if (hm_ADL_Overdrive6_TargetTemperatureData_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &CurrentValue
, &DefaultValue
) != ADL_OK
) return -1;
3078 // the return value has never been tested since hm_ADL_Overdrive6_TargetTemperatureData_Get() never worked on any system. expect problems.
3080 return DefaultValue
;
3085 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3090 hm_NVML_nvmlDeviceGetTemperatureThreshold (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_THRESHOLD_SLOWDOWN
, (unsigned int *) &target
);
3103 int hm_get_temperature_with_device_id (const uint device_id
)
3105 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3107 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3111 if (data
.hm_device
[device_id
].od_version
== 5)
3113 ADLTemperature Temperature
;
3115 Temperature
.iSize
= sizeof (ADLTemperature
);
3117 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3119 return Temperature
.iTemperature
/ 1000;
3121 else if (data
.hm_device
[device_id
].od_version
== 6)
3123 int Temperature
= 0;
3125 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3127 return Temperature
/ 1000;
3132 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3135 int temperature
= 0;
3137 hm_NVML_nvmlDeviceGetTemperature (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
);
3143 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3145 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3146 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3147 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3148 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3150 if (hm_NvAPI_GPU_GetThermalSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3152 return pThermalSettings
.sensor
[0].currentTemp
;
3159 int hm_get_fanpolicy_with_device_id (const uint device_id
)
3161 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3163 if (data
.hm_device
[device_id
].fan_get_supported
== 1)
3165 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3169 if (data
.hm_device
[device_id
].od_version
== 5)
3171 ADLFanSpeedValue lpFanSpeedValue
;
3173 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3175 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3176 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3178 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3180 return (lpFanSpeedValue
.iFanSpeed
& ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
) ? 0 : 1;
3182 else // od_version == 6
3189 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3204 int hm_get_fanspeed_with_device_id (const uint device_id
)
3206 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3208 if (data
.hm_device
[device_id
].fan_get_supported
== 1)
3210 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3214 if (data
.hm_device
[device_id
].od_version
== 5)
3216 ADLFanSpeedValue lpFanSpeedValue
;
3218 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3220 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3221 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3222 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3224 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3226 return lpFanSpeedValue
.iFanSpeed
;
3228 else // od_version == 6
3230 ADLOD6FanSpeedInfo faninfo
;
3232 memset (&faninfo
, 0, sizeof (faninfo
));
3234 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3236 return faninfo
.iFanSpeedPercent
;
3241 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3246 hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (uint
*) &speed
);
3252 NV_GPU_COOLER_SETTINGS pCoolerSettings
;
3254 pCoolerSettings
.Version
= GPU_COOLER_SETTINGS_VER
| sizeof (NV_GPU_COOLER_SETTINGS
);
3256 if (hm_NvAPI_GPU_GetCoolerSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pCoolerSettings
) != NVAPI_OK
) return -1;
3258 return pCoolerSettings
.Cooler
[0].CurrentLevel
;
3266 int hm_get_buslanes_with_device_id (const uint device_id
)
3268 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3270 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3274 ADLPMActivity PMActivity
;
3276 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3278 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3280 return PMActivity
.iCurrentBusLanes
;
3284 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3287 unsigned int currLinkWidth
;
3289 hm_NVML_nvmlDeviceGetCurrPcieLinkWidth (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &currLinkWidth
);
3291 return currLinkWidth
;
3297 if (hm_NvAPI_GPU_GetCurrentPCIEDownstreamWidth (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, (NvU32
*) &Width
) != NVAPI_OK
) return -1;
3306 int hm_get_utilization_with_device_id (const uint device_id
)
3308 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3310 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3314 ADLPMActivity PMActivity
;
3316 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3318 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3320 return PMActivity
.iActivityPercent
;
3324 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3327 nvmlUtilization_t utilization
;
3329 hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3331 return utilization
.gpu
;
3335 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3337 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3339 if (hm_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3341 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3348 int hm_get_memoryspeed_with_device_id (const uint device_id
)
3350 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3352 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3356 ADLPMActivity PMActivity
;
3358 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3360 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3362 return PMActivity
.iMemoryClock
/ 100;
3366 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3371 hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_CLOCK_MEM
, &clock
);
3377 NV_GPU_CLOCK_FREQUENCIES pClkFreqs
= { 0 };
3379 pClkFreqs
.version
= NV_GPU_CLOCK_FREQUENCIES_VER
;
3380 pClkFreqs
.ClockType
= NV_GPU_CLOCK_FREQUENCIES_CURRENT_FREQ
;
3382 if (hm_NvAPI_GPU_GetAllClockFrequencies (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pClkFreqs
) != NVAPI_OK
) return -1;
3384 return pClkFreqs
.domain
[NVAPI_GPU_PUBLIC_CLOCK_MEMORY
].frequency
/ 1000;
3391 int hm_get_corespeed_with_device_id (const uint device_id
)
3393 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3395 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3399 ADLPMActivity PMActivity
;
3401 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3403 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3405 return PMActivity
.iEngineClock
/ 100;
3409 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3414 hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_CLOCK_SM
, &clock
);
3420 NV_GPU_CLOCK_FREQUENCIES pClkFreqs
= { 0 };
3422 pClkFreqs
.version
= NV_GPU_CLOCK_FREQUENCIES_VER
;
3423 pClkFreqs
.ClockType
= NV_GPU_CLOCK_FREQUENCIES_CURRENT_FREQ
;
3425 if (hm_NvAPI_GPU_GetAllClockFrequencies (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pClkFreqs
) != NVAPI_OK
) return -1;
3427 return pClkFreqs
.domain
[NVAPI_GPU_PUBLIC_CLOCK_GRAPHICS
].frequency
/ 1000;
3434 int hm_get_throttle_with_device_id (const uint device_id
)
3436 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3438 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3443 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3452 if (hm_NvAPI_GPU_GetPerfDecreaseInfo (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &throttle
) != NVAPI_OK
) return -1;
3461 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
, const int fanpolicy
)
3463 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3467 if (data
.hm_device
[device_id
].od_version
== 5)
3469 ADLFanSpeedValue lpFanSpeedValue
;
3471 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3473 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3474 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3475 lpFanSpeedValue
.iFlags
= (fanpolicy
== 1) ? ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
: 0;
3476 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3478 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3482 else // od_version == 6
3484 ADLOD6FanSpeedValue fan_speed_value
;
3486 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3488 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3489 fan_speed_value
.iFanSpeed
= fanspeed
;
3491 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3502 int hm_set_fanspeed_with_device_id_nvapi (const uint device_id
, const int fanspeed
, const int fanpolicy
)
3504 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3508 NV_GPU_COOLER_LEVELS CoolerLevels
= { 0 };
3510 CoolerLevels
.Version
= GPU_COOLER_LEVELS_VER
| sizeof (NV_GPU_COOLER_LEVELS
);
3512 CoolerLevels
.Levels
[0].Level
= fanspeed
;
3513 CoolerLevels
.Levels
[0].Policy
= fanpolicy
;
3515 if (hm_NvAPI_GPU_SetCoolerLevels (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &CoolerLevels
) != NVAPI_OK
) return -1;
3526 int hm_set_fanspeed_with_device_id_nvml (const uint device_id
, const int fanspeed
, const int fanpolicy
)
3528 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3532 // NVML does not support setting the fan speed... :((
3534 if (fanspeed
== fanpolicy
) return -1; // makes the compiler happy
3542 #endif // HAVE_HWMON
3548 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3550 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3552 if (css_cnt
> SP_PW_MAX
)
3554 log_error ("ERROR: mask length is too long");
3559 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3561 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3563 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3564 uint cs_len
= css
[css_pos
].cs_len
;
3566 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3568 uint c
= cs_buf
[cs_pos
] & 0xff;
3575 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3577 cs_t
*cs
= &css
[css_cnt
];
3579 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3581 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3585 for (i
= 0; i
< cs
->cs_len
; i
++)
3587 const uint u
= cs
->cs_buf
[i
];
3592 for (i
= 0; i
< in_len
; i
++)
3594 uint u
= in_buf
[i
] & 0xff;
3596 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3598 if (css_uniq
[u
] == 1) continue;
3602 cs
->cs_buf
[cs
->cs_len
] = u
;
3610 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3614 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3616 uint p0
= in_buf
[in_pos
] & 0xff;
3618 if (interpret
== 1 && p0
== '?')
3622 if (in_pos
== in_len
) break;
3624 uint p1
= in_buf
[in_pos
] & 0xff;
3628 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3630 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3632 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3634 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3636 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3638 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3640 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3641 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3643 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3644 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3646 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3647 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3649 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3650 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3652 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3654 default: log_error ("Syntax error: %s", in_buf
);
3660 if (data
.hex_charset
)
3664 if (in_pos
== in_len
)
3666 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3671 uint p1
= in_buf
[in_pos
] & 0xff;
3673 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3675 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3682 chr
= hex_convert (p1
) << 0;
3683 chr
|= hex_convert (p0
) << 4;
3685 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3691 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3697 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3701 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3703 sum
*= css
[css_pos
].cs_len
;
3709 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3711 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3716 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3718 char p0
= mask_buf
[mask_pos
];
3724 if (mask_pos
== mask_len
) break;
3726 char p1
= mask_buf
[mask_pos
];
3732 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3734 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3736 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3738 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3740 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3742 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3744 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3745 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3747 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3748 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3750 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3751 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3753 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3754 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3756 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3758 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3764 if (data
.hex_charset
)
3768 // if there is no 2nd hex character, show an error:
3770 if (mask_pos
== mask_len
)
3772 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3777 char p1
= mask_buf
[mask_pos
];
3779 // if they are not valid hex character, show an error:
3781 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3783 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3790 chr
|= hex_convert (p1
) << 0;
3791 chr
|= hex_convert (p0
) << 4;
3793 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3799 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3806 log_error ("ERROR: invalid mask length (0)");
3816 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3818 for (int i
= 0; i
< css_cnt
; i
++)
3820 uint len
= css
[i
].cs_len
;
3821 u64 next
= val
/ len
;
3822 uint pos
= val
% len
;
3823 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3828 void mp_cut_at (char *mask
, uint max
)
3832 uint mask_len
= strlen (mask
);
3834 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3836 if (mask
[i
] == '?') i
++;
3842 void mp_setup_sys (cs_t
*mp_sys
)
3846 uint donec
[CHARSIZ
] = { 0 };
3848 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3849 mp_sys
[0].cs_buf
[pos
++] = chr
;
3850 mp_sys
[0].cs_len
= pos
; }
3852 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3853 mp_sys
[1].cs_buf
[pos
++] = chr
;
3854 mp_sys
[1].cs_len
= pos
; }
3856 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3857 mp_sys
[2].cs_buf
[pos
++] = chr
;
3858 mp_sys
[2].cs_len
= pos
; }
3860 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3861 mp_sys
[3].cs_buf
[pos
++] = chr
;
3862 mp_sys
[3].cs_len
= pos
; }
3864 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3865 mp_sys
[4].cs_len
= pos
; }
3867 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3868 mp_sys
[5].cs_len
= pos
; }
3871 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3873 FILE *fp
= fopen (buf
, "rb");
3875 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3877 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3881 char mp_file
[1024] = { 0 };
3883 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3887 len
= in_superchop (mp_file
);
3891 log_info ("WARNING: charset file corrupted");
3893 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3897 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3902 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3904 mp_usr
[index
].cs_len
= 0;
3906 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3909 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3911 char *new_mask_buf
= (char *) mymalloc (256);
3917 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3919 if (css_pos
== len
) break;
3921 char p0
= mask_buf
[mask_pos
];
3923 new_mask_buf
[mask_pos
] = p0
;
3929 if (mask_pos
== mask_len
) break;
3931 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3935 if (data
.hex_charset
)
3939 if (mask_pos
== mask_len
)
3941 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3946 char p1
= mask_buf
[mask_pos
];
3948 // if they are not valid hex character, show an error:
3950 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3952 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3957 new_mask_buf
[mask_pos
] = p1
;
3962 if (css_pos
== len
) return (new_mask_buf
);
3964 myfree (new_mask_buf
);
3973 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3979 for (i
= start
; i
< stop
; i
++)
3981 sum
*= root_css_buf
[i
].cs_len
;
3987 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3991 cs_t
*cs
= &root_css_buf
[start
];
3995 for (i
= start
; i
< stop
; i
++)
3997 const u64 m
= v
% cs
->cs_len
;
3998 const u64 d
= v
/ cs
->cs_len
;
4002 const uint k
= cs
->cs_buf
[m
];
4004 pw_buf
[i
- start
] = (char) k
;
4006 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
4010 int sp_comp_val (const void *p1
, const void *p2
)
4012 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
4013 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
4015 return b2
->val
- b1
->val
;
4018 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
)
4025 * Initialize hcstats
4028 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
4030 u64
*root_stats_ptr
= root_stats_buf
;
4032 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
4034 for (i
= 0; i
< SP_PW_MAX
; i
++)
4036 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
4038 root_stats_ptr
+= CHARSIZ
;
4041 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
4043 u64
*markov_stats_ptr
= markov_stats_buf
;
4045 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4047 for (i
= 0; i
< SP_PW_MAX
; i
++)
4049 for (j
= 0; j
< CHARSIZ
; j
++)
4051 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
4053 markov_stats_ptr
+= CHARSIZ
;
4063 char hcstat_tmp
[256] = { 0 };
4065 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
4067 hcstat
= hcstat_tmp
;
4070 FILE *fd
= fopen (hcstat
, "rb");
4074 log_error ("%s: %s", hcstat
, strerror (errno
));
4079 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
4081 log_error ("%s: Could not load data", hcstat
);
4088 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
4090 log_error ("%s: Could not load data", hcstat
);
4100 * Markov modifier of hcstat_table on user request
4105 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
4106 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
4111 /* Add all stats to first position */
4113 for (i
= 1; i
< SP_PW_MAX
; i
++)
4115 u64
*out
= root_stats_buf_by_pos
[0];
4116 u64
*in
= root_stats_buf_by_pos
[i
];
4118 for (j
= 0; j
< CHARSIZ
; j
++)
4124 for (i
= 1; i
< SP_PW_MAX
; i
++)
4126 u64
*out
= markov_stats_buf_by_key
[0][0];
4127 u64
*in
= markov_stats_buf_by_key
[i
][0];
4129 for (j
= 0; j
< CHARSIZ
; j
++)
4131 for (k
= 0; k
< CHARSIZ
; k
++)
4138 /* copy them to all pw_positions */
4140 for (i
= 1; i
< SP_PW_MAX
; i
++)
4142 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
4145 for (i
= 1; i
< SP_PW_MAX
; i
++)
4147 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
4155 hcstat_table_t
*root_table_ptr
= root_table_buf
;
4157 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
4159 for (i
= 0; i
< SP_PW_MAX
; i
++)
4161 root_table_buf_by_pos
[i
] = root_table_ptr
;
4163 root_table_ptr
+= CHARSIZ
;
4166 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
4168 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4170 for (i
= 0; i
< SP_PW_MAX
; i
++)
4172 for (j
= 0; j
< CHARSIZ
; j
++)
4174 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
4176 markov_table_ptr
+= CHARSIZ
;
4181 * Convert hcstat to tables
4184 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
4186 uint key
= i
% CHARSIZ
;
4188 root_table_buf
[i
].key
= key
;
4189 root_table_buf
[i
].val
= root_stats_buf
[i
];
4192 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
4194 uint key
= i
% CHARSIZ
;
4196 markov_table_buf
[i
].key
= key
;
4197 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
4200 myfree (root_stats_buf
);
4201 myfree (markov_stats_buf
);
4207 for (i
= 0; i
< SP_PW_MAX
; i
++)
4209 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4212 for (i
= 0; i
< SP_PW_MAX
; i
++)
4214 for (j
= 0; j
< CHARSIZ
; j
++)
4216 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4221 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
])
4224 * Convert tables to css
4227 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
4229 uint pw_pos
= i
/ CHARSIZ
;
4231 cs_t
*cs
= &root_css_buf
[pw_pos
];
4233 if (cs
->cs_len
== threshold
) continue;
4235 uint key
= root_table_buf
[i
].key
;
4237 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
4239 cs
->cs_buf
[cs
->cs_len
] = key
;
4245 * Convert table to css
4248 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4250 uint c
= i
/ CHARSIZ
;
4252 cs_t
*cs
= &markov_css_buf
[c
];
4254 if (cs
->cs_len
== threshold
) continue;
4256 uint pw_pos
= c
/ CHARSIZ
;
4258 uint key
= markov_table_buf
[i
].key
;
4260 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4262 cs
->cs_buf
[cs
->cs_len
] = key
;
4268 for (uint i = 0; i < 8; i++)
4270 for (uint j = 0x20; j < 0x80; j++)
4272 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4274 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4276 for (uint k = 0; k < 10; k++)
4278 printf (" %u\n", ptr->cs_buf[k]);
4285 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4287 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4289 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4299 for (uint j
= 1; j
< CHARSIZ
; j
++)
4309 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4311 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4313 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4315 out
+= CHARSIZ
* CHARSIZ
;
4316 in
+= CHARSIZ
* CHARSIZ
;
4318 for (uint j
= 0; j
< CHARSIZ
; j
++)
4325 for (uint k
= 1; k
< CHARSIZ
; k
++)
4337 * mixed shared functions
4340 void dump_hex (const u8
*s
, const int sz
)
4342 for (int i
= 0; i
< sz
; i
++)
4344 log_info_nn ("%02x ", s
[i
]);
4350 void usage_mini_print (const char *progname
)
4352 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4355 void usage_big_print (const char *progname
)
4357 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4360 char *get_exec_path ()
4362 int exec_path_len
= 1024;
4364 char *exec_path
= (char *) mymalloc (exec_path_len
);
4368 char tmp
[32] = { 0 };
4370 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4372 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4376 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4380 uint size
= exec_path_len
;
4382 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4384 log_error("! executable path buffer too small\n");
4389 const int len
= strlen (exec_path
);
4392 #error Your Operating System is not supported or detected
4400 char *get_install_dir (const char *progname
)
4402 char *install_dir
= mystrdup (progname
);
4403 char *last_slash
= NULL
;
4405 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4409 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4415 install_dir
[0] = '.';
4419 return (install_dir
);
4422 char *get_profile_dir (const char *homedir
)
4424 #define DOT_HASHCAT ".hashcat"
4426 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4428 char *profile_dir
= (char *) mymalloc (len
+ 1);
4430 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4435 char *get_session_dir (const char *profile_dir
)
4437 #define SESSIONS_FOLDER "sessions"
4439 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4441 char *session_dir
= (char *) mymalloc (len
+ 1);
4443 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4448 uint
count_lines (FILE *fd
)
4452 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4458 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4460 if (nread
< 1) continue;
4464 for (i
= 0; i
< nread
; i
++)
4466 if (prev
== '\n') cnt
++;
4477 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4481 FILE *fd
= fopen (filename
, "rb");
4485 log_error ("%s: %s", filename
, strerror (errno
));
4490 #define MAX_KEY_SIZE (1024 * 1024)
4492 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4494 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4500 for (int fpos
= 0; fpos
< nread
; fpos
++)
4502 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4504 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4505 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4506 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4507 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4509 if (kpos
>= 64) kpos
= 0;
4516 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4520 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4521 if (CPU_ISSET(core
, cpu_set
)) break;
4523 thread_affinity_policy_data_t policy
= { core
};
4525 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4527 if (data
.quiet
== 0)
4529 if (rc
!= KERN_SUCCESS
)
4531 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4539 void set_cpu_affinity (char *cpu_affinity
)
4542 DWORD_PTR aff_mask
= 0;
4550 char *devices
= strdup (cpu_affinity
);
4552 char *next
= strtok (devices
, ",");
4556 uint cpu_id
= atoi (next
);
4571 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4577 aff_mask
|= 1 << (cpu_id
- 1);
4579 CPU_SET ((cpu_id
- 1), &cpuset
);
4582 } while ((next
= strtok (NULL
, ",")) != NULL
);
4588 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4589 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4591 pthread_t thread
= pthread_self ();
4592 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4596 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4598 char *element
, *end
;
4600 end
= (char *) base
+ nmemb
* size
;
4602 for (element
= (char *) base
; element
< end
; element
+= size
)
4603 if (!compar (element
, key
))
4609 int sort_by_u32 (const void *v1
, const void *v2
)
4611 const u32
*s1
= (const u32
*) v1
;
4612 const u32
*s2
= (const u32
*) v2
;
4617 int sort_by_salt (const void *v1
, const void *v2
)
4619 const salt_t
*s1
= (const salt_t
*) v1
;
4620 const salt_t
*s2
= (const salt_t
*) v2
;
4622 const int res1
= s1
->salt_len
- s2
->salt_len
;
4624 if (res1
!= 0) return (res1
);
4626 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4628 if (res2
!= 0) return (res2
);
4636 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4637 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4644 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4645 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4651 int sort_by_salt_buf (const void *v1
, const void *v2
)
4653 const pot_t
*p1
= (const pot_t
*) v1
;
4654 const pot_t
*p2
= (const pot_t
*) v2
;
4656 const hash_t
*h1
= &p1
->hash
;
4657 const hash_t
*h2
= &p2
->hash
;
4659 const salt_t
*s1
= h1
->salt
;
4660 const salt_t
*s2
= h2
->salt
;
4666 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4667 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4673 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4675 const hash_t
*h1
= (const hash_t
*) v1
;
4676 const hash_t
*h2
= (const hash_t
*) v2
;
4678 const salt_t
*s1
= h1
->salt
;
4679 const salt_t
*s2
= h2
->salt
;
4681 // testphase: this should work
4686 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4687 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4690 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4691 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4692 if (s1->salt_len > s2->salt_len) return ( 1);
4693 if (s1->salt_len < s2->salt_len) return (-1);
4695 uint n = s1->salt_len;
4699 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4700 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4707 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4709 const hash_t
*h1
= (const hash_t
*) v1
;
4710 const hash_t
*h2
= (const hash_t
*) v2
;
4712 const salt_t
*s1
= h1
->salt
;
4713 const salt_t
*s2
= h2
->salt
;
4715 // 16 - 2 (since last 2 uints contain the digest)
4720 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4721 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4727 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4729 const hash_t
*h1
= (const hash_t
*) v1
;
4730 const hash_t
*h2
= (const hash_t
*) v2
;
4732 const void *d1
= h1
->digest
;
4733 const void *d2
= h2
->digest
;
4735 return data
.sort_by_digest (d1
, d2
);
4738 int sort_by_hash (const void *v1
, const void *v2
)
4740 const hash_t
*h1
= (const hash_t
*) v1
;
4741 const hash_t
*h2
= (const hash_t
*) v2
;
4745 const salt_t
*s1
= h1
->salt
;
4746 const salt_t
*s2
= h2
->salt
;
4748 int res
= sort_by_salt (s1
, s2
);
4750 if (res
!= 0) return (res
);
4753 const void *d1
= h1
->digest
;
4754 const void *d2
= h2
->digest
;
4756 return data
.sort_by_digest (d1
, d2
);
4759 int sort_by_pot (const void *v1
, const void *v2
)
4761 const pot_t
*p1
= (const pot_t
*) v1
;
4762 const pot_t
*p2
= (const pot_t
*) v2
;
4764 const hash_t
*h1
= &p1
->hash
;
4765 const hash_t
*h2
= &p2
->hash
;
4767 return sort_by_hash (h1
, h2
);
4770 int sort_by_mtime (const void *p1
, const void *p2
)
4772 const char **f1
= (const char **) p1
;
4773 const char **f2
= (const char **) p2
;
4775 struct stat s1
; stat (*f1
, &s1
);
4776 struct stat s2
; stat (*f2
, &s2
);
4778 return s2
.st_mtime
- s1
.st_mtime
;
4781 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4783 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4784 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4786 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4789 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4791 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4792 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4794 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4797 int sort_by_stringptr (const void *p1
, const void *p2
)
4799 const char **s1
= (const char **) p1
;
4800 const char **s2
= (const char **) p2
;
4802 return strcmp (*s1
, *s2
);
4805 int sort_by_dictstat (const void *s1
, const void *s2
)
4807 dictstat_t
*d1
= (dictstat_t
*) s1
;
4808 dictstat_t
*d2
= (dictstat_t
*) s2
;
4811 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4813 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4816 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4819 int sort_by_bitmap (const void *p1
, const void *p2
)
4821 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4822 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4824 return b1
->collisions
- b2
->collisions
;
4827 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4829 const u32
*d1
= (const u32
*) v1
;
4830 const u32
*d2
= (const u32
*) v2
;
4836 if (d1
[n
] > d2
[n
]) return ( 1);
4837 if (d1
[n
] < d2
[n
]) return (-1);
4843 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4845 const u32
*d1
= (const u32
*) v1
;
4846 const u32
*d2
= (const u32
*) v2
;
4852 if (d1
[n
] > d2
[n
]) return ( 1);
4853 if (d1
[n
] < d2
[n
]) return (-1);
4859 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4861 const u32
*d1
= (const u32
*) v1
;
4862 const u32
*d2
= (const u32
*) v2
;
4868 if (d1
[n
] > d2
[n
]) return ( 1);
4869 if (d1
[n
] < d2
[n
]) return (-1);
4875 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4877 const u32
*d1
= (const u32
*) v1
;
4878 const u32
*d2
= (const u32
*) v2
;
4884 if (d1
[n
] > d2
[n
]) return ( 1);
4885 if (d1
[n
] < d2
[n
]) return (-1);
4891 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4893 const u32
*d1
= (const u32
*) v1
;
4894 const u32
*d2
= (const u32
*) v2
;
4900 if (d1
[n
] > d2
[n
]) return ( 1);
4901 if (d1
[n
] < d2
[n
]) return (-1);
4907 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4909 const u32
*d1
= (const u32
*) v1
;
4910 const u32
*d2
= (const u32
*) v2
;
4916 if (d1
[n
] > d2
[n
]) return ( 1);
4917 if (d1
[n
] < d2
[n
]) return (-1);
4923 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4925 const u32
*d1
= (const u32
*) v1
;
4926 const u32
*d2
= (const u32
*) v2
;
4932 if (d1
[n
] > d2
[n
]) return ( 1);
4933 if (d1
[n
] < d2
[n
]) return (-1);
4939 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4941 const u32
*d1
= (const u32
*) v1
;
4942 const u32
*d2
= (const u32
*) v2
;
4948 if (d1
[n
] > d2
[n
]) return ( 1);
4949 if (d1
[n
] < d2
[n
]) return (-1);
4955 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4957 const u64
*d1
= (const u64
*) v1
;
4958 const u64
*d2
= (const u64
*) v2
;
4964 if (d1
[n
] > d2
[n
]) return ( 1);
4965 if (d1
[n
] < d2
[n
]) return (-1);
4971 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4973 const u64
*d1
= (const u64
*) v1
;
4974 const u64
*d2
= (const u64
*) v2
;
4980 if (d1
[n
] > d2
[n
]) return ( 1);
4981 if (d1
[n
] < d2
[n
]) return (-1);
4987 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4989 const u64
*d1
= (const u64
*) v1
;
4990 const u64
*d2
= (const u64
*) v2
;
4996 if (d1
[n
] > d2
[n
]) return ( 1);
4997 if (d1
[n
] < d2
[n
]) return (-1);
5003 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
5005 const u32
*d1
= (const u32
*) v1
;
5006 const u32
*d2
= (const u32
*) v2
;
5008 const uint dgst_pos0
= data
.dgst_pos0
;
5009 const uint dgst_pos1
= data
.dgst_pos1
;
5010 const uint dgst_pos2
= data
.dgst_pos2
;
5011 const uint dgst_pos3
= data
.dgst_pos3
;
5013 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
5014 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
5015 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
5016 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
5017 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
5018 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
5019 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
5020 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
5025 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
5027 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
5028 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
5030 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
5032 if (res1
!= 0) return (res1
);
5037 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
5039 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
5040 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
5042 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
5044 if (res1
!= 0) return (res1
);
5046 const int res2
= t1
->attack_mode
5049 if (res2
!= 0) return (res2
);
5051 const int res3
= t1
->hash_type
5054 if (res3
!= 0) return (res3
);
5059 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
)
5061 uint outfile_autohex
= data
.outfile_autohex
;
5063 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
5065 FILE *debug_fp
= NULL
;
5067 if (debug_file
!= NULL
)
5069 debug_fp
= fopen (debug_file
, "ab");
5071 lock_file (debug_fp
);
5078 if (debug_fp
== NULL
)
5080 log_info ("WARNING: Could not open debug-file for writing");
5084 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
5086 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
5088 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
5091 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
5093 if (debug_mode
== 4)
5095 fputc (':', debug_fp
);
5097 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
5100 fputc ('\n', debug_fp
);
5102 if (debug_file
!= NULL
) fclose (debug_fp
);
5106 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
5108 int needs_hexify
= 0;
5110 if (outfile_autohex
== 1)
5112 for (uint i
= 0; i
< plain_len
; i
++)
5114 if (plain_ptr
[i
] < 0x20)
5121 if (plain_ptr
[i
] > 0x7f)
5130 if (needs_hexify
== 1)
5132 fprintf (fp
, "$HEX[");
5134 for (uint i
= 0; i
< plain_len
; i
++)
5136 fprintf (fp
, "%02x", plain_ptr
[i
]);
5143 fwrite (plain_ptr
, plain_len
, 1, fp
);
5147 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
)
5149 uint outfile_format
= data
.outfile_format
;
5151 char separator
= data
.separator
;
5153 if (outfile_format
& OUTFILE_FMT_HASH
)
5155 fprintf (out_fp
, "%s", out_buf
);
5157 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5159 fputc (separator
, out_fp
);
5162 else if (data
.username
)
5164 if (username
!= NULL
)
5166 for (uint i
= 0; i
< user_len
; i
++)
5168 fprintf (out_fp
, "%c", username
[i
]);
5171 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5173 fputc (separator
, out_fp
);
5178 if (outfile_format
& OUTFILE_FMT_PLAIN
)
5180 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
5182 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5184 fputc (separator
, out_fp
);
5188 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
5190 for (uint i
= 0; i
< plain_len
; i
++)
5192 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
5195 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
5197 fputc (separator
, out_fp
);
5201 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
5204 __mingw_fprintf (out_fp
, "%llu", crackpos
);
5209 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
5211 fprintf (out_fp
, "%llu", crackpos
);
5216 fputc ('\n', out_fp
);
5219 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
)
5223 pot_key
.hash
.salt
= hashes_buf
->salt
;
5224 pot_key
.hash
.digest
= hashes_buf
->digest
;
5226 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5232 input_buf
[input_len
] = 0;
5235 unsigned char *username
= NULL
;
5240 user_t
*user
= hashes_buf
->hash_info
->user
;
5244 username
= (unsigned char *) (user
->user_name
);
5246 user_len
= user
->user_len
;
5250 // do output the line
5251 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5255 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5256 #define LM_MASKED_PLAIN "[notfound]"
5258 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
)
5264 pot_left_key
.hash
.salt
= hash_left
->salt
;
5265 pot_left_key
.hash
.digest
= hash_left
->digest
;
5267 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5271 uint weak_hash_found
= 0;
5273 pot_t pot_right_key
;
5275 pot_right_key
.hash
.salt
= hash_right
->salt
;
5276 pot_right_key
.hash
.digest
= hash_right
->digest
;
5278 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5280 if (pot_right_ptr
== NULL
)
5282 // special case, if "weak hash"
5284 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5286 weak_hash_found
= 1;
5288 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5290 // in theory this is not needed, but we are paranoia:
5292 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5293 pot_right_ptr
->plain_len
= 0;
5297 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5299 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
5304 // at least one half was found:
5308 input_buf
[input_len
] = 0;
5312 unsigned char *username
= NULL
;
5317 user_t
*user
= hash_left
->hash_info
->user
;
5321 username
= (unsigned char *) (user
->user_name
);
5323 user_len
= user
->user_len
;
5327 // mask the part which was not found
5329 uint left_part_masked
= 0;
5330 uint right_part_masked
= 0;
5332 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5334 if (pot_left_ptr
== NULL
)
5336 left_part_masked
= 1;
5338 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5340 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5342 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5343 pot_left_ptr
->plain_len
= mask_plain_len
;
5346 if (pot_right_ptr
== NULL
)
5348 right_part_masked
= 1;
5350 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5352 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5354 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5355 pot_right_ptr
->plain_len
= mask_plain_len
;
5358 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5362 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5364 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5366 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5368 // do output the line
5370 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5372 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5374 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5375 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5378 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
)
5382 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5384 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5386 if (pot_ptr
== NULL
)
5390 input_buf
[input_len
] = 0;
5392 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5396 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
)
5402 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5404 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5408 pot_t pot_right_key
;
5410 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5412 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5414 uint weak_hash_found
= 0;
5416 if (pot_right_ptr
== NULL
)
5418 // special case, if "weak hash"
5420 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5422 weak_hash_found
= 1;
5424 // we just need that pot_right_ptr is not a NULL pointer
5426 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5430 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5432 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5437 // ... at least one part was not cracked
5441 input_buf
[input_len
] = 0;
5443 // only show the hash part which is still not cracked
5445 uint user_len
= input_len
- 32;
5447 char *hash_output
= (char *) mymalloc (33);
5449 memcpy (hash_output
, input_buf
, input_len
);
5451 if (pot_left_ptr
!= NULL
)
5453 // only show right part (because left part was already found)
5455 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5457 hash_output
[user_len
+ 16] = 0;
5460 if (pot_right_ptr
!= NULL
)
5462 // only show left part (because right part was already found)
5464 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5466 hash_output
[user_len
+ 16] = 0;
5469 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5471 myfree (hash_output
);
5473 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5476 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5478 uint opencl_platforms_filter
= 0;
5480 if (opencl_platforms
)
5482 char *platforms
= strdup (opencl_platforms
);
5484 char *next
= strtok (platforms
, ",");
5488 int platform
= atoi (next
);
5490 if (platform
< 1 || platform
> 32)
5492 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5497 opencl_platforms_filter
|= 1 << (platform
- 1);
5499 } while ((next
= strtok (NULL
, ",")) != NULL
);
5505 opencl_platforms_filter
= -1;
5508 return opencl_platforms_filter
;
5511 u32
setup_devices_filter (char *opencl_devices
)
5513 u32 devices_filter
= 0;
5517 char *devices
= strdup (opencl_devices
);
5519 char *next
= strtok (devices
, ",");
5523 int device_id
= atoi (next
);
5525 if (device_id
< 1 || device_id
> 32)
5527 log_error ("ERROR: invalid device_id %u specified", device_id
);
5532 devices_filter
|= 1 << (device_id
- 1);
5534 } while ((next
= strtok (NULL
, ",")) != NULL
);
5540 devices_filter
= -1;
5543 return devices_filter
;
5546 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5548 cl_device_type device_types_filter
= 0;
5550 if (opencl_device_types
)
5552 char *device_types
= strdup (opencl_device_types
);
5554 char *next
= strtok (device_types
, ",");
5558 int device_type
= atoi (next
);
5560 if (device_type
< 1 || device_type
> 3)
5562 log_error ("ERROR: invalid device_type %u specified", device_type
);
5567 device_types_filter
|= 1 << device_type
;
5569 } while ((next
= strtok (NULL
, ",")) != NULL
);
5571 free (device_types
);
5575 // Do not use CPU by default, this often reduces GPU performance because
5576 // the CPU is too busy to handle GPU synchronization
5578 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5581 return device_types_filter
;
5584 u32
get_random_num (const u32 min
, const u32 max
)
5586 if (min
== max
) return (min
);
5588 return ((rand () % (max
- min
)) + min
);
5591 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5593 u32 quotient
= dividend
/ divisor
;
5595 if (dividend
% divisor
) quotient
++;
5600 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5602 u64 quotient
= dividend
/ divisor
;
5604 if (dividend
% divisor
) quotient
++;
5609 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5611 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5612 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5614 if (tm
->tm_year
- 70)
5616 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5617 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5619 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5621 else if (tm
->tm_yday
)
5623 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5624 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5626 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5628 else if (tm
->tm_hour
)
5630 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5631 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5633 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5635 else if (tm
->tm_min
)
5637 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5638 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5640 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5644 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5646 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5650 void format_speed_display (float val
, char *buf
, size_t len
)
5661 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5672 /* generate output */
5676 snprintf (buf
, len
- 1, "%.0f ", val
);
5680 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5684 void lowercase (u8
*buf
, int len
)
5686 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5689 void uppercase (u8
*buf
, int len
)
5691 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5694 int fgetl (FILE *fp
, char *line_buf
)
5700 const int c
= fgetc (fp
);
5702 if (c
== EOF
) break;
5704 line_buf
[line_len
] = (char) c
;
5708 if (line_len
== HCBUFSIZ
) line_len
--;
5710 if (c
== '\n') break;
5713 if (line_len
== 0) return 0;
5715 if (line_buf
[line_len
- 1] == '\n')
5719 line_buf
[line_len
] = 0;
5722 if (line_len
== 0) return 0;
5724 if (line_buf
[line_len
- 1] == '\r')
5728 line_buf
[line_len
] = 0;
5734 int in_superchop (char *buf
)
5736 int len
= strlen (buf
);
5740 if (buf
[len
- 1] == '\n')
5747 if (buf
[len
- 1] == '\r')
5762 char **scan_directory (const char *path
)
5764 char *tmp_path
= mystrdup (path
);
5766 size_t tmp_path_len
= strlen (tmp_path
);
5768 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5770 tmp_path
[tmp_path_len
- 1] = 0;
5772 tmp_path_len
= strlen (tmp_path
);
5775 char **files
= NULL
;
5781 if ((d
= opendir (tmp_path
)) != NULL
)
5787 memset (&e
, 0, sizeof (e
));
5788 struct dirent
*de
= NULL
;
5790 if (readdir_r (d
, &e
, &de
) != 0)
5792 log_error ("ERROR: readdir_r() failed");
5797 if (de
== NULL
) break;
5801 while ((de
= readdir (d
)) != NULL
)
5804 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5806 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5808 char *path_file
= (char *) mymalloc (path_size
+ 1);
5810 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5812 path_file
[path_size
] = 0;
5816 if ((d_test
= opendir (path_file
)) != NULL
)
5824 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5828 files
[num_files
- 1] = path_file
;
5834 else if (errno
== ENOTDIR
)
5836 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5840 files
[num_files
- 1] = mystrdup (path
);
5843 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5847 files
[num_files
- 1] = NULL
;
5854 int count_dictionaries (char **dictionary_files
)
5856 if (dictionary_files
== NULL
) return 0;
5860 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5868 char *stroptitype (const uint opti_type
)
5872 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5873 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5874 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5875 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5876 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5877 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5878 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5879 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5880 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5881 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5882 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5883 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5884 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5885 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5886 case OPTI_TYPE_SLOW_HASH_SIMD
: return ((char *) OPTI_STR_SLOW_HASH_SIMD
); break;
5887 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5888 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5889 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5890 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5896 char *strparser (const uint parser_status
)
5898 switch (parser_status
)
5900 case PARSER_OK
: return ((char *) PA_000
); break;
5901 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5902 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5903 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5904 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5905 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5906 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5907 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5908 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5909 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5910 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5911 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5912 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5913 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5914 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5915 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5916 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5919 return ((char *) PA_255
);
5922 char *strhashtype (const uint hash_mode
)
5926 case 0: return ((char *) HT_00000
); break;
5927 case 10: return ((char *) HT_00010
); break;
5928 case 11: return ((char *) HT_00011
); break;
5929 case 12: return ((char *) HT_00012
); break;
5930 case 20: return ((char *) HT_00020
); break;
5931 case 21: return ((char *) HT_00021
); break;
5932 case 22: return ((char *) HT_00022
); break;
5933 case 23: return ((char *) HT_00023
); break;
5934 case 30: return ((char *) HT_00030
); break;
5935 case 40: return ((char *) HT_00040
); break;
5936 case 50: return ((char *) HT_00050
); break;
5937 case 60: return ((char *) HT_00060
); break;
5938 case 100: return ((char *) HT_00100
); break;
5939 case 101: return ((char *) HT_00101
); break;
5940 case 110: return ((char *) HT_00110
); break;
5941 case 111: return ((char *) HT_00111
); break;
5942 case 112: return ((char *) HT_00112
); break;
5943 case 120: return ((char *) HT_00120
); break;
5944 case 121: return ((char *) HT_00121
); break;
5945 case 122: return ((char *) HT_00122
); break;
5946 case 124: return ((char *) HT_00124
); break;
5947 case 125: return ((char *) HT_00125
); break;
5948 case 130: return ((char *) HT_00130
); break;
5949 case 131: return ((char *) HT_00131
); break;
5950 case 132: return ((char *) HT_00132
); break;
5951 case 133: return ((char *) HT_00133
); break;
5952 case 140: return ((char *) HT_00140
); break;
5953 case 141: return ((char *) HT_00141
); break;
5954 case 150: return ((char *) HT_00150
); break;
5955 case 160: return ((char *) HT_00160
); break;
5956 case 190: return ((char *) HT_00190
); break;
5957 case 200: return ((char *) HT_00200
); break;
5958 case 300: return ((char *) HT_00300
); break;
5959 case 400: return ((char *) HT_00400
); break;
5960 case 500: return ((char *) HT_00500
); break;
5961 case 501: return ((char *) HT_00501
); break;
5962 case 900: return ((char *) HT_00900
); break;
5963 case 910: return ((char *) HT_00910
); break;
5964 case 1000: return ((char *) HT_01000
); break;
5965 case 1100: return ((char *) HT_01100
); break;
5966 case 1400: return ((char *) HT_01400
); break;
5967 case 1410: return ((char *) HT_01410
); break;
5968 case 1420: return ((char *) HT_01420
); break;
5969 case 1421: return ((char *) HT_01421
); break;
5970 case 1430: return ((char *) HT_01430
); break;
5971 case 1440: return ((char *) HT_01440
); break;
5972 case 1441: return ((char *) HT_01441
); break;
5973 case 1450: return ((char *) HT_01450
); break;
5974 case 1460: return ((char *) HT_01460
); break;
5975 case 1500: return ((char *) HT_01500
); break;
5976 case 1600: return ((char *) HT_01600
); break;
5977 case 1700: return ((char *) HT_01700
); break;
5978 case 1710: return ((char *) HT_01710
); break;
5979 case 1711: return ((char *) HT_01711
); break;
5980 case 1720: return ((char *) HT_01720
); break;
5981 case 1722: return ((char *) HT_01722
); break;
5982 case 1730: return ((char *) HT_01730
); break;
5983 case 1731: return ((char *) HT_01731
); break;
5984 case 1740: return ((char *) HT_01740
); break;
5985 case 1750: return ((char *) HT_01750
); break;
5986 case 1760: return ((char *) HT_01760
); break;
5987 case 1800: return ((char *) HT_01800
); break;
5988 case 2100: return ((char *) HT_02100
); break;
5989 case 2400: return ((char *) HT_02400
); break;
5990 case 2410: return ((char *) HT_02410
); break;
5991 case 2500: return ((char *) HT_02500
); break;
5992 case 2600: return ((char *) HT_02600
); break;
5993 case 2611: return ((char *) HT_02611
); break;
5994 case 2612: return ((char *) HT_02612
); break;
5995 case 2711: return ((char *) HT_02711
); break;
5996 case 2811: return ((char *) HT_02811
); break;
5997 case 3000: return ((char *) HT_03000
); break;
5998 case 3100: return ((char *) HT_03100
); break;
5999 case 3200: return ((char *) HT_03200
); break;
6000 case 3710: return ((char *) HT_03710
); break;
6001 case 3711: return ((char *) HT_03711
); break;
6002 case 3800: return ((char *) HT_03800
); break;
6003 case 4300: return ((char *) HT_04300
); break;
6004 case 4400: return ((char *) HT_04400
); break;
6005 case 4500: return ((char *) HT_04500
); break;
6006 case 4700: return ((char *) HT_04700
); break;
6007 case 4800: return ((char *) HT_04800
); break;
6008 case 4900: return ((char *) HT_04900
); break;
6009 case 5000: return ((char *) HT_05000
); break;
6010 case 5100: return ((char *) HT_05100
); break;
6011 case 5200: return ((char *) HT_05200
); break;
6012 case 5300: return ((char *) HT_05300
); break;
6013 case 5400: return ((char *) HT_05400
); break;
6014 case 5500: return ((char *) HT_05500
); break;
6015 case 5600: return ((char *) HT_05600
); break;
6016 case 5700: return ((char *) HT_05700
); break;
6017 case 5800: return ((char *) HT_05800
); break;
6018 case 6000: return ((char *) HT_06000
); break;
6019 case 6100: return ((char *) HT_06100
); break;
6020 case 6211: return ((char *) HT_06211
); break;
6021 case 6212: return ((char *) HT_06212
); break;
6022 case 6213: return ((char *) HT_06213
); break;
6023 case 6221: return ((char *) HT_06221
); break;
6024 case 6222: return ((char *) HT_06222
); break;
6025 case 6223: return ((char *) HT_06223
); break;
6026 case 6231: return ((char *) HT_06231
); break;
6027 case 6232: return ((char *) HT_06232
); break;
6028 case 6233: return ((char *) HT_06233
); break;
6029 case 6241: return ((char *) HT_06241
); break;
6030 case 6242: return ((char *) HT_06242
); break;
6031 case 6243: return ((char *) HT_06243
); break;
6032 case 6300: return ((char *) HT_06300
); break;
6033 case 6400: return ((char *) HT_06400
); break;
6034 case 6500: return ((char *) HT_06500
); break;
6035 case 6600: return ((char *) HT_06600
); break;
6036 case 6700: return ((char *) HT_06700
); break;
6037 case 6800: return ((char *) HT_06800
); break;
6038 case 6900: return ((char *) HT_06900
); break;
6039 case 7100: return ((char *) HT_07100
); break;
6040 case 7200: return ((char *) HT_07200
); break;
6041 case 7300: return ((char *) HT_07300
); break;
6042 case 7400: return ((char *) HT_07400
); break;
6043 case 7500: return ((char *) HT_07500
); break;
6044 case 7600: return ((char *) HT_07600
); break;
6045 case 7700: return ((char *) HT_07700
); break;
6046 case 7800: return ((char *) HT_07800
); break;
6047 case 7900: return ((char *) HT_07900
); break;
6048 case 8000: return ((char *) HT_08000
); break;
6049 case 8100: return ((char *) HT_08100
); break;
6050 case 8200: return ((char *) HT_08200
); break;
6051 case 8300: return ((char *) HT_08300
); break;
6052 case 8400: return ((char *) HT_08400
); break;
6053 case 8500: return ((char *) HT_08500
); break;
6054 case 8600: return ((char *) HT_08600
); break;
6055 case 8700: return ((char *) HT_08700
); break;
6056 case 8800: return ((char *) HT_08800
); break;
6057 case 8900: return ((char *) HT_08900
); break;
6058 case 9000: return ((char *) HT_09000
); break;
6059 case 9100: return ((char *) HT_09100
); break;
6060 case 9200: return ((char *) HT_09200
); break;
6061 case 9300: return ((char *) HT_09300
); break;
6062 case 9400: return ((char *) HT_09400
); break;
6063 case 9500: return ((char *) HT_09500
); break;
6064 case 9600: return ((char *) HT_09600
); break;
6065 case 9700: return ((char *) HT_09700
); break;
6066 case 9710: return ((char *) HT_09710
); break;
6067 case 9720: return ((char *) HT_09720
); break;
6068 case 9800: return ((char *) HT_09800
); break;
6069 case 9810: return ((char *) HT_09810
); break;
6070 case 9820: return ((char *) HT_09820
); break;
6071 case 9900: return ((char *) HT_09900
); break;
6072 case 10000: return ((char *) HT_10000
); break;
6073 case 10100: return ((char *) HT_10100
); break;
6074 case 10200: return ((char *) HT_10200
); break;
6075 case 10300: return ((char *) HT_10300
); break;
6076 case 10400: return ((char *) HT_10400
); break;
6077 case 10410: return ((char *) HT_10410
); break;
6078 case 10420: return ((char *) HT_10420
); break;
6079 case 10500: return ((char *) HT_10500
); break;
6080 case 10600: return ((char *) HT_10600
); break;
6081 case 10700: return ((char *) HT_10700
); break;
6082 case 10800: return ((char *) HT_10800
); break;
6083 case 10900: return ((char *) HT_10900
); break;
6084 case 11000: return ((char *) HT_11000
); break;
6085 case 11100: return ((char *) HT_11100
); break;
6086 case 11200: return ((char *) HT_11200
); break;
6087 case 11300: return ((char *) HT_11300
); break;
6088 case 11400: return ((char *) HT_11400
); break;
6089 case 11500: return ((char *) HT_11500
); break;
6090 case 11600: return ((char *) HT_11600
); break;
6091 case 11700: return ((char *) HT_11700
); break;
6092 case 11800: return ((char *) HT_11800
); break;
6093 case 11900: return ((char *) HT_11900
); break;
6094 case 12000: return ((char *) HT_12000
); break;
6095 case 12100: return ((char *) HT_12100
); break;
6096 case 12200: return ((char *) HT_12200
); break;
6097 case 12300: return ((char *) HT_12300
); break;
6098 case 12400: return ((char *) HT_12400
); break;
6099 case 12500: return ((char *) HT_12500
); break;
6100 case 12600: return ((char *) HT_12600
); break;
6101 case 12700: return ((char *) HT_12700
); break;
6102 case 12800: return ((char *) HT_12800
); break;
6103 case 12900: return ((char *) HT_12900
); break;
6104 case 13000: return ((char *) HT_13000
); break;
6105 case 13100: return ((char *) HT_13100
); break;
6106 case 13200: return ((char *) HT_13200
); break;
6107 case 13300: return ((char *) HT_13300
); break;
6108 case 13400: return ((char *) HT_13400
); break;
6109 case 13500: return ((char *) HT_13500
); break;
6110 case 13600: return ((char *) HT_13600
); break;
6111 case 13711: return ((char *) HT_13711
); break;
6112 case 13712: return ((char *) HT_13712
); break;
6113 case 13713: return ((char *) HT_13713
); break;
6114 case 13721: return ((char *) HT_13721
); break;
6115 case 13722: return ((char *) HT_13722
); break;
6116 case 13723: return ((char *) HT_13723
); break;
6117 case 13731: return ((char *) HT_13731
); break;
6118 case 13732: return ((char *) HT_13732
); break;
6119 case 13733: return ((char *) HT_13733
); break;
6120 case 13741: return ((char *) HT_13741
); break;
6121 case 13742: return ((char *) HT_13742
); break;
6122 case 13743: return ((char *) HT_13743
); break;
6123 case 13751: return ((char *) HT_13751
); break;
6124 case 13752: return ((char *) HT_13752
); break;
6125 case 13753: return ((char *) HT_13753
); break;
6126 case 13761: return ((char *) HT_13761
); break;
6127 case 13762: return ((char *) HT_13762
); break;
6128 case 13763: return ((char *) HT_13763
); break;
6131 return ((char *) "Unknown");
6134 char *strstatus (const uint devices_status
)
6136 switch (devices_status
)
6138 case STATUS_INIT
: return ((char *) ST_0000
); break;
6139 case STATUS_STARTING
: return ((char *) ST_0001
); break;
6140 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
6141 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
6142 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
6143 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
6144 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
6145 case STATUS_QUIT
: return ((char *) ST_0007
); break;
6146 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
6147 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
6148 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
6151 return ((char *) "Unknown");
6154 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
6156 uint hash_type
= data
.hash_type
;
6157 uint hash_mode
= data
.hash_mode
;
6158 uint salt_type
= data
.salt_type
;
6159 uint opts_type
= data
.opts_type
;
6160 uint opti_type
= data
.opti_type
;
6161 uint dgst_size
= data
.dgst_size
;
6163 char *hashfile
= data
.hashfile
;
6167 uint digest_buf
[64] = { 0 };
6169 u64
*digest_buf64
= (u64
*) digest_buf
;
6171 char *digests_buf_ptr
= (char *) data
.digests_buf
;
6173 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
6175 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6181 case HASH_TYPE_DESCRYPT
:
6182 FP (digest_buf
[1], digest_buf
[0], tt
);
6185 case HASH_TYPE_DESRACF
:
6186 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6187 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6189 FP (digest_buf
[1], digest_buf
[0], tt
);
6193 FP (digest_buf
[1], digest_buf
[0], tt
);
6196 case HASH_TYPE_NETNTLM
:
6197 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6198 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6199 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
6200 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
6202 FP (digest_buf
[1], digest_buf
[0], tt
);
6203 FP (digest_buf
[3], digest_buf
[2], tt
);
6206 case HASH_TYPE_BSDICRYPT
:
6207 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
6208 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
6210 FP (digest_buf
[1], digest_buf
[0], tt
);
6215 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
6220 digest_buf
[0] += MD4M_A
;
6221 digest_buf
[1] += MD4M_B
;
6222 digest_buf
[2] += MD4M_C
;
6223 digest_buf
[3] += MD4M_D
;
6227 digest_buf
[0] += MD5M_A
;
6228 digest_buf
[1] += MD5M_B
;
6229 digest_buf
[2] += MD5M_C
;
6230 digest_buf
[3] += MD5M_D
;
6233 case HASH_TYPE_SHA1
:
6234 digest_buf
[0] += SHA1M_A
;
6235 digest_buf
[1] += SHA1M_B
;
6236 digest_buf
[2] += SHA1M_C
;
6237 digest_buf
[3] += SHA1M_D
;
6238 digest_buf
[4] += SHA1M_E
;
6241 case HASH_TYPE_SHA256
:
6242 digest_buf
[0] += SHA256M_A
;
6243 digest_buf
[1] += SHA256M_B
;
6244 digest_buf
[2] += SHA256M_C
;
6245 digest_buf
[3] += SHA256M_D
;
6246 digest_buf
[4] += SHA256M_E
;
6247 digest_buf
[5] += SHA256M_F
;
6248 digest_buf
[6] += SHA256M_G
;
6249 digest_buf
[7] += SHA256M_H
;
6252 case HASH_TYPE_SHA384
:
6253 digest_buf64
[0] += SHA384M_A
;
6254 digest_buf64
[1] += SHA384M_B
;
6255 digest_buf64
[2] += SHA384M_C
;
6256 digest_buf64
[3] += SHA384M_D
;
6257 digest_buf64
[4] += SHA384M_E
;
6258 digest_buf64
[5] += SHA384M_F
;
6259 digest_buf64
[6] += 0;
6260 digest_buf64
[7] += 0;
6263 case HASH_TYPE_SHA512
:
6264 digest_buf64
[0] += SHA512M_A
;
6265 digest_buf64
[1] += SHA512M_B
;
6266 digest_buf64
[2] += SHA512M_C
;
6267 digest_buf64
[3] += SHA512M_D
;
6268 digest_buf64
[4] += SHA512M_E
;
6269 digest_buf64
[5] += SHA512M_F
;
6270 digest_buf64
[6] += SHA512M_G
;
6271 digest_buf64
[7] += SHA512M_H
;
6276 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6278 if (dgst_size
== DGST_SIZE_4_2
)
6280 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6282 else if (dgst_size
== DGST_SIZE_4_4
)
6284 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6286 else if (dgst_size
== DGST_SIZE_4_5
)
6288 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6290 else if (dgst_size
== DGST_SIZE_4_6
)
6292 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6294 else if (dgst_size
== DGST_SIZE_4_8
)
6296 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6298 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6300 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6302 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6304 else if (hash_type
== HASH_TYPE_SHA384
)
6306 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6308 else if (hash_type
== HASH_TYPE_SHA512
)
6310 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6312 else if (hash_type
== HASH_TYPE_GOST
)
6314 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6317 else if (dgst_size
== DGST_SIZE_4_64
)
6319 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6321 else if (dgst_size
== DGST_SIZE_8_25
)
6323 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6327 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6328 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6329 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6335 memset (&salt
, 0, sizeof (salt_t
));
6337 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6339 char *ptr
= (char *) salt
.salt_buf
;
6341 uint len
= salt
.salt_len
;
6343 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6349 case HASH_TYPE_NETNTLM
:
6351 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6352 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6354 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6360 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6362 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6370 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6372 uint max
= salt
.salt_len
/ 4;
6376 for (uint i
= 0; i
< max
; i
++)
6378 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6382 if (opts_type
& OPTS_TYPE_ST_HEX
)
6384 char tmp
[64] = { 0 };
6386 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6388 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6393 memcpy (ptr
, tmp
, len
);
6396 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6398 memset (ptr
+ len
, 0, memset_size
);
6400 salt
.salt_len
= len
;
6404 // some modes require special encoding
6407 uint out_buf_plain
[256] = { 0 };
6408 uint out_buf_salt
[256] = { 0 };
6410 char tmp_buf
[1024] = { 0 };
6412 char *ptr_plain
= (char *) out_buf_plain
;
6413 char *ptr_salt
= (char *) out_buf_salt
;
6415 if (hash_mode
== 22)
6417 char username
[30] = { 0 };
6419 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6421 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6423 u16
*ptr
= (u16
*) digest_buf
;
6425 tmp_buf
[ 0] = sig
[0];
6426 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6427 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6428 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6429 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6430 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6431 tmp_buf
[ 6] = sig
[1];
6432 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6433 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6434 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6435 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6436 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6437 tmp_buf
[12] = sig
[2];
6438 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6439 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6440 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6441 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6442 tmp_buf
[17] = sig
[3];
6443 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6444 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6445 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6446 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6447 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6448 tmp_buf
[23] = sig
[4];
6449 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6450 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6451 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6452 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6453 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6454 tmp_buf
[29] = sig
[5];
6456 snprintf (out_buf
, len
-1, "%s:%s",
6460 else if (hash_mode
== 23)
6462 // do not show the skyper part in output
6464 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6466 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6468 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6475 else if (hash_mode
== 101)
6477 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6479 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6480 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6481 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6482 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6483 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6485 memcpy (tmp_buf
, digest_buf
, 20);
6487 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6489 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6491 else if (hash_mode
== 111)
6493 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6495 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6496 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6497 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6498 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6499 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6501 memcpy (tmp_buf
, digest_buf
, 20);
6502 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6504 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6506 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6508 else if ((hash_mode
== 122) || (hash_mode
== 125))
6510 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6511 (char *) salt
.salt_buf
,
6518 else if (hash_mode
== 124)
6520 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6521 (char *) salt
.salt_buf
,
6528 else if (hash_mode
== 131)
6530 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6531 (char *) salt
.salt_buf
,
6539 else if (hash_mode
== 132)
6541 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6542 (char *) salt
.salt_buf
,
6549 else if (hash_mode
== 133)
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]);
6557 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6559 memcpy (tmp_buf
, digest_buf
, 20);
6561 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6563 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6565 else if (hash_mode
== 141)
6567 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6569 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6571 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6573 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6575 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6576 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6577 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6578 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6579 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6581 memcpy (tmp_buf
, digest_buf
, 20);
6583 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6587 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6589 else if (hash_mode
== 400)
6591 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6593 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6594 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6595 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6596 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6598 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6600 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6602 else if (hash_mode
== 500)
6604 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6606 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6607 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6608 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6609 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6611 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6613 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6615 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6619 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6622 else if (hash_mode
== 501)
6624 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6626 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6627 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6629 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6631 else if (hash_mode
== 1421)
6633 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6635 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6651 else if (hash_mode
== 1441)
6653 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6655 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6657 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6659 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6661 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6662 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6663 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6664 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6665 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6666 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6667 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6668 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6670 memcpy (tmp_buf
, digest_buf
, 32);
6672 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6676 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6678 else if (hash_mode
== 1500)
6680 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6681 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6682 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6683 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6684 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6686 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6688 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6690 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6691 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6693 memcpy (tmp_buf
, digest_buf
, 8);
6695 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6697 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6701 else if (hash_mode
== 1600)
6703 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6705 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6706 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6707 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6708 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6710 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6712 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6714 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6718 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6721 else if (hash_mode
== 1711)
6723 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6725 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6726 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6727 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6728 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6729 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6730 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6731 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6732 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6734 memcpy (tmp_buf
, digest_buf
, 64);
6735 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6737 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6739 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6741 else if (hash_mode
== 1722)
6743 uint
*ptr
= digest_buf
;
6745 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6746 (unsigned char *) salt
.salt_buf
,
6756 else if (hash_mode
== 1731)
6758 uint
*ptr
= digest_buf
;
6760 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6761 (unsigned char *) salt
.salt_buf
,
6771 else if (hash_mode
== 1800)
6775 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6776 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6777 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6778 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6779 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6780 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6781 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6782 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6784 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6786 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6788 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6792 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6795 else if (hash_mode
== 2100)
6799 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6801 salt
.salt_iter
+ 1);
6803 uint signature_len
= strlen (out_buf
);
6805 pos
+= signature_len
;
6806 len
-= signature_len
;
6808 char *salt_ptr
= (char *) salt
.salt_buf
;
6810 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6812 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6813 byte_swap_32 (digest_buf
[0]),
6814 byte_swap_32 (digest_buf
[1]),
6815 byte_swap_32 (digest_buf
[2]),
6816 byte_swap_32 (digest_buf
[3]));
6818 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6820 memcpy (tmp_buf
, digest_buf
, 16);
6822 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6824 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6825 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6826 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6827 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6829 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6830 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6831 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6832 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6834 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6835 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6836 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6837 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6839 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6840 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6841 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6842 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6844 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6845 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6846 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6847 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6851 else if (hash_mode
== 2500)
6853 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6855 wpa_t
*wpa
= &wpas
[salt_pos
];
6857 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6858 (char *) salt
.salt_buf
,
6872 else if (hash_mode
== 4400)
6874 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6875 byte_swap_32 (digest_buf
[0]),
6876 byte_swap_32 (digest_buf
[1]),
6877 byte_swap_32 (digest_buf
[2]),
6878 byte_swap_32 (digest_buf
[3]));
6880 else if (hash_mode
== 4700)
6882 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6883 byte_swap_32 (digest_buf
[0]),
6884 byte_swap_32 (digest_buf
[1]),
6885 byte_swap_32 (digest_buf
[2]),
6886 byte_swap_32 (digest_buf
[3]),
6887 byte_swap_32 (digest_buf
[4]));
6889 else if (hash_mode
== 4800)
6891 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6893 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6898 byte_swap_32 (salt
.salt_buf
[0]),
6899 byte_swap_32 (salt
.salt_buf
[1]),
6900 byte_swap_32 (salt
.salt_buf
[2]),
6901 byte_swap_32 (salt
.salt_buf
[3]),
6904 else if (hash_mode
== 4900)
6906 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6907 byte_swap_32 (digest_buf
[0]),
6908 byte_swap_32 (digest_buf
[1]),
6909 byte_swap_32 (digest_buf
[2]),
6910 byte_swap_32 (digest_buf
[3]),
6911 byte_swap_32 (digest_buf
[4]));
6913 else if (hash_mode
== 5100)
6915 snprintf (out_buf
, len
-1, "%08x%08x",
6919 else if (hash_mode
== 5200)
6921 snprintf (out_buf
, len
-1, "%s", hashfile
);
6923 else if (hash_mode
== 5300)
6925 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6927 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6929 int buf_len
= len
-1;
6933 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6935 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6937 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6939 snprintf (out_buf
, buf_len
, ":");
6945 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6953 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6955 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6957 if ((i
== 0) || (i
== 5))
6959 snprintf (out_buf
, buf_len
, ":");
6965 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6973 for (uint i
= 0; i
< 4; i
++)
6977 snprintf (out_buf
, buf_len
, ":");
6983 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6989 else if (hash_mode
== 5400)
6991 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6993 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6995 int buf_len
= len
-1;
6999 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
7001 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
7003 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
7005 snprintf (out_buf
, buf_len
, ":");
7011 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
7019 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
7021 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
7023 if ((i
== 0) || (i
== 5))
7025 snprintf (out_buf
, buf_len
, ":");
7031 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
7039 for (uint i
= 0; i
< 5; i
++)
7043 snprintf (out_buf
, buf_len
, ":");
7049 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
7055 else if (hash_mode
== 5500)
7057 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7059 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7061 char user_buf
[64] = { 0 };
7062 char domain_buf
[64] = { 0 };
7063 char srvchall_buf
[1024] = { 0 };
7064 char clichall_buf
[1024] = { 0 };
7066 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7068 char *ptr
= (char *) netntlm
->userdomain_buf
;
7070 user_buf
[i
] = ptr
[j
];
7073 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7075 char *ptr
= (char *) netntlm
->userdomain_buf
;
7077 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7080 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7082 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7084 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7087 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7089 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7091 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7094 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
7102 byte_swap_32 (salt
.salt_buf_pc
[0]),
7103 byte_swap_32 (salt
.salt_buf_pc
[1]),
7106 else if (hash_mode
== 5600)
7108 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7110 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7112 char user_buf
[64] = { 0 };
7113 char domain_buf
[64] = { 0 };
7114 char srvchall_buf
[1024] = { 0 };
7115 char clichall_buf
[1024] = { 0 };
7117 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7119 char *ptr
= (char *) netntlm
->userdomain_buf
;
7121 user_buf
[i
] = ptr
[j
];
7124 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7126 char *ptr
= (char *) netntlm
->userdomain_buf
;
7128 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7131 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7133 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7135 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7138 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7140 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7142 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7145 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
7155 else if (hash_mode
== 5700)
7157 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7159 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7160 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7161 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7162 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7163 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7164 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7165 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7166 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7168 memcpy (tmp_buf
, digest_buf
, 32);
7170 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
7174 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
7176 else if (hash_mode
== 5800)
7178 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7179 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7180 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7181 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7182 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7184 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
7191 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
7193 snprintf (out_buf
, len
-1, "%s", hashfile
);
7195 else if (hash_mode
== 6300)
7197 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7199 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7200 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7201 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7202 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7204 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7206 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7208 else if (hash_mode
== 6400)
7210 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7212 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7214 else if (hash_mode
== 6500)
7216 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7218 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7220 else if (hash_mode
== 6600)
7222 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
7224 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
7226 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7227 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7229 uint buf_len
= len
- 1;
7231 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
7234 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
7236 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
7241 else if (hash_mode
== 6700)
7243 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7245 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7247 else if (hash_mode
== 6800)
7249 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
7251 else if (hash_mode
== 7100)
7253 uint
*ptr
= digest_buf
;
7255 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7257 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7259 uint esalt
[8] = { 0 };
7261 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7262 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7263 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7264 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7265 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7266 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7267 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7268 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7270 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",
7271 SIGNATURE_SHA512OSX
,
7273 esalt
[ 0], esalt
[ 1],
7274 esalt
[ 2], esalt
[ 3],
7275 esalt
[ 4], esalt
[ 5],
7276 esalt
[ 6], esalt
[ 7],
7284 ptr
[15], ptr
[14]);
7286 else if (hash_mode
== 7200)
7288 uint
*ptr
= digest_buf
;
7290 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7292 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7296 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7298 len_used
= strlen (out_buf
);
7300 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7302 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7304 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7307 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",
7315 ptr
[15], ptr
[14]);
7317 else if (hash_mode
== 7300)
7319 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7321 rakp_t
*rakp
= &rakps
[salt_pos
];
7323 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7325 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7328 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7335 else if (hash_mode
== 7400)
7337 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7339 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7340 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7341 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7342 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7343 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7344 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7345 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7346 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7348 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7350 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7352 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7356 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7359 else if (hash_mode
== 7500)
7361 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7363 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7365 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7366 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7368 char data
[128] = { 0 };
7370 char *ptr_data
= data
;
7372 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7374 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7377 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7379 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7384 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7386 (char *) krb5pa
->user
,
7387 (char *) krb5pa
->realm
,
7388 (char *) krb5pa
->salt
,
7391 else if (hash_mode
== 7700)
7393 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7394 (char *) salt
.salt_buf
,
7398 else if (hash_mode
== 7800)
7400 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7401 (char *) salt
.salt_buf
,
7408 else if (hash_mode
== 7900)
7410 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7414 char *tmp
= (char *) salt
.salt_buf_pc
;
7416 ptr_plain
[42] = tmp
[0];
7422 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7424 else if (hash_mode
== 8000)
7426 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7427 (unsigned char *) salt
.salt_buf
,
7437 else if (hash_mode
== 8100)
7439 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7440 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7442 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7443 (unsigned char *) salt
.salt_buf
,
7450 else if (hash_mode
== 8200)
7452 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7454 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7456 char data_buf
[4096] = { 0 };
7458 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7460 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7463 data_buf
[cloudkey
->data_len
* 2] = 0;
7465 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7466 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7467 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7468 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7469 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7470 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7471 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7472 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7474 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7475 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7476 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7477 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7479 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7495 else if (hash_mode
== 8300)
7497 char digest_buf_c
[34] = { 0 };
7499 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7500 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7501 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7502 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7503 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7505 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7507 digest_buf_c
[32] = 0;
7511 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7513 char domain_buf_c
[33] = { 0 };
7515 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7517 for (uint i
= 0; i
< salt_pc_len
; i
++)
7519 const char next
= domain_buf_c
[i
];
7521 domain_buf_c
[i
] = '.';
7526 domain_buf_c
[salt_pc_len
] = 0;
7530 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7532 else if (hash_mode
== 8500)
7534 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7536 else if (hash_mode
== 2612)
7538 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7540 (char *) salt
.salt_buf
,
7546 else if (hash_mode
== 3711)
7548 char *salt_ptr
= (char *) salt
.salt_buf
;
7550 salt_ptr
[salt
.salt_len
- 1] = 0;
7552 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7553 SIGNATURE_MEDIAWIKI_B
,
7560 else if (hash_mode
== 8800)
7562 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7564 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7566 char tmp
[3073] = { 0 };
7568 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7570 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7575 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7576 SIGNATURE_ANDROIDFDE
,
7577 byte_swap_32 (salt
.salt_buf
[0]),
7578 byte_swap_32 (salt
.salt_buf
[1]),
7579 byte_swap_32 (salt
.salt_buf
[2]),
7580 byte_swap_32 (salt
.salt_buf
[3]),
7581 byte_swap_32 (digest_buf
[0]),
7582 byte_swap_32 (digest_buf
[1]),
7583 byte_swap_32 (digest_buf
[2]),
7584 byte_swap_32 (digest_buf
[3]),
7587 else if (hash_mode
== 8900)
7589 uint N
= salt
.scrypt_N
;
7590 uint r
= salt
.scrypt_r
;
7591 uint p
= salt
.scrypt_p
;
7593 char base64_salt
[32] = { 0 };
7595 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7597 memset (tmp_buf
, 0, 46);
7599 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7600 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7601 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7602 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7603 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7604 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7605 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7606 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7607 digest_buf
[8] = 0; // needed for base64_encode ()
7609 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7611 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7619 else if (hash_mode
== 9000)
7621 snprintf (out_buf
, len
-1, "%s", hashfile
);
7623 else if (hash_mode
== 9200)
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_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7648 tmp_buf
[43] = 0; // cut it here
7652 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7654 else if (hash_mode
== 9300)
7656 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7657 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7658 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7659 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7660 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7661 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7662 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7663 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7664 digest_buf
[8] = 0; // needed for base64_encode ()
7666 char tmp_buf
[64] = { 0 };
7668 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7669 tmp_buf
[43] = 0; // cut it here
7671 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7673 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7675 else if (hash_mode
== 9400)
7677 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7679 office2007_t
*office2007
= &office2007s
[salt_pos
];
7681 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7682 SIGNATURE_OFFICE2007
,
7685 office2007
->keySize
,
7691 office2007
->encryptedVerifier
[0],
7692 office2007
->encryptedVerifier
[1],
7693 office2007
->encryptedVerifier
[2],
7694 office2007
->encryptedVerifier
[3],
7695 office2007
->encryptedVerifierHash
[0],
7696 office2007
->encryptedVerifierHash
[1],
7697 office2007
->encryptedVerifierHash
[2],
7698 office2007
->encryptedVerifierHash
[3],
7699 office2007
->encryptedVerifierHash
[4]);
7701 else if (hash_mode
== 9500)
7703 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7705 office2010_t
*office2010
= &office2010s
[salt_pos
];
7707 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,
7713 office2010
->encryptedVerifier
[0],
7714 office2010
->encryptedVerifier
[1],
7715 office2010
->encryptedVerifier
[2],
7716 office2010
->encryptedVerifier
[3],
7717 office2010
->encryptedVerifierHash
[0],
7718 office2010
->encryptedVerifierHash
[1],
7719 office2010
->encryptedVerifierHash
[2],
7720 office2010
->encryptedVerifierHash
[3],
7721 office2010
->encryptedVerifierHash
[4],
7722 office2010
->encryptedVerifierHash
[5],
7723 office2010
->encryptedVerifierHash
[6],
7724 office2010
->encryptedVerifierHash
[7]);
7726 else if (hash_mode
== 9600)
7728 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7730 office2013_t
*office2013
= &office2013s
[salt_pos
];
7732 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,
7738 office2013
->encryptedVerifier
[0],
7739 office2013
->encryptedVerifier
[1],
7740 office2013
->encryptedVerifier
[2],
7741 office2013
->encryptedVerifier
[3],
7742 office2013
->encryptedVerifierHash
[0],
7743 office2013
->encryptedVerifierHash
[1],
7744 office2013
->encryptedVerifierHash
[2],
7745 office2013
->encryptedVerifierHash
[3],
7746 office2013
->encryptedVerifierHash
[4],
7747 office2013
->encryptedVerifierHash
[5],
7748 office2013
->encryptedVerifierHash
[6],
7749 office2013
->encryptedVerifierHash
[7]);
7751 else if (hash_mode
== 9700)
7753 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7755 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7757 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7758 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7759 byte_swap_32 (salt
.salt_buf
[0]),
7760 byte_swap_32 (salt
.salt_buf
[1]),
7761 byte_swap_32 (salt
.salt_buf
[2]),
7762 byte_swap_32 (salt
.salt_buf
[3]),
7763 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7764 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7765 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7766 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7767 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7768 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7769 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7770 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7772 else if (hash_mode
== 9710)
7774 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7776 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7778 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7779 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7780 byte_swap_32 (salt
.salt_buf
[0]),
7781 byte_swap_32 (salt
.salt_buf
[1]),
7782 byte_swap_32 (salt
.salt_buf
[2]),
7783 byte_swap_32 (salt
.salt_buf
[3]),
7784 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7785 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7786 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7787 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7788 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7789 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7790 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7791 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7793 else if (hash_mode
== 9720)
7795 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7797 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7799 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7801 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7802 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7803 byte_swap_32 (salt
.salt_buf
[0]),
7804 byte_swap_32 (salt
.salt_buf
[1]),
7805 byte_swap_32 (salt
.salt_buf
[2]),
7806 byte_swap_32 (salt
.salt_buf
[3]),
7807 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7808 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7809 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7810 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7811 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7812 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7813 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7814 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7821 else if (hash_mode
== 9800)
7823 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7825 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7827 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7828 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7833 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7834 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7835 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7836 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7837 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7838 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7839 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7840 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7841 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7843 else if (hash_mode
== 9810)
7845 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7847 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7849 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7850 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7855 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7856 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7857 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7858 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7859 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7860 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7861 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7862 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7863 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7865 else if (hash_mode
== 9820)
7867 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7869 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7871 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7873 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7874 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7879 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7880 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7881 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7882 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7883 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7884 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7885 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7886 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7887 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7894 else if (hash_mode
== 10000)
7898 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7900 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7902 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7906 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7907 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7908 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7909 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7910 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7911 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7912 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7913 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7914 digest_buf
[8] = 0; // needed for base64_encode ()
7916 char tmp_buf
[64] = { 0 };
7918 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7922 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7924 else if (hash_mode
== 10100)
7926 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7931 byte_swap_32 (salt
.salt_buf
[0]),
7932 byte_swap_32 (salt
.salt_buf
[1]),
7933 byte_swap_32 (salt
.salt_buf
[2]),
7934 byte_swap_32 (salt
.salt_buf
[3]));
7936 else if (hash_mode
== 10200)
7938 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7940 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7944 char challenge
[100] = { 0 };
7946 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7950 char tmp_buf
[100] = { 0 };
7952 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7953 (char *) cram_md5
->user
,
7959 char response
[100] = { 0 };
7961 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7963 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7965 else if (hash_mode
== 10300)
7967 char tmp_buf
[100] = { 0 };
7969 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7970 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7972 uint tmp_len
= 20 + salt
.salt_len
;
7976 char base64_encoded
[100] = { 0 };
7978 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7980 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7982 else if (hash_mode
== 10400)
7984 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7986 pdf_t
*pdf
= &pdfs
[salt_pos
];
7988 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",
7996 byte_swap_32 (pdf
->id_buf
[0]),
7997 byte_swap_32 (pdf
->id_buf
[1]),
7998 byte_swap_32 (pdf
->id_buf
[2]),
7999 byte_swap_32 (pdf
->id_buf
[3]),
8001 byte_swap_32 (pdf
->u_buf
[0]),
8002 byte_swap_32 (pdf
->u_buf
[1]),
8003 byte_swap_32 (pdf
->u_buf
[2]),
8004 byte_swap_32 (pdf
->u_buf
[3]),
8005 byte_swap_32 (pdf
->u_buf
[4]),
8006 byte_swap_32 (pdf
->u_buf
[5]),
8007 byte_swap_32 (pdf
->u_buf
[6]),
8008 byte_swap_32 (pdf
->u_buf
[7]),
8010 byte_swap_32 (pdf
->o_buf
[0]),
8011 byte_swap_32 (pdf
->o_buf
[1]),
8012 byte_swap_32 (pdf
->o_buf
[2]),
8013 byte_swap_32 (pdf
->o_buf
[3]),
8014 byte_swap_32 (pdf
->o_buf
[4]),
8015 byte_swap_32 (pdf
->o_buf
[5]),
8016 byte_swap_32 (pdf
->o_buf
[6]),
8017 byte_swap_32 (pdf
->o_buf
[7])
8020 else if (hash_mode
== 10410)
8022 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8024 pdf_t
*pdf
= &pdfs
[salt_pos
];
8026 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",
8034 byte_swap_32 (pdf
->id_buf
[0]),
8035 byte_swap_32 (pdf
->id_buf
[1]),
8036 byte_swap_32 (pdf
->id_buf
[2]),
8037 byte_swap_32 (pdf
->id_buf
[3]),
8039 byte_swap_32 (pdf
->u_buf
[0]),
8040 byte_swap_32 (pdf
->u_buf
[1]),
8041 byte_swap_32 (pdf
->u_buf
[2]),
8042 byte_swap_32 (pdf
->u_buf
[3]),
8043 byte_swap_32 (pdf
->u_buf
[4]),
8044 byte_swap_32 (pdf
->u_buf
[5]),
8045 byte_swap_32 (pdf
->u_buf
[6]),
8046 byte_swap_32 (pdf
->u_buf
[7]),
8048 byte_swap_32 (pdf
->o_buf
[0]),
8049 byte_swap_32 (pdf
->o_buf
[1]),
8050 byte_swap_32 (pdf
->o_buf
[2]),
8051 byte_swap_32 (pdf
->o_buf
[3]),
8052 byte_swap_32 (pdf
->o_buf
[4]),
8053 byte_swap_32 (pdf
->o_buf
[5]),
8054 byte_swap_32 (pdf
->o_buf
[6]),
8055 byte_swap_32 (pdf
->o_buf
[7])
8058 else if (hash_mode
== 10420)
8060 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8062 pdf_t
*pdf
= &pdfs
[salt_pos
];
8064 u8
*rc4key
= (u8
*) pdf
->rc4key
;
8066 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",
8074 byte_swap_32 (pdf
->id_buf
[0]),
8075 byte_swap_32 (pdf
->id_buf
[1]),
8076 byte_swap_32 (pdf
->id_buf
[2]),
8077 byte_swap_32 (pdf
->id_buf
[3]),
8079 byte_swap_32 (pdf
->u_buf
[0]),
8080 byte_swap_32 (pdf
->u_buf
[1]),
8081 byte_swap_32 (pdf
->u_buf
[2]),
8082 byte_swap_32 (pdf
->u_buf
[3]),
8083 byte_swap_32 (pdf
->u_buf
[4]),
8084 byte_swap_32 (pdf
->u_buf
[5]),
8085 byte_swap_32 (pdf
->u_buf
[6]),
8086 byte_swap_32 (pdf
->u_buf
[7]),
8088 byte_swap_32 (pdf
->o_buf
[0]),
8089 byte_swap_32 (pdf
->o_buf
[1]),
8090 byte_swap_32 (pdf
->o_buf
[2]),
8091 byte_swap_32 (pdf
->o_buf
[3]),
8092 byte_swap_32 (pdf
->o_buf
[4]),
8093 byte_swap_32 (pdf
->o_buf
[5]),
8094 byte_swap_32 (pdf
->o_buf
[6]),
8095 byte_swap_32 (pdf
->o_buf
[7]),
8103 else if (hash_mode
== 10500)
8105 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8107 pdf_t
*pdf
= &pdfs
[salt_pos
];
8109 if (pdf
->id_len
== 32)
8111 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",
8119 byte_swap_32 (pdf
->id_buf
[0]),
8120 byte_swap_32 (pdf
->id_buf
[1]),
8121 byte_swap_32 (pdf
->id_buf
[2]),
8122 byte_swap_32 (pdf
->id_buf
[3]),
8123 byte_swap_32 (pdf
->id_buf
[4]),
8124 byte_swap_32 (pdf
->id_buf
[5]),
8125 byte_swap_32 (pdf
->id_buf
[6]),
8126 byte_swap_32 (pdf
->id_buf
[7]),
8128 byte_swap_32 (pdf
->u_buf
[0]),
8129 byte_swap_32 (pdf
->u_buf
[1]),
8130 byte_swap_32 (pdf
->u_buf
[2]),
8131 byte_swap_32 (pdf
->u_buf
[3]),
8132 byte_swap_32 (pdf
->u_buf
[4]),
8133 byte_swap_32 (pdf
->u_buf
[5]),
8134 byte_swap_32 (pdf
->u_buf
[6]),
8135 byte_swap_32 (pdf
->u_buf
[7]),
8137 byte_swap_32 (pdf
->o_buf
[0]),
8138 byte_swap_32 (pdf
->o_buf
[1]),
8139 byte_swap_32 (pdf
->o_buf
[2]),
8140 byte_swap_32 (pdf
->o_buf
[3]),
8141 byte_swap_32 (pdf
->o_buf
[4]),
8142 byte_swap_32 (pdf
->o_buf
[5]),
8143 byte_swap_32 (pdf
->o_buf
[6]),
8144 byte_swap_32 (pdf
->o_buf
[7])
8149 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",
8157 byte_swap_32 (pdf
->id_buf
[0]),
8158 byte_swap_32 (pdf
->id_buf
[1]),
8159 byte_swap_32 (pdf
->id_buf
[2]),
8160 byte_swap_32 (pdf
->id_buf
[3]),
8162 byte_swap_32 (pdf
->u_buf
[0]),
8163 byte_swap_32 (pdf
->u_buf
[1]),
8164 byte_swap_32 (pdf
->u_buf
[2]),
8165 byte_swap_32 (pdf
->u_buf
[3]),
8166 byte_swap_32 (pdf
->u_buf
[4]),
8167 byte_swap_32 (pdf
->u_buf
[5]),
8168 byte_swap_32 (pdf
->u_buf
[6]),
8169 byte_swap_32 (pdf
->u_buf
[7]),
8171 byte_swap_32 (pdf
->o_buf
[0]),
8172 byte_swap_32 (pdf
->o_buf
[1]),
8173 byte_swap_32 (pdf
->o_buf
[2]),
8174 byte_swap_32 (pdf
->o_buf
[3]),
8175 byte_swap_32 (pdf
->o_buf
[4]),
8176 byte_swap_32 (pdf
->o_buf
[5]),
8177 byte_swap_32 (pdf
->o_buf
[6]),
8178 byte_swap_32 (pdf
->o_buf
[7])
8182 else if (hash_mode
== 10600)
8184 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8186 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8187 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8189 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8191 else if (hash_mode
== 10700)
8193 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8195 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8196 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8198 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8200 else if (hash_mode
== 10900)
8202 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8204 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8205 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8207 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8209 else if (hash_mode
== 11100)
8211 u32 salt_challenge
= salt
.salt_buf
[0];
8213 salt_challenge
= byte_swap_32 (salt_challenge
);
8215 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
8217 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
8218 SIGNATURE_POSTGRESQL_AUTH
,
8226 else if (hash_mode
== 11200)
8228 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
8229 SIGNATURE_MYSQL_AUTH
,
8230 (unsigned char *) salt
.salt_buf
,
8237 else if (hash_mode
== 11300)
8239 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
8241 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
8243 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
8244 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
8245 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
8247 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
8248 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
8249 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
8251 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
8253 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
8255 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
8258 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
8260 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
8262 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8265 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8267 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8269 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8272 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8273 SIGNATURE_BITCOIN_WALLET
,
8277 (unsigned char *) salt
.salt_buf
,
8285 free (cry_master_buf
);
8287 free (public_key_buf
);
8289 else if (hash_mode
== 11400)
8291 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8293 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8294 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8296 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8298 else if (hash_mode
== 11600)
8300 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8302 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8304 const uint data_len
= seven_zip
->data_len
;
8306 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8308 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8310 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8312 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8315 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8316 SIGNATURE_SEVEN_ZIP
,
8320 (char *) seven_zip
->salt_buf
,
8322 seven_zip
->iv_buf
[0],
8323 seven_zip
->iv_buf
[1],
8324 seven_zip
->iv_buf
[2],
8325 seven_zip
->iv_buf
[3],
8327 seven_zip
->data_len
,
8328 seven_zip
->unpack_size
,
8333 else if (hash_mode
== 11700)
8335 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8345 else if (hash_mode
== 11800)
8347 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8365 else if (hash_mode
== 11900)
8367 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8369 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8370 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8372 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8374 else if (hash_mode
== 12000)
8376 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8378 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8379 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8381 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8383 else if (hash_mode
== 12100)
8385 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8387 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8388 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8390 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8392 else if (hash_mode
== 12200)
8394 uint
*ptr_digest
= digest_buf
;
8395 uint
*ptr_salt
= salt
.salt_buf
;
8397 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8404 else if (hash_mode
== 12300)
8406 uint
*ptr_digest
= digest_buf
;
8407 uint
*ptr_salt
= salt
.salt_buf
;
8409 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",
8410 ptr_digest
[ 0], ptr_digest
[ 1],
8411 ptr_digest
[ 2], ptr_digest
[ 3],
8412 ptr_digest
[ 4], ptr_digest
[ 5],
8413 ptr_digest
[ 6], ptr_digest
[ 7],
8414 ptr_digest
[ 8], ptr_digest
[ 9],
8415 ptr_digest
[10], ptr_digest
[11],
8416 ptr_digest
[12], ptr_digest
[13],
8417 ptr_digest
[14], ptr_digest
[15],
8423 else if (hash_mode
== 12400)
8425 // encode iteration count
8427 char salt_iter
[5] = { 0 };
8429 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8430 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8431 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8432 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8437 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8438 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8439 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8440 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8445 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8447 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8448 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8450 memcpy (tmp_buf
, digest_buf
, 8);
8452 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8456 // fill the resulting buffer
8458 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8460 else if (hash_mode
== 12500)
8462 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8464 byte_swap_32 (salt
.salt_buf
[0]),
8465 byte_swap_32 (salt
.salt_buf
[1]),
8471 else if (hash_mode
== 12600)
8473 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8474 digest_buf
[0] + salt
.salt_buf_pc
[0],
8475 digest_buf
[1] + salt
.salt_buf_pc
[1],
8476 digest_buf
[2] + salt
.salt_buf_pc
[2],
8477 digest_buf
[3] + salt
.salt_buf_pc
[3],
8478 digest_buf
[4] + salt
.salt_buf_pc
[4],
8479 digest_buf
[5] + salt
.salt_buf_pc
[5],
8480 digest_buf
[6] + salt
.salt_buf_pc
[6],
8481 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8483 else if (hash_mode
== 12700)
8485 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8487 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8488 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8490 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8492 else if (hash_mode
== 12800)
8494 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8496 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",
8509 byte_swap_32 (digest_buf
[0]),
8510 byte_swap_32 (digest_buf
[1]),
8511 byte_swap_32 (digest_buf
[2]),
8512 byte_swap_32 (digest_buf
[3]),
8513 byte_swap_32 (digest_buf
[4]),
8514 byte_swap_32 (digest_buf
[5]),
8515 byte_swap_32 (digest_buf
[6]),
8516 byte_swap_32 (digest_buf
[7])
8519 else if (hash_mode
== 12900)
8521 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",
8530 byte_swap_32 (digest_buf
[0]),
8531 byte_swap_32 (digest_buf
[1]),
8532 byte_swap_32 (digest_buf
[2]),
8533 byte_swap_32 (digest_buf
[3]),
8534 byte_swap_32 (digest_buf
[4]),
8535 byte_swap_32 (digest_buf
[5]),
8536 byte_swap_32 (digest_buf
[6]),
8537 byte_swap_32 (digest_buf
[7]),
8544 else if (hash_mode
== 13000)
8546 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8548 rar5_t
*rar5
= &rar5s
[salt_pos
];
8550 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8560 byte_swap_32 (digest_buf
[0]),
8561 byte_swap_32 (digest_buf
[1])
8564 else if (hash_mode
== 13100)
8566 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8568 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8570 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8571 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8573 char data
[2560 * 4 * 2] = { 0 };
8575 char *ptr_data
= data
;
8577 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8578 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8583 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8584 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8586 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8588 (char *) krb5tgs
->account_info
,
8592 else if (hash_mode
== 13200)
8594 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8608 else if (hash_mode
== 13300)
8610 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8611 SIGNATURE_AXCRYPT_SHA1
,
8617 else if (hash_mode
== 13400)
8619 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8621 keepass_t
*keepass
= &keepasss
[salt_pos
];
8623 u32 version
= (u32
) keepass
->version
;
8624 u32 rounds
= salt
.salt_iter
;
8625 u32 algorithm
= (u32
) keepass
->algorithm
;
8626 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8628 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8629 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8630 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8631 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8632 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8634 /* specific to version 1 */
8638 /* specific to version 2 */
8639 u32 expected_bytes_len
;
8640 u32
*ptr_expected_bytes
;
8642 u32 final_random_seed_len
;
8643 u32 transf_random_seed_len
;
8645 u32 contents_hash_len
;
8647 transf_random_seed_len
= 8;
8649 contents_hash_len
= 8;
8650 final_random_seed_len
= 8;
8653 final_random_seed_len
= 4;
8655 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8661 char *ptr_data
= out_buf
;
8663 ptr_data
+= strlen(out_buf
);
8668 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8669 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8674 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8675 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8680 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8681 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8688 contents_len
= (u32
) keepass
->contents_len
;
8689 ptr_contents
= (u32
*) keepass
->contents
;
8691 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8692 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8704 char ptr_contents_len
[10] = { 0 };
8706 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8708 sprintf (ptr_data
, "%d", contents_len
);
8710 ptr_data
+= strlen(ptr_contents_len
);
8715 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8716 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8718 else if (version
== 2)
8720 expected_bytes_len
= 8;
8721 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8723 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8724 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8729 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8730 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8744 sprintf (ptr_data
, "%d", keyfile_len
);
8751 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8752 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8755 else if (hash_mode
== 13500)
8757 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8759 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8761 const u32 salt_len
= (pstoken
->salt_len
> 512) ? 512 : pstoken
->salt_len
;
8763 char pstoken_tmp
[1024 + 1] = { 0 };
8765 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8767 const u8
*ptr
= (const u8
*) pstoken
->salt_buf
;
8769 sprintf (pstoken_tmp
+ j
, "%02x", ptr
[i
]);
8772 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8780 else if (hash_mode
== 13600)
8782 zip2_t
*zip2s
= (zip2_t
*) data
.esalts_buf
;
8784 zip2_t
*zip2
= &zip2s
[salt_pos
];
8786 const u32 salt_len
= zip2
->salt_len
;
8788 char salt_tmp
[32 + 1] = { 0 };
8790 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8792 const u8
*ptr
= (const u8
*) zip2
->salt_buf
;
8794 sprintf (salt_tmp
+ j
, "%02x", ptr
[i
]);
8797 const u32 data_len
= zip2
->data_len
;
8799 char data_tmp
[8192 + 1] = { 0 };
8801 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8803 const u8
*ptr
= (const u8
*) zip2
->data_buf
;
8805 sprintf (data_tmp
+ j
, "%02x", ptr
[i
]);
8808 const u32 auth_len
= zip2
->auth_len
;
8810 char auth_tmp
[20 + 1] = { 0 };
8812 for (uint i
= 0, j
= 0; i
< auth_len
; i
+= 1, j
+= 2)
8814 const u8
*ptr
= (const u8
*) zip2
->auth_buf
;
8816 sprintf (auth_tmp
+ j
, "%02x", ptr
[i
]);
8819 snprintf (out_buf
, 255, "%s*%u*%u*%u*%s*%x*%u*%s*%s*%s",
8820 SIGNATURE_ZIP2_START
,
8826 zip2
->compress_length
,
8829 SIGNATURE_ZIP2_STOP
);
8831 else if ((hash_mode
>= 13700) && (hash_mode
<= 13799))
8833 snprintf (out_buf
, len
-1, "%s", hashfile
);
8837 if (hash_type
== HASH_TYPE_MD4
)
8839 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8845 else if (hash_type
== HASH_TYPE_MD5
)
8847 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8853 else if (hash_type
== HASH_TYPE_SHA1
)
8855 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8862 else if (hash_type
== HASH_TYPE_SHA256
)
8864 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8874 else if (hash_type
== HASH_TYPE_SHA384
)
8876 uint
*ptr
= digest_buf
;
8878 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8886 else if (hash_type
== HASH_TYPE_SHA512
)
8888 uint
*ptr
= digest_buf
;
8890 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8900 else if (hash_type
== HASH_TYPE_LM
)
8902 snprintf (out_buf
, len
-1, "%08x%08x",
8906 else if (hash_type
== HASH_TYPE_ORACLEH
)
8908 snprintf (out_buf
, len
-1, "%08X%08X",
8912 else if (hash_type
== HASH_TYPE_BCRYPT
)
8914 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8915 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8917 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8919 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8921 else if (hash_type
== HASH_TYPE_KECCAK
)
8923 uint
*ptr
= digest_buf
;
8925 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",
8953 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8955 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8957 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8964 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8966 digest_buf
[ 0] = digest_buf
[ 0];
8967 digest_buf
[ 1] = digest_buf
[ 1];
8968 digest_buf
[ 2] = digest_buf
[ 2];
8969 digest_buf
[ 3] = digest_buf
[ 3];
8970 digest_buf
[ 4] = digest_buf
[ 4];
8971 digest_buf
[ 5] = digest_buf
[ 5];
8972 digest_buf
[ 6] = digest_buf
[ 6];
8973 digest_buf
[ 7] = digest_buf
[ 7];
8974 digest_buf
[ 8] = digest_buf
[ 8];
8975 digest_buf
[ 9] = digest_buf
[ 9];
8976 digest_buf
[10] = digest_buf
[10];
8977 digest_buf
[11] = digest_buf
[11];
8978 digest_buf
[12] = digest_buf
[12];
8979 digest_buf
[13] = digest_buf
[13];
8980 digest_buf
[14] = digest_buf
[14];
8981 digest_buf
[15] = digest_buf
[15];
8983 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
9001 else if (hash_type
== HASH_TYPE_GOST
)
9003 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
9013 else if (hash_type
== HASH_TYPE_MYSQL
)
9015 snprintf (out_buf
, len
-1, "%08x%08x",
9019 else if (hash_type
== HASH_TYPE_LOTUS5
)
9021 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
9027 else if (hash_type
== HASH_TYPE_LOTUS6
)
9029 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
9030 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
9031 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
9032 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
9034 char buf
[16] = { 0 };
9036 memcpy (buf
+ 0, salt
.salt_buf
, 5);
9037 memcpy (buf
+ 5, digest_buf
, 9);
9041 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
9043 tmp_buf
[18] = salt
.salt_buf_pc
[7];
9046 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
9048 else if (hash_type
== HASH_TYPE_LOTUS8
)
9050 char buf
[52] = { 0 };
9054 memcpy (buf
+ 0, salt
.salt_buf
, 16);
9060 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
9064 buf
[26] = salt
.salt_buf_pc
[0];
9065 buf
[27] = salt
.salt_buf_pc
[1];
9069 memcpy (buf
+ 28, digest_buf
, 8);
9071 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
9075 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
9077 else if (hash_type
== HASH_TYPE_CRC32
)
9079 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
9083 if (salt_type
== SALT_TYPE_INTERN
)
9085 size_t pos
= strlen (out_buf
);
9087 out_buf
[pos
] = data
.separator
;
9089 char *ptr
= (char *) salt
.salt_buf
;
9091 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
9093 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
9097 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
9099 memset (hccap
, 0, sizeof (hccap_t
));
9101 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
9103 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
9105 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
9106 wpa_t
*wpa
= &wpas
[salt_pos
];
9108 hccap
->keyver
= wpa
->keyver
;
9110 hccap
->eapol_size
= wpa
->eapol_size
;
9112 if (wpa
->keyver
!= 1)
9114 uint eapol_tmp
[64] = { 0 };
9116 for (uint i
= 0; i
< 64; i
++)
9118 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9121 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
9125 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
9128 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
9129 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
9130 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
9131 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
9133 char *digests_buf_ptr
= (char *) data
.digests_buf
;
9135 uint dgst_size
= data
.dgst_size
;
9137 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
9139 if (wpa
->keyver
!= 1)
9141 uint digest_tmp
[4] = { 0 };
9143 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
9144 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
9145 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
9146 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
9148 memcpy (hccap
->keymic
, digest_tmp
, 16);
9152 memcpy (hccap
->keymic
, digest_ptr
, 16);
9156 void SuspendThreads ()
9158 if (data
.devices_status
== STATUS_RUNNING
)
9160 hc_timer_set (&data
.timer_paused
);
9162 data
.devices_status
= STATUS_PAUSED
;
9164 log_info ("Paused");
9168 void ResumeThreads ()
9170 if (data
.devices_status
== STATUS_PAUSED
)
9174 hc_timer_get (data
.timer_paused
, ms_paused
);
9176 data
.ms_paused
+= ms_paused
;
9178 data
.devices_status
= STATUS_RUNNING
;
9180 log_info ("Resumed");
9186 if (data
.devices_status
!= STATUS_RUNNING
) return;
9188 data
.devices_status
= STATUS_BYPASS
;
9190 log_info ("Next dictionary / mask in queue selected, bypassing current one");
9193 void stop_at_checkpoint ()
9195 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9197 if (data
.devices_status
!= STATUS_RUNNING
) return;
9200 // this feature only makes sense if --restore-disable was not specified
9202 if (data
.restore_disable
== 1)
9204 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
9209 // check if monitoring of Restore Point updates should be enabled or disabled
9211 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9213 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
9215 // save the current restore point value
9217 data
.checkpoint_cur_words
= get_lowest_words_done ();
9219 log_info ("Checkpoint enabled: will quit at next Restore Point update");
9223 data
.devices_status
= STATUS_RUNNING
;
9225 // reset the global value for checkpoint checks
9227 data
.checkpoint_cur_words
= 0;
9229 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
9235 if (data
.devices_status
== STATUS_INIT
) return;
9236 if (data
.devices_status
== STATUS_STARTING
) return;
9238 data
.devices_status
= STATUS_ABORTED
;
9243 if (data
.devices_status
== STATUS_INIT
) return;
9244 if (data
.devices_status
== STATUS_STARTING
) return;
9246 data
.devices_status
= STATUS_QUIT
;
9249 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
9251 FILE *fp
= fopen (kernel_file
, "rb");
9257 memset (&st
, 0, sizeof (st
));
9259 stat (kernel_file
, &st
);
9261 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
9263 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
9265 if (num_read
!= (size_t) st
.st_size
)
9267 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9274 buf
[st
.st_size
] = 0;
9276 for (int i
= 0; i
< num_devices
; i
++)
9278 kernel_lengths
[i
] = (size_t) st
.st_size
;
9280 kernel_sources
[i
] = buf
;
9285 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9293 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
9295 if (binary_size
> 0)
9297 FILE *fp
= fopen (dst
, "wb");
9300 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
9311 restore_data_t
*init_restore (int argc
, char **argv
)
9313 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
9315 if (data
.restore_disable
== 0)
9317 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
9321 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
9325 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
9334 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9336 int pidbin_len
= -1;
9339 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9341 FILE *fd
= fopen (pidbin
, "rb");
9345 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9347 pidbin
[pidbin_len
] = 0;
9351 char *argv0_r
= strrchr (argv
[0], '/');
9353 char *pidbin_r
= strrchr (pidbin
, '/');
9355 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9357 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9359 if (strcmp (argv0_r
, pidbin_r
) == 0)
9361 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
9368 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9370 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9372 int pidbin2_len
= -1;
9374 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9375 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9377 pidbin
[pidbin_len
] = 0;
9378 pidbin2
[pidbin2_len
] = 0;
9382 if (strcmp (pidbin
, pidbin2
) == 0)
9384 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9397 if (rd
->version_bin
< RESTORE_MIN
)
9399 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9406 memset (rd
, 0, sizeof (restore_data_t
));
9408 rd
->version_bin
= VERSION_BIN
;
9411 rd
->pid
= getpid ();
9413 rd
->pid
= GetCurrentProcessId ();
9416 if (getcwd (rd
->cwd
, 255) == NULL
)
9429 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9431 FILE *fp
= fopen (eff_restore_file
, "rb");
9435 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
9440 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9442 log_error ("ERROR: cannot read %s", eff_restore_file
);
9447 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9449 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9451 for (uint i
= 0; i
< rd
->argc
; i
++)
9453 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9455 log_error ("ERROR: cannot read %s", eff_restore_file
);
9460 size_t len
= strlen (buf
);
9462 if (len
) buf
[len
- 1] = 0;
9464 rd
->argv
[i
] = mystrdup (buf
);
9471 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9473 if (chdir (rd
->cwd
))
9475 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9476 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9477 " https://github.com/philsmd/analyze_hc_restore\n"
9478 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9484 u64
get_lowest_words_done ()
9488 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9490 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9492 if (device_param
->skipped
) continue;
9494 const u64 words_done
= device_param
->words_done
;
9496 if (words_done
< words_cur
) words_cur
= words_done
;
9499 // It's possible that a device's workload isn't finished right after a restore-case.
9500 // In that case, this function would return 0 and overwrite the real restore point
9501 // There's also data.words_cur which is set to rd->words_cur but it changes while
9502 // the attack is running therefore we should stick to rd->words_cur.
9503 // Note that -s influences rd->words_cur we should keep a close look on that.
9505 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9510 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9512 u64 words_cur
= get_lowest_words_done ();
9514 rd
->words_cur
= words_cur
;
9516 FILE *fp
= fopen (new_restore_file
, "wb");
9520 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9525 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9527 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9532 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9534 for (uint i
= 0; i
< rd
->argc
; i
++)
9536 fprintf (fp
, "%s", rd
->argv
[i
]);
9542 fsync (fileno (fp
));
9547 void cycle_restore ()
9549 const char *eff_restore_file
= data
.eff_restore_file
;
9550 const char *new_restore_file
= data
.new_restore_file
;
9552 restore_data_t
*rd
= data
.rd
;
9554 write_restore (new_restore_file
, rd
);
9558 memset (&st
, 0, sizeof(st
));
9560 if (stat (eff_restore_file
, &st
) == 0)
9562 if (unlink (eff_restore_file
))
9564 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9568 if (rename (new_restore_file
, eff_restore_file
))
9570 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9574 void check_checkpoint ()
9576 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9578 u64 words_cur
= get_lowest_words_done ();
9580 if (words_cur
!= data
.checkpoint_cur_words
)
9590 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9594 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9596 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9598 myfree (alias
->device_name
);
9599 myfree (alias
->alias_name
);
9602 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9604 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9606 myfree (entry
->device_name
);
9609 myfree (tuning_db
->alias_buf
);
9610 myfree (tuning_db
->entry_buf
);
9615 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9617 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9619 int num_lines
= count_lines (fp
);
9621 // a bit over-allocated
9623 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9624 tuning_db
->alias_cnt
= 0;
9626 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9627 tuning_db
->entry_cnt
= 0;
9632 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9634 FILE *fp
= fopen (tuning_db_file
, "rb");
9638 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9643 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9649 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9653 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9655 if (line_buf
== NULL
) break;
9659 const int line_len
= in_superchop (line_buf
);
9661 if (line_len
== 0) continue;
9663 if (line_buf
[0] == '#') continue;
9667 char *token_ptr
[7] = { NULL
};
9671 char *next
= strtok (line_buf
, "\t ");
9673 token_ptr
[token_cnt
] = next
;
9677 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9679 token_ptr
[token_cnt
] = next
;
9686 char *device_name
= token_ptr
[0];
9687 char *alias_name
= token_ptr
[1];
9689 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9691 alias
->device_name
= mystrdup (device_name
);
9692 alias
->alias_name
= mystrdup (alias_name
);
9694 tuning_db
->alias_cnt
++;
9696 else if (token_cnt
== 6)
9698 if ((token_ptr
[1][0] != '0') &&
9699 (token_ptr
[1][0] != '1') &&
9700 (token_ptr
[1][0] != '3') &&
9701 (token_ptr
[1][0] != '*'))
9703 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9708 if ((token_ptr
[3][0] != '1') &&
9709 (token_ptr
[3][0] != '2') &&
9710 (token_ptr
[3][0] != '4') &&
9711 (token_ptr
[3][0] != '8') &&
9712 (token_ptr
[3][0] != 'N'))
9714 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9719 char *device_name
= token_ptr
[0];
9721 int attack_mode
= -1;
9723 int vector_width
= -1;
9724 int kernel_accel
= -1;
9725 int kernel_loops
= -1;
9727 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9728 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9729 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9731 if (token_ptr
[4][0] != 'A')
9733 kernel_accel
= atoi (token_ptr
[4]);
9735 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9737 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9747 if (token_ptr
[5][0] != 'A')
9749 kernel_loops
= atoi (token_ptr
[5]);
9751 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9753 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9763 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9765 entry
->device_name
= mystrdup (device_name
);
9766 entry
->attack_mode
= attack_mode
;
9767 entry
->hash_type
= hash_type
;
9768 entry
->vector_width
= vector_width
;
9769 entry
->kernel_accel
= kernel_accel
;
9770 entry
->kernel_loops
= kernel_loops
;
9772 tuning_db
->entry_cnt
++;
9776 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9786 // todo: print loaded 'cnt' message
9788 // sort the database
9790 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9791 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9796 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9798 static tuning_db_entry_t s
;
9800 // first we need to convert all spaces in the device_name to underscore
9802 char *device_name_nospace
= strdup (device_param
->device_name
);
9804 int device_name_length
= strlen (device_name_nospace
);
9808 for (i
= 0; i
< device_name_length
; i
++)
9810 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9813 // find out if there's an alias configured
9815 tuning_db_alias_t a
;
9817 a
.device_name
= device_name_nospace
;
9819 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
);
9821 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9823 // attack-mode 6 and 7 are attack-mode 1 basically
9825 if (attack_mode
== 6) attack_mode
= 1;
9826 if (attack_mode
== 7) attack_mode
= 1;
9828 // bsearch is not ideal but fast enough
9830 s
.device_name
= device_name_nospace
;
9831 s
.attack_mode
= attack_mode
;
9832 s
.hash_type
= hash_type
;
9834 tuning_db_entry_t
*entry
= NULL
;
9836 // this will produce all 2^3 combinations required
9838 for (i
= 0; i
< 8; i
++)
9840 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9841 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9842 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9844 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9846 if (entry
!= NULL
) break;
9848 // in non-wildcard mode do some additional checks:
9852 // in case we have an alias-name
9854 if (alias_name
!= NULL
)
9856 s
.device_name
= alias_name
;
9858 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9860 if (entry
!= NULL
) break;
9863 // or by device type
9865 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9867 s
.device_name
= "DEVICE_TYPE_CPU";
9869 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9871 s
.device_name
= "DEVICE_TYPE_GPU";
9873 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9875 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9878 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9880 if (entry
!= NULL
) break;
9884 // free converted device_name
9886 myfree (device_name_nospace
);
9895 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9897 u8 tmp
[256] = { 0 };
9899 if (salt_len
> sizeof (tmp
))
9904 memcpy (tmp
, in
, salt_len
);
9906 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9908 if ((salt_len
% 2) == 0)
9910 u32 new_salt_len
= salt_len
/ 2;
9912 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9917 tmp
[i
] = hex_convert (p1
) << 0;
9918 tmp
[i
] |= hex_convert (p0
) << 4;
9921 salt_len
= new_salt_len
;
9928 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9930 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9933 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9935 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9939 u32
*tmp_uint
= (u32
*) tmp
;
9941 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9942 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9943 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9944 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9945 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9946 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9947 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9948 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9949 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9950 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9952 salt_len
= salt_len
* 2;
9960 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9962 lowercase (tmp
, salt_len
);
9965 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9967 uppercase (tmp
, salt_len
);
9972 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9977 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9982 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9984 u32
*tmp_uint
= (uint
*) tmp
;
9990 for (u32 i
= 0; i
< max
; i
++)
9992 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9995 // Important: we may need to increase the length of memcpy since
9996 // we don't want to "loose" some swapped bytes (could happen if
9997 // they do not perfectly fit in the 4-byte blocks)
9998 // Memcpy does always copy the bytes in the BE order, but since
9999 // we swapped them, some important bytes could be in positions
10000 // we normally skip with the original len
10002 if (len
% 4) len
+= 4 - (len
% 4);
10005 memcpy (out
, tmp
, len
);
10010 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10012 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
10014 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
10016 u32
*digest
= (u32
*) hash_buf
->digest
;
10018 salt_t
*salt
= hash_buf
->salt
;
10020 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
10022 char *iter_pos
= input_buf
+ 4;
10024 salt
->salt_iter
= 1 << atoi (iter_pos
);
10026 char *salt_pos
= strchr (iter_pos
, '$');
10028 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10032 uint salt_len
= 16;
10034 salt
->salt_len
= salt_len
;
10036 u8 tmp_buf
[100] = { 0 };
10038 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
10040 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10042 memcpy (salt_buf_ptr
, tmp_buf
, 16);
10044 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
10045 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
10046 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
10047 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
10049 char *hash_pos
= salt_pos
+ 22;
10051 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10053 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
10055 memcpy (digest
, tmp_buf
, 24);
10057 digest
[0] = byte_swap_32 (digest
[0]);
10058 digest
[1] = byte_swap_32 (digest
[1]);
10059 digest
[2] = byte_swap_32 (digest
[2]);
10060 digest
[3] = byte_swap_32 (digest
[3]);
10061 digest
[4] = byte_swap_32 (digest
[4]);
10062 digest
[5] = byte_swap_32 (digest
[5]);
10064 digest
[5] &= ~0xff; // its just 23 not 24 !
10066 return (PARSER_OK
);
10069 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10071 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
10073 u32
*digest
= (u32
*) hash_buf
->digest
;
10075 u8 tmp_buf
[100] = { 0 };
10077 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
10079 memcpy (digest
, tmp_buf
, 32);
10081 digest
[0] = byte_swap_32 (digest
[0]);
10082 digest
[1] = byte_swap_32 (digest
[1]);
10083 digest
[2] = byte_swap_32 (digest
[2]);
10084 digest
[3] = byte_swap_32 (digest
[3]);
10085 digest
[4] = byte_swap_32 (digest
[4]);
10086 digest
[5] = byte_swap_32 (digest
[5]);
10087 digest
[6] = byte_swap_32 (digest
[6]);
10088 digest
[7] = byte_swap_32 (digest
[7]);
10090 digest
[0] -= SHA256M_A
;
10091 digest
[1] -= SHA256M_B
;
10092 digest
[2] -= SHA256M_C
;
10093 digest
[3] -= SHA256M_D
;
10094 digest
[4] -= SHA256M_E
;
10095 digest
[5] -= SHA256M_F
;
10096 digest
[6] -= SHA256M_G
;
10097 digest
[7] -= SHA256M_H
;
10099 return (PARSER_OK
);
10102 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10104 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
10106 u32
*digest
= (u32
*) hash_buf
->digest
;
10108 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10109 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10111 digest
[0] = byte_swap_32 (digest
[0]);
10112 digest
[1] = byte_swap_32 (digest
[1]);
10116 IP (digest
[0], digest
[1], tt
);
10118 digest
[0] = digest
[0];
10119 digest
[1] = digest
[1];
10123 return (PARSER_OK
);
10126 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10128 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
10130 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
10132 u32
*digest
= (u32
*) hash_buf
->digest
;
10134 salt_t
*salt
= hash_buf
->salt
;
10136 char *hash_pos
= input_buf
+ 10;
10138 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10139 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10140 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10141 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10142 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10144 digest
[0] -= SHA1M_A
;
10145 digest
[1] -= SHA1M_B
;
10146 digest
[2] -= SHA1M_C
;
10147 digest
[3] -= SHA1M_D
;
10148 digest
[4] -= SHA1M_E
;
10150 uint salt_len
= 10;
10152 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10154 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10156 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10158 salt
->salt_len
= salt_len
;
10160 return (PARSER_OK
);
10163 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10165 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
10167 u32
*digest
= (u32
*) hash_buf
->digest
;
10169 salt_t
*salt
= hash_buf
->salt
;
10171 char *hash_pos
= input_buf
+ 8;
10173 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10174 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10175 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10176 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10177 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10179 digest
[0] -= SHA1M_A
;
10180 digest
[1] -= SHA1M_B
;
10181 digest
[2] -= SHA1M_C
;
10182 digest
[3] -= SHA1M_D
;
10183 digest
[4] -= SHA1M_E
;
10187 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10189 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10191 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10193 salt
->salt_len
= salt_len
;
10195 return (PARSER_OK
);
10198 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10200 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
10202 u64
*digest
= (u64
*) hash_buf
->digest
;
10204 salt_t
*salt
= hash_buf
->salt
;
10206 char *hash_pos
= input_buf
+ 8;
10208 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
10209 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
10210 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
10211 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
10212 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
10213 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
10214 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
10215 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
10217 digest
[0] -= SHA512M_A
;
10218 digest
[1] -= SHA512M_B
;
10219 digest
[2] -= SHA512M_C
;
10220 digest
[3] -= SHA512M_D
;
10221 digest
[4] -= SHA512M_E
;
10222 digest
[5] -= SHA512M_F
;
10223 digest
[6] -= SHA512M_G
;
10224 digest
[7] -= SHA512M_H
;
10228 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10230 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10232 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10234 salt
->salt_len
= salt_len
;
10236 return (PARSER_OK
);
10239 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10241 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10243 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
10247 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
10250 u32
*digest
= (u32
*) hash_buf
->digest
;
10252 salt_t
*salt
= hash_buf
->salt
;
10254 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10255 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10256 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10257 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10259 digest
[0] = byte_swap_32 (digest
[0]);
10260 digest
[1] = byte_swap_32 (digest
[1]);
10261 digest
[2] = byte_swap_32 (digest
[2]);
10262 digest
[3] = byte_swap_32 (digest
[3]);
10264 digest
[0] -= MD5M_A
;
10265 digest
[1] -= MD5M_B
;
10266 digest
[2] -= MD5M_C
;
10267 digest
[3] -= MD5M_D
;
10269 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10271 uint salt_len
= input_len
- 32 - 1;
10273 char *salt_buf
= input_buf
+ 32 + 1;
10275 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10277 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10279 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10281 salt
->salt_len
= salt_len
;
10283 return (PARSER_OK
);
10286 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10288 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10290 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
10294 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
10299 char clean_input_buf
[32] = { 0 };
10301 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
10302 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
10304 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
10308 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
10314 clean_input_buf
[k
] = input_buf
[i
];
10322 u32
*digest
= (u32
*) hash_buf
->digest
;
10324 salt_t
*salt
= hash_buf
->salt
;
10326 u32 a
, b
, c
, d
, e
, f
;
10328 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10329 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10330 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10331 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10332 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10333 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10335 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10336 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10338 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10339 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10340 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10341 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10342 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10343 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10345 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10346 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10348 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10349 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10350 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10351 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10352 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10353 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10355 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10356 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10358 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10359 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10360 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10361 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10362 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10363 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10365 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10366 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10368 digest
[0] = byte_swap_32 (digest
[0]);
10369 digest
[1] = byte_swap_32 (digest
[1]);
10370 digest
[2] = byte_swap_32 (digest
[2]);
10371 digest
[3] = byte_swap_32 (digest
[3]);
10373 digest
[0] -= MD5M_A
;
10374 digest
[1] -= MD5M_B
;
10375 digest
[2] -= MD5M_C
;
10376 digest
[3] -= MD5M_D
;
10378 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10380 uint salt_len
= input_len
- 30 - 1;
10382 char *salt_buf
= input_buf
+ 30 + 1;
10384 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10386 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10388 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10389 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10391 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10393 salt
->salt_len
= salt_len
;
10395 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10397 salt
->salt_len
+= 22;
10399 return (PARSER_OK
);
10402 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10404 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10406 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10410 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10413 u32
*digest
= (u32
*) hash_buf
->digest
;
10415 salt_t
*salt
= hash_buf
->salt
;
10417 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10418 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10419 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10420 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10421 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10423 digest
[0] -= SHA1M_A
;
10424 digest
[1] -= SHA1M_B
;
10425 digest
[2] -= SHA1M_C
;
10426 digest
[3] -= SHA1M_D
;
10427 digest
[4] -= SHA1M_E
;
10429 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10431 uint salt_len
= input_len
- 40 - 1;
10433 char *salt_buf
= input_buf
+ 40 + 1;
10435 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10437 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10439 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10441 salt
->salt_len
= salt_len
;
10443 return (PARSER_OK
);
10446 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10448 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10450 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10454 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10457 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10459 char *iter_pos
= input_buf
+ 6;
10461 salt_t
*salt
= hash_buf
->salt
;
10463 uint iter
= atoi (iter_pos
);
10467 iter
= ROUNDS_DCC2
;
10470 salt
->salt_iter
= iter
- 1;
10472 char *salt_pos
= strchr (iter_pos
, '#');
10474 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10478 char *digest_pos
= strchr (salt_pos
, '#');
10480 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10484 uint salt_len
= digest_pos
- salt_pos
- 1;
10486 u32
*digest
= (u32
*) hash_buf
->digest
;
10488 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10489 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10490 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10491 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10493 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10495 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10497 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10499 salt
->salt_len
= salt_len
;
10501 return (PARSER_OK
);
10504 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10506 u32
*digest
= (u32
*) hash_buf
->digest
;
10508 salt_t
*salt
= hash_buf
->salt
;
10510 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10514 memcpy (&in
, input_buf
, input_len
);
10516 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10518 memcpy (digest
, in
.keymic
, 16);
10521 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10522 The phrase "Pairwise key expansion"
10523 Access Point Address (referred to as Authenticator Address AA)
10524 Supplicant Address (referred to as Supplicant Address SA)
10525 Access Point Nonce (referred to as Authenticator Anonce)
10526 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10529 uint salt_len
= strlen (in
.essid
);
10533 log_info ("WARNING: the length of the ESSID is too long. The hccap file may be invalid or corrupted");
10535 return (PARSER_SALT_LENGTH
);
10538 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10540 salt
->salt_len
= salt_len
;
10542 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10544 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10546 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10548 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10550 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10551 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10555 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10556 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10559 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10561 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10562 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10566 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10567 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10570 for (int i
= 0; i
< 25; i
++)
10572 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10575 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10576 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10577 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10578 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10580 wpa
->keyver
= in
.keyver
;
10582 if (wpa
->keyver
> 255)
10584 log_info ("ATTENTION!");
10585 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10586 log_info (" This could be due to a recent aircrack-ng bug.");
10587 log_info (" The key version was automatically reset to a reasonable value.");
10590 wpa
->keyver
&= 0xff;
10593 wpa
->eapol_size
= in
.eapol_size
;
10595 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10597 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10599 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10601 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10603 if (wpa
->keyver
== 1)
10609 digest
[0] = byte_swap_32 (digest
[0]);
10610 digest
[1] = byte_swap_32 (digest
[1]);
10611 digest
[2] = byte_swap_32 (digest
[2]);
10612 digest
[3] = byte_swap_32 (digest
[3]);
10614 for (int i
= 0; i
< 64; i
++)
10616 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10620 uint32_t *p0
= (uint32_t *) in
.essid
;
10624 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10625 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10627 salt
->salt_buf
[10] = c0
;
10628 salt
->salt_buf
[11] = c1
;
10630 return (PARSER_OK
);
10633 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10635 u32
*digest
= (u32
*) hash_buf
->digest
;
10637 salt_t
*salt
= hash_buf
->salt
;
10639 if (input_len
== 0)
10641 log_error ("Password Safe v2 container not specified");
10646 FILE *fp
= fopen (input_buf
, "rb");
10650 log_error ("%s: %s", input_buf
, strerror (errno
));
10657 memset (&buf
, 0, sizeof (psafe2_hdr
));
10659 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10663 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10665 salt
->salt_buf
[0] = buf
.random
[0];
10666 salt
->salt_buf
[1] = buf
.random
[1];
10668 salt
->salt_len
= 8;
10669 salt
->salt_iter
= 1000;
10671 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10672 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10673 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10674 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10675 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10677 return (PARSER_OK
);
10680 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10682 u32
*digest
= (u32
*) hash_buf
->digest
;
10684 salt_t
*salt
= hash_buf
->salt
;
10686 if (input_len
== 0)
10688 log_error (".psafe3 not specified");
10693 FILE *fp
= fopen (input_buf
, "rb");
10697 log_error ("%s: %s", input_buf
, strerror (errno
));
10704 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10708 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10710 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10712 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10714 salt
->salt_iter
= in
.iterations
+ 1;
10716 salt
->salt_buf
[0] = in
.salt_buf
[0];
10717 salt
->salt_buf
[1] = in
.salt_buf
[1];
10718 salt
->salt_buf
[2] = in
.salt_buf
[2];
10719 salt
->salt_buf
[3] = in
.salt_buf
[3];
10720 salt
->salt_buf
[4] = in
.salt_buf
[4];
10721 salt
->salt_buf
[5] = in
.salt_buf
[5];
10722 salt
->salt_buf
[6] = in
.salt_buf
[6];
10723 salt
->salt_buf
[7] = in
.salt_buf
[7];
10725 salt
->salt_len
= 32;
10727 digest
[0] = in
.hash_buf
[0];
10728 digest
[1] = in
.hash_buf
[1];
10729 digest
[2] = in
.hash_buf
[2];
10730 digest
[3] = in
.hash_buf
[3];
10731 digest
[4] = in
.hash_buf
[4];
10732 digest
[5] = in
.hash_buf
[5];
10733 digest
[6] = in
.hash_buf
[6];
10734 digest
[7] = in
.hash_buf
[7];
10736 digest
[0] = byte_swap_32 (digest
[0]);
10737 digest
[1] = byte_swap_32 (digest
[1]);
10738 digest
[2] = byte_swap_32 (digest
[2]);
10739 digest
[3] = byte_swap_32 (digest
[3]);
10740 digest
[4] = byte_swap_32 (digest
[4]);
10741 digest
[5] = byte_swap_32 (digest
[5]);
10742 digest
[6] = byte_swap_32 (digest
[6]);
10743 digest
[7] = byte_swap_32 (digest
[7]);
10745 return (PARSER_OK
);
10748 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10750 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10752 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10754 u32
*digest
= (u32
*) hash_buf
->digest
;
10756 salt_t
*salt
= hash_buf
->salt
;
10758 char *iter_pos
= input_buf
+ 3;
10760 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10762 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10764 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10766 salt
->salt_iter
= salt_iter
;
10768 char *salt_pos
= iter_pos
+ 1;
10772 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10774 salt
->salt_len
= salt_len
;
10776 char *hash_pos
= salt_pos
+ salt_len
;
10778 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10780 return (PARSER_OK
);
10783 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10785 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10787 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10789 u32
*digest
= (u32
*) hash_buf
->digest
;
10791 salt_t
*salt
= hash_buf
->salt
;
10793 char *salt_pos
= input_buf
+ 3;
10795 uint iterations_len
= 0;
10797 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10801 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10803 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10804 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10808 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10812 iterations_len
+= 8;
10816 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10819 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10821 char *hash_pos
= strchr (salt_pos
, '$');
10823 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10825 uint salt_len
= hash_pos
- salt_pos
;
10827 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10829 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10831 salt
->salt_len
= salt_len
;
10835 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10837 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10839 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10841 return (PARSER_OK
);
10844 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10846 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10848 u32
*digest
= (u32
*) hash_buf
->digest
;
10850 salt_t
*salt
= hash_buf
->salt
;
10852 char *salt_pos
= input_buf
+ 6;
10854 uint iterations_len
= 0;
10856 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10860 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10862 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10863 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10867 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10871 iterations_len
+= 8;
10875 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10878 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10880 char *hash_pos
= strchr (salt_pos
, '$');
10882 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10884 uint salt_len
= hash_pos
- salt_pos
;
10886 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10888 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10890 salt
->salt_len
= salt_len
;
10894 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10896 return (PARSER_OK
);
10899 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10901 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10903 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10905 u32
*digest
= (u32
*) hash_buf
->digest
;
10907 salt_t
*salt
= hash_buf
->salt
;
10909 char *salt_pos
= input_buf
+ 14;
10911 char *hash_pos
= strchr (salt_pos
, '*');
10913 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10917 uint salt_len
= hash_pos
- salt_pos
- 1;
10919 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10921 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10923 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10925 salt
->salt_len
= salt_len
;
10927 u8 tmp_buf
[100] = { 0 };
10929 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10931 memcpy (digest
, tmp_buf
, 20);
10933 digest
[0] = byte_swap_32 (digest
[0]);
10934 digest
[1] = byte_swap_32 (digest
[1]);
10935 digest
[2] = byte_swap_32 (digest
[2]);
10936 digest
[3] = byte_swap_32 (digest
[3]);
10937 digest
[4] = byte_swap_32 (digest
[4]);
10939 digest
[0] -= SHA1M_A
;
10940 digest
[1] -= SHA1M_B
;
10941 digest
[2] -= SHA1M_C
;
10942 digest
[3] -= SHA1M_D
;
10943 digest
[4] -= SHA1M_E
;
10945 return (PARSER_OK
);
10948 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10950 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10952 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10954 if (c12
& 3) return (PARSER_HASH_VALUE
);
10956 u32
*digest
= (u32
*) hash_buf
->digest
;
10958 salt_t
*salt
= hash_buf
->salt
;
10960 // for ascii_digest
10961 salt
->salt_sign
[0] = input_buf
[0];
10962 salt
->salt_sign
[1] = input_buf
[1];
10964 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10965 | itoa64_to_int (input_buf
[1]) << 6;
10967 salt
->salt_len
= 2;
10969 u8 tmp_buf
[100] = { 0 };
10971 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10973 memcpy (digest
, tmp_buf
, 8);
10977 IP (digest
[0], digest
[1], tt
);
10982 return (PARSER_OK
);
10985 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10987 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10989 u32
*digest
= (u32
*) hash_buf
->digest
;
10991 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10992 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10993 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10994 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10996 digest
[0] = byte_swap_32 (digest
[0]);
10997 digest
[1] = byte_swap_32 (digest
[1]);
10998 digest
[2] = byte_swap_32 (digest
[2]);
10999 digest
[3] = byte_swap_32 (digest
[3]);
11001 digest
[0] -= MD4M_A
;
11002 digest
[1] -= MD4M_B
;
11003 digest
[2] -= MD4M_C
;
11004 digest
[3] -= MD4M_D
;
11006 return (PARSER_OK
);
11009 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11011 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11013 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
11017 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
11020 u32
*digest
= (u32
*) hash_buf
->digest
;
11022 salt_t
*salt
= hash_buf
->salt
;
11024 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11025 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11026 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11027 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11029 digest
[0] = byte_swap_32 (digest
[0]);
11030 digest
[1] = byte_swap_32 (digest
[1]);
11031 digest
[2] = byte_swap_32 (digest
[2]);
11032 digest
[3] = byte_swap_32 (digest
[3]);
11034 digest
[0] -= MD4M_A
;
11035 digest
[1] -= MD4M_B
;
11036 digest
[2] -= MD4M_C
;
11037 digest
[3] -= MD4M_D
;
11039 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11041 uint salt_len
= input_len
- 32 - 1;
11043 char *salt_buf
= input_buf
+ 32 + 1;
11045 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11047 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11049 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11051 salt
->salt_len
= salt_len
;
11053 return (PARSER_OK
);
11056 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11058 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
11060 u32
*digest
= (u32
*) hash_buf
->digest
;
11062 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11063 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11064 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11065 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11067 digest
[0] = byte_swap_32 (digest
[0]);
11068 digest
[1] = byte_swap_32 (digest
[1]);
11069 digest
[2] = byte_swap_32 (digest
[2]);
11070 digest
[3] = byte_swap_32 (digest
[3]);
11072 digest
[0] -= MD5M_A
;
11073 digest
[1] -= MD5M_B
;
11074 digest
[2] -= MD5M_C
;
11075 digest
[3] -= MD5M_D
;
11077 return (PARSER_OK
);
11080 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11082 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
11084 u32
*digest
= (u32
*) hash_buf
->digest
;
11086 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
11087 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
11091 digest
[0] = byte_swap_32 (digest
[0]);
11092 digest
[1] = byte_swap_32 (digest
[1]);
11094 return (PARSER_OK
);
11097 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11099 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11101 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
11105 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
11108 u32
*digest
= (u32
*) hash_buf
->digest
;
11110 salt_t
*salt
= hash_buf
->salt
;
11112 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11113 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11114 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11115 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11117 digest
[0] = byte_swap_32 (digest
[0]);
11118 digest
[1] = byte_swap_32 (digest
[1]);
11119 digest
[2] = byte_swap_32 (digest
[2]);
11120 digest
[3] = byte_swap_32 (digest
[3]);
11122 digest
[0] -= MD5M_A
;
11123 digest
[1] -= MD5M_B
;
11124 digest
[2] -= MD5M_C
;
11125 digest
[3] -= MD5M_D
;
11127 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11129 uint salt_len
= input_len
- 32 - 1;
11131 char *salt_buf
= input_buf
+ 32 + 1;
11133 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11135 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11137 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11139 salt
->salt_len
= salt_len
;
11141 return (PARSER_OK
);
11144 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11146 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
11148 u32
*digest
= (u32
*) hash_buf
->digest
;
11150 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11151 | itoa64_to_int (input_buf
[ 1]) << 6
11152 | itoa64_to_int (input_buf
[ 2]) << 12
11153 | itoa64_to_int (input_buf
[ 3]) << 18;
11154 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11155 | itoa64_to_int (input_buf
[ 5]) << 6
11156 | itoa64_to_int (input_buf
[ 6]) << 12
11157 | itoa64_to_int (input_buf
[ 7]) << 18;
11158 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11159 | itoa64_to_int (input_buf
[ 9]) << 6
11160 | itoa64_to_int (input_buf
[10]) << 12
11161 | itoa64_to_int (input_buf
[11]) << 18;
11162 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11163 | itoa64_to_int (input_buf
[13]) << 6
11164 | itoa64_to_int (input_buf
[14]) << 12
11165 | itoa64_to_int (input_buf
[15]) << 18;
11167 digest
[0] -= MD5M_A
;
11168 digest
[1] -= MD5M_B
;
11169 digest
[2] -= MD5M_C
;
11170 digest
[3] -= MD5M_D
;
11172 digest
[0] &= 0x00ffffff;
11173 digest
[1] &= 0x00ffffff;
11174 digest
[2] &= 0x00ffffff;
11175 digest
[3] &= 0x00ffffff;
11177 return (PARSER_OK
);
11180 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11182 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11184 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
11188 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
11191 u32
*digest
= (u32
*) hash_buf
->digest
;
11193 salt_t
*salt
= hash_buf
->salt
;
11195 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11196 | itoa64_to_int (input_buf
[ 1]) << 6
11197 | itoa64_to_int (input_buf
[ 2]) << 12
11198 | itoa64_to_int (input_buf
[ 3]) << 18;
11199 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11200 | itoa64_to_int (input_buf
[ 5]) << 6
11201 | itoa64_to_int (input_buf
[ 6]) << 12
11202 | itoa64_to_int (input_buf
[ 7]) << 18;
11203 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11204 | itoa64_to_int (input_buf
[ 9]) << 6
11205 | itoa64_to_int (input_buf
[10]) << 12
11206 | itoa64_to_int (input_buf
[11]) << 18;
11207 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11208 | itoa64_to_int (input_buf
[13]) << 6
11209 | itoa64_to_int (input_buf
[14]) << 12
11210 | itoa64_to_int (input_buf
[15]) << 18;
11212 digest
[0] -= MD5M_A
;
11213 digest
[1] -= MD5M_B
;
11214 digest
[2] -= MD5M_C
;
11215 digest
[3] -= MD5M_D
;
11217 digest
[0] &= 0x00ffffff;
11218 digest
[1] &= 0x00ffffff;
11219 digest
[2] &= 0x00ffffff;
11220 digest
[3] &= 0x00ffffff;
11222 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11224 uint salt_len
= input_len
- 16 - 1;
11226 char *salt_buf
= input_buf
+ 16 + 1;
11228 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11230 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11232 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11234 salt
->salt_len
= salt_len
;
11236 return (PARSER_OK
);
11239 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
11241 key
[0] = (nthash
[0] >> 0);
11242 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
11243 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
11244 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
11245 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
11246 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
11247 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
11248 key
[7] = (nthash
[6] << 1);
11260 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11262 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
11264 u32
*digest
= (u32
*) hash_buf
->digest
;
11266 salt_t
*salt
= hash_buf
->salt
;
11268 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11274 char *user_pos
= input_buf
;
11276 char *unused_pos
= strchr (user_pos
, ':');
11278 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11280 uint user_len
= unused_pos
- user_pos
;
11282 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11286 char *domain_pos
= strchr (unused_pos
, ':');
11288 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11290 uint unused_len
= domain_pos
- unused_pos
;
11292 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11296 char *srvchall_pos
= strchr (domain_pos
, ':');
11298 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11300 uint domain_len
= srvchall_pos
- domain_pos
;
11302 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11306 char *hash_pos
= strchr (srvchall_pos
, ':');
11308 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11310 uint srvchall_len
= hash_pos
- srvchall_pos
;
11312 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
11316 char *clichall_pos
= strchr (hash_pos
, ':');
11318 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11320 uint hash_len
= clichall_pos
- hash_pos
;
11322 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11326 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11328 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11331 * store some data for later use
11334 netntlm
->user_len
= user_len
* 2;
11335 netntlm
->domain_len
= domain_len
* 2;
11336 netntlm
->srvchall_len
= srvchall_len
/ 2;
11337 netntlm
->clichall_len
= clichall_len
/ 2;
11339 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11340 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11343 * handle username and domainname
11346 for (uint i
= 0; i
< user_len
; i
++)
11348 *userdomain_ptr
++ = user_pos
[i
];
11349 *userdomain_ptr
++ = 0;
11352 for (uint i
= 0; i
< domain_len
; i
++)
11354 *userdomain_ptr
++ = domain_pos
[i
];
11355 *userdomain_ptr
++ = 0;
11359 * handle server challenge encoding
11362 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11364 const char p0
= srvchall_pos
[i
+ 0];
11365 const char p1
= srvchall_pos
[i
+ 1];
11367 *chall_ptr
++ = hex_convert (p1
) << 0
11368 | hex_convert (p0
) << 4;
11372 * handle client challenge encoding
11375 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11377 const char p0
= clichall_pos
[i
+ 0];
11378 const char p1
= clichall_pos
[i
+ 1];
11380 *chall_ptr
++ = hex_convert (p1
) << 0
11381 | hex_convert (p0
) << 4;
11388 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11390 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11392 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11394 salt
->salt_len
= salt_len
;
11396 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11397 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11398 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11399 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11401 digest
[0] = byte_swap_32 (digest
[0]);
11402 digest
[1] = byte_swap_32 (digest
[1]);
11403 digest
[2] = byte_swap_32 (digest
[2]);
11404 digest
[3] = byte_swap_32 (digest
[3]);
11406 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11408 uint digest_tmp
[2] = { 0 };
11410 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11411 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11413 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11414 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11416 /* special case 2: ESS */
11418 if (srvchall_len
== 48)
11420 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11422 uint w
[16] = { 0 };
11424 w
[ 0] = netntlm
->chall_buf
[6];
11425 w
[ 1] = netntlm
->chall_buf
[7];
11426 w
[ 2] = netntlm
->chall_buf
[0];
11427 w
[ 3] = netntlm
->chall_buf
[1];
11431 uint dgst
[4] = { 0 };
11440 salt
->salt_buf
[0] = dgst
[0];
11441 salt
->salt_buf
[1] = dgst
[1];
11445 /* precompute netntlmv1 exploit start */
11447 for (uint i
= 0; i
< 0x10000; i
++)
11449 uint key_md4
[2] = { i
, 0 };
11450 uint key_des
[2] = { 0, 0 };
11452 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11454 uint Kc
[16] = { 0 };
11455 uint Kd
[16] = { 0 };
11457 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11459 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11461 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11463 if (data3
[0] != digest_tmp
[0]) continue;
11464 if (data3
[1] != digest_tmp
[1]) continue;
11466 salt
->salt_buf
[2] = i
;
11468 salt
->salt_len
= 24;
11473 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11474 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11476 /* precompute netntlmv1 exploit stop */
11480 IP (digest
[0], digest
[1], tt
);
11481 IP (digest
[2], digest
[3], tt
);
11483 digest
[0] = rotr32 (digest
[0], 29);
11484 digest
[1] = rotr32 (digest
[1], 29);
11485 digest
[2] = rotr32 (digest
[2], 29);
11486 digest
[3] = rotr32 (digest
[3], 29);
11488 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11490 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11491 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11493 return (PARSER_OK
);
11496 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11498 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11500 u32
*digest
= (u32
*) hash_buf
->digest
;
11502 salt_t
*salt
= hash_buf
->salt
;
11504 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11510 char *user_pos
= input_buf
;
11512 char *unused_pos
= strchr (user_pos
, ':');
11514 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11516 uint user_len
= unused_pos
- user_pos
;
11518 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11522 char *domain_pos
= strchr (unused_pos
, ':');
11524 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11526 uint unused_len
= domain_pos
- unused_pos
;
11528 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11532 char *srvchall_pos
= strchr (domain_pos
, ':');
11534 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11536 uint domain_len
= srvchall_pos
- domain_pos
;
11538 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11542 char *hash_pos
= strchr (srvchall_pos
, ':');
11544 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11546 uint srvchall_len
= hash_pos
- srvchall_pos
;
11548 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11552 char *clichall_pos
= strchr (hash_pos
, ':');
11554 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11556 uint hash_len
= clichall_pos
- hash_pos
;
11558 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11562 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11564 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11566 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11569 * store some data for later use
11572 netntlm
->user_len
= user_len
* 2;
11573 netntlm
->domain_len
= domain_len
* 2;
11574 netntlm
->srvchall_len
= srvchall_len
/ 2;
11575 netntlm
->clichall_len
= clichall_len
/ 2;
11577 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11578 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11581 * handle username and domainname
11584 for (uint i
= 0; i
< user_len
; i
++)
11586 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11587 *userdomain_ptr
++ = 0;
11590 for (uint i
= 0; i
< domain_len
; i
++)
11592 *userdomain_ptr
++ = domain_pos
[i
];
11593 *userdomain_ptr
++ = 0;
11596 *userdomain_ptr
++ = 0x80;
11599 * handle server challenge encoding
11602 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11604 const char p0
= srvchall_pos
[i
+ 0];
11605 const char p1
= srvchall_pos
[i
+ 1];
11607 *chall_ptr
++ = hex_convert (p1
) << 0
11608 | hex_convert (p0
) << 4;
11612 * handle client challenge encoding
11615 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11617 const char p0
= clichall_pos
[i
+ 0];
11618 const char p1
= clichall_pos
[i
+ 1];
11620 *chall_ptr
++ = hex_convert (p1
) << 0
11621 | hex_convert (p0
) << 4;
11624 *chall_ptr
++ = 0x80;
11627 * handle hash itself
11630 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11631 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11632 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11633 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11635 digest
[0] = byte_swap_32 (digest
[0]);
11636 digest
[1] = byte_swap_32 (digest
[1]);
11637 digest
[2] = byte_swap_32 (digest
[2]);
11638 digest
[3] = byte_swap_32 (digest
[3]);
11641 * reuse challange data as salt_buf, its the buffer that is most likely unique
11644 salt
->salt_buf
[0] = 0;
11645 salt
->salt_buf
[1] = 0;
11646 salt
->salt_buf
[2] = 0;
11647 salt
->salt_buf
[3] = 0;
11648 salt
->salt_buf
[4] = 0;
11649 salt
->salt_buf
[5] = 0;
11650 salt
->salt_buf
[6] = 0;
11651 salt
->salt_buf
[7] = 0;
11655 uptr
= (uint
*) netntlm
->userdomain_buf
;
11657 for (uint i
= 0; i
< 16; i
+= 16)
11659 md5_64 (uptr
, salt
->salt_buf
);
11662 uptr
= (uint
*) netntlm
->chall_buf
;
11664 for (uint i
= 0; i
< 256; i
+= 16)
11666 md5_64 (uptr
, salt
->salt_buf
);
11669 salt
->salt_len
= 16;
11671 return (PARSER_OK
);
11674 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11676 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11678 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11682 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11685 u32
*digest
= (u32
*) hash_buf
->digest
;
11687 salt_t
*salt
= hash_buf
->salt
;
11689 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11690 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11691 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11692 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11694 digest
[0] = byte_swap_32 (digest
[0]);
11695 digest
[1] = byte_swap_32 (digest
[1]);
11696 digest
[2] = byte_swap_32 (digest
[2]);
11697 digest
[3] = byte_swap_32 (digest
[3]);
11699 digest
[0] -= MD5M_A
;
11700 digest
[1] -= MD5M_B
;
11701 digest
[2] -= MD5M_C
;
11702 digest
[3] -= MD5M_D
;
11704 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11706 uint salt_len
= input_len
- 32 - 1;
11708 char *salt_buf
= input_buf
+ 32 + 1;
11710 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11712 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11714 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11716 salt
->salt_len
= salt_len
;
11718 return (PARSER_OK
);
11721 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11723 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11725 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11729 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11732 u32
*digest
= (u32
*) hash_buf
->digest
;
11734 salt_t
*salt
= hash_buf
->salt
;
11736 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11737 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11738 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11739 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11741 digest
[0] = byte_swap_32 (digest
[0]);
11742 digest
[1] = byte_swap_32 (digest
[1]);
11743 digest
[2] = byte_swap_32 (digest
[2]);
11744 digest
[3] = byte_swap_32 (digest
[3]);
11746 digest
[0] -= MD5M_A
;
11747 digest
[1] -= MD5M_B
;
11748 digest
[2] -= MD5M_C
;
11749 digest
[3] -= MD5M_D
;
11751 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11753 uint salt_len
= input_len
- 32 - 1;
11755 char *salt_buf
= input_buf
+ 32 + 1;
11757 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11759 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11761 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11763 salt
->salt_len
= salt_len
;
11765 return (PARSER_OK
);
11768 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11770 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11772 u32
*digest
= (u32
*) hash_buf
->digest
;
11774 salt_t
*salt
= hash_buf
->salt
;
11776 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11777 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11778 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11779 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11781 digest
[0] = byte_swap_32 (digest
[0]);
11782 digest
[1] = byte_swap_32 (digest
[1]);
11783 digest
[2] = byte_swap_32 (digest
[2]);
11784 digest
[3] = byte_swap_32 (digest
[3]);
11786 digest
[0] -= MD5M_A
;
11787 digest
[1] -= MD5M_B
;
11788 digest
[2] -= MD5M_C
;
11789 digest
[3] -= MD5M_D
;
11792 * This is a virtual salt. While the algorithm is basically not salted
11793 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11794 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11797 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11799 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11801 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11803 salt
->salt_len
= salt_len
;
11805 return (PARSER_OK
);
11808 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11810 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11812 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11816 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11819 u32
*digest
= (u32
*) hash_buf
->digest
;
11821 salt_t
*salt
= hash_buf
->salt
;
11823 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11824 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11825 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11826 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11828 digest
[0] = byte_swap_32 (digest
[0]);
11829 digest
[1] = byte_swap_32 (digest
[1]);
11830 digest
[2] = byte_swap_32 (digest
[2]);
11831 digest
[3] = byte_swap_32 (digest
[3]);
11833 digest
[0] -= MD5M_A
;
11834 digest
[1] -= MD5M_B
;
11835 digest
[2] -= MD5M_C
;
11836 digest
[3] -= MD5M_D
;
11838 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11840 uint salt_len
= input_len
- 32 - 1;
11842 char *salt_buf
= input_buf
+ 32 + 1;
11844 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11846 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11848 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11850 salt
->salt_len
= salt_len
;
11852 return (PARSER_OK
);
11855 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11857 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11859 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11863 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11866 u32
*digest
= (u32
*) hash_buf
->digest
;
11868 salt_t
*salt
= hash_buf
->salt
;
11870 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11871 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11872 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11873 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11875 digest
[0] = byte_swap_32 (digest
[0]);
11876 digest
[1] = byte_swap_32 (digest
[1]);
11877 digest
[2] = byte_swap_32 (digest
[2]);
11878 digest
[3] = byte_swap_32 (digest
[3]);
11880 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11882 uint salt_len
= input_len
- 32 - 1;
11884 char *salt_buf
= input_buf
+ 32 + 1;
11886 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11888 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11890 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11892 salt
->salt_len
= salt_len
;
11894 return (PARSER_OK
);
11897 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11899 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11901 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11905 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11908 u32
*digest
= (u32
*) hash_buf
->digest
;
11910 salt_t
*salt
= hash_buf
->salt
;
11912 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11913 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11914 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11915 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11917 digest
[0] = byte_swap_32 (digest
[0]);
11918 digest
[1] = byte_swap_32 (digest
[1]);
11919 digest
[2] = byte_swap_32 (digest
[2]);
11920 digest
[3] = byte_swap_32 (digest
[3]);
11922 digest
[0] -= MD4M_A
;
11923 digest
[1] -= MD4M_B
;
11924 digest
[2] -= MD4M_C
;
11925 digest
[3] -= MD4M_D
;
11927 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11929 uint salt_len
= input_len
- 32 - 1;
11931 char *salt_buf
= input_buf
+ 32 + 1;
11933 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11935 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11937 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11939 salt
->salt_len
= salt_len
;
11941 return (PARSER_OK
);
11944 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11946 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11948 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11952 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11955 u32
*digest
= (u32
*) hash_buf
->digest
;
11957 salt_t
*salt
= hash_buf
->salt
;
11959 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11960 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11961 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11962 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11964 digest
[0] = byte_swap_32 (digest
[0]);
11965 digest
[1] = byte_swap_32 (digest
[1]);
11966 digest
[2] = byte_swap_32 (digest
[2]);
11967 digest
[3] = byte_swap_32 (digest
[3]);
11969 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11971 uint salt_len
= input_len
- 32 - 1;
11973 char *salt_buf
= input_buf
+ 32 + 1;
11975 uint salt_pc_block
[16] = { 0 };
11977 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11979 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11981 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11983 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11985 salt_pc_block
[14] = salt_len
* 8;
11987 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11989 md5_64 (salt_pc_block
, salt_pc_digest
);
11991 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11992 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11993 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11994 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11996 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11998 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
12000 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
12002 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
12003 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
12004 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
12005 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
12007 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
12009 return (PARSER_OK
);
12012 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12014 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
12016 u32
*digest
= (u32
*) hash_buf
->digest
;
12018 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12019 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12020 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12021 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12022 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12024 digest
[0] -= SHA1M_A
;
12025 digest
[1] -= SHA1M_B
;
12026 digest
[2] -= SHA1M_C
;
12027 digest
[3] -= SHA1M_D
;
12028 digest
[4] -= SHA1M_E
;
12030 return (PARSER_OK
);
12033 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12035 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
12037 u32
*digest
= (u32
*) hash_buf
->digest
;
12039 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12040 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12041 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12042 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12043 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12045 return (PARSER_OK
);
12048 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12050 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
12052 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
12054 u32
*digest
= (u32
*) hash_buf
->digest
;
12058 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12059 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12060 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12061 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12062 digest
[4] = 0x00000000;
12064 return (PARSER_OK
);
12067 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12069 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12071 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
12075 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
12078 u32
*digest
= (u32
*) hash_buf
->digest
;
12080 salt_t
*salt
= hash_buf
->salt
;
12082 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12083 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12084 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12085 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12086 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12088 digest
[0] -= SHA1M_A
;
12089 digest
[1] -= SHA1M_B
;
12090 digest
[2] -= SHA1M_C
;
12091 digest
[3] -= SHA1M_D
;
12092 digest
[4] -= SHA1M_E
;
12094 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12096 uint salt_len
= input_len
- 40 - 1;
12098 char *salt_buf
= input_buf
+ 40 + 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 pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12113 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
12115 u32
*digest
= (u32
*) hash_buf
->digest
;
12117 salt_t
*salt
= hash_buf
->salt
;
12119 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
12121 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12122 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12123 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12124 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12125 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12127 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12129 uint salt_len
= input_len
- 40 - 1;
12131 char *salt_buf
= input_buf
+ 40 + 1;
12133 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
12135 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
12137 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
12139 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
12142 pstoken
->salt_len
= salt_len
/ 2;
12144 /* some fake salt for the sorting mechanisms */
12146 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
12147 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
12148 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
12149 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
12150 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
12151 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
12152 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
12153 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
12155 salt
->salt_len
= 32;
12157 /* we need to check if we can precompute some of the data --
12158 this is possible since the scheme is badly designed */
12160 pstoken
->pc_digest
[0] = SHA1M_A
;
12161 pstoken
->pc_digest
[1] = SHA1M_B
;
12162 pstoken
->pc_digest
[2] = SHA1M_C
;
12163 pstoken
->pc_digest
[3] = SHA1M_D
;
12164 pstoken
->pc_digest
[4] = SHA1M_E
;
12166 pstoken
->pc_offset
= 0;
12168 for (int i
= 0; i
< (int) pstoken
->salt_len
- 64; i
+= 64)
12172 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
12173 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
12174 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
12175 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
12176 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
12177 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
12178 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
12179 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
12180 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
12181 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
12182 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
12183 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
12184 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
12185 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
12186 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
12187 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
12189 sha1_64 (w
, pstoken
->pc_digest
);
12191 pstoken
->pc_offset
+= 16;
12194 return (PARSER_OK
);
12197 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12199 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
12201 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
12203 u32
*digest
= (u32
*) hash_buf
->digest
;
12205 u8 tmp_buf
[100] = { 0 };
12207 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
12209 memcpy (digest
, tmp_buf
, 20);
12211 digest
[0] = byte_swap_32 (digest
[0]);
12212 digest
[1] = byte_swap_32 (digest
[1]);
12213 digest
[2] = byte_swap_32 (digest
[2]);
12214 digest
[3] = byte_swap_32 (digest
[3]);
12215 digest
[4] = byte_swap_32 (digest
[4]);
12217 digest
[0] -= SHA1M_A
;
12218 digest
[1] -= SHA1M_B
;
12219 digest
[2] -= SHA1M_C
;
12220 digest
[3] -= SHA1M_D
;
12221 digest
[4] -= SHA1M_E
;
12223 return (PARSER_OK
);
12226 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12228 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
12230 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12232 u32
*digest
= (u32
*) hash_buf
->digest
;
12234 salt_t
*salt
= hash_buf
->salt
;
12236 u8 tmp_buf
[100] = { 0 };
12238 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
12240 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
12242 memcpy (digest
, tmp_buf
, 20);
12244 int salt_len
= tmp_len
- 20;
12246 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
12248 salt
->salt_len
= salt_len
;
12250 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
12252 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12254 char *ptr
= (char *) salt
->salt_buf
;
12256 ptr
[salt
->salt_len
] = 0x80;
12259 digest
[0] = byte_swap_32 (digest
[0]);
12260 digest
[1] = byte_swap_32 (digest
[1]);
12261 digest
[2] = byte_swap_32 (digest
[2]);
12262 digest
[3] = byte_swap_32 (digest
[3]);
12263 digest
[4] = byte_swap_32 (digest
[4]);
12265 digest
[0] -= SHA1M_A
;
12266 digest
[1] -= SHA1M_B
;
12267 digest
[2] -= SHA1M_C
;
12268 digest
[3] -= SHA1M_D
;
12269 digest
[4] -= SHA1M_E
;
12271 return (PARSER_OK
);
12274 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12276 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
12278 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12280 u32
*digest
= (u32
*) hash_buf
->digest
;
12282 salt_t
*salt
= hash_buf
->salt
;
12284 char *salt_buf
= input_buf
+ 6;
12288 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12290 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12292 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12294 salt
->salt_len
= salt_len
;
12296 char *hash_pos
= input_buf
+ 6 + 8 + 40;
12298 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12299 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12300 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12301 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12302 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12304 digest
[0] -= SHA1M_A
;
12305 digest
[1] -= SHA1M_B
;
12306 digest
[2] -= SHA1M_C
;
12307 digest
[3] -= SHA1M_D
;
12308 digest
[4] -= SHA1M_E
;
12310 return (PARSER_OK
);
12313 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12315 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
12317 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12319 u32
*digest
= (u32
*) hash_buf
->digest
;
12321 salt_t
*salt
= hash_buf
->salt
;
12323 char *salt_buf
= input_buf
+ 6;
12327 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12329 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12331 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12333 salt
->salt_len
= salt_len
;
12335 char *hash_pos
= input_buf
+ 6 + 8;
12337 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12338 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12339 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12340 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12341 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12343 digest
[0] -= SHA1M_A
;
12344 digest
[1] -= SHA1M_B
;
12345 digest
[2] -= SHA1M_C
;
12346 digest
[3] -= SHA1M_D
;
12347 digest
[4] -= SHA1M_E
;
12349 return (PARSER_OK
);
12352 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12354 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12356 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12358 u64
*digest
= (u64
*) hash_buf
->digest
;
12360 salt_t
*salt
= hash_buf
->salt
;
12362 char *salt_buf
= input_buf
+ 6;
12366 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12368 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12370 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12372 salt
->salt_len
= salt_len
;
12374 char *hash_pos
= input_buf
+ 6 + 8;
12376 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12377 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12378 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12379 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12380 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12381 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12382 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12383 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12385 digest
[0] -= SHA512M_A
;
12386 digest
[1] -= SHA512M_B
;
12387 digest
[2] -= SHA512M_C
;
12388 digest
[3] -= SHA512M_D
;
12389 digest
[4] -= SHA512M_E
;
12390 digest
[5] -= SHA512M_F
;
12391 digest
[6] -= SHA512M_G
;
12392 digest
[7] -= SHA512M_H
;
12394 return (PARSER_OK
);
12397 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12399 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12401 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12405 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12408 u32
*digest
= (u32
*) hash_buf
->digest
;
12410 salt_t
*salt
= hash_buf
->salt
;
12412 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12413 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12417 digest
[0] = byte_swap_32 (digest
[0]);
12418 digest
[1] = byte_swap_32 (digest
[1]);
12420 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12422 uint salt_len
= input_len
- 16 - 1;
12424 char *salt_buf
= input_buf
+ 16 + 1;
12426 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12428 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12430 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12432 salt
->salt_len
= salt_len
;
12434 return (PARSER_OK
);
12437 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12439 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12441 u32
*digest
= (u32
*) hash_buf
->digest
;
12443 salt_t
*salt
= hash_buf
->salt
;
12445 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12446 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12447 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12448 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12449 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12451 digest
[0] -= SHA1M_A
;
12452 digest
[1] -= SHA1M_B
;
12453 digest
[2] -= SHA1M_C
;
12454 digest
[3] -= SHA1M_D
;
12455 digest
[4] -= SHA1M_E
;
12457 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12459 uint salt_len
= input_len
- 40 - 1;
12461 char *salt_buf
= input_buf
+ 40 + 1;
12463 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12465 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12467 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12469 salt
->salt_len
= salt_len
;
12471 return (PARSER_OK
);
12474 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12476 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12478 u32
*digest
= (u32
*) hash_buf
->digest
;
12480 salt_t
*salt
= hash_buf
->salt
;
12482 char *hash_pos
= input_buf
;
12484 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12485 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12486 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12487 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12488 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12489 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12490 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12491 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12492 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12493 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12494 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12495 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12496 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12497 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12498 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12499 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12501 char *salt_pos
= input_buf
+ 128;
12503 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12504 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12505 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12506 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12508 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12509 salt
->salt_len
= 16;
12511 return (PARSER_OK
);
12514 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12516 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12518 u32
*digest
= (u32
*) hash_buf
->digest
;
12520 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12521 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12522 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12523 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12524 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12525 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12526 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12527 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12529 digest
[0] -= SHA256M_A
;
12530 digest
[1] -= SHA256M_B
;
12531 digest
[2] -= SHA256M_C
;
12532 digest
[3] -= SHA256M_D
;
12533 digest
[4] -= SHA256M_E
;
12534 digest
[5] -= SHA256M_F
;
12535 digest
[6] -= SHA256M_G
;
12536 digest
[7] -= SHA256M_H
;
12538 return (PARSER_OK
);
12541 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12543 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12545 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12549 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12552 u32
*digest
= (u32
*) hash_buf
->digest
;
12554 salt_t
*salt
= hash_buf
->salt
;
12556 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12557 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12558 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12559 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12560 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12561 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12562 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12563 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12565 digest
[0] -= SHA256M_A
;
12566 digest
[1] -= SHA256M_B
;
12567 digest
[2] -= SHA256M_C
;
12568 digest
[3] -= SHA256M_D
;
12569 digest
[4] -= SHA256M_E
;
12570 digest
[5] -= SHA256M_F
;
12571 digest
[6] -= SHA256M_G
;
12572 digest
[7] -= SHA256M_H
;
12574 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12576 uint salt_len
= input_len
- 64 - 1;
12578 char *salt_buf
= input_buf
+ 64 + 1;
12580 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12582 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12584 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12586 salt
->salt_len
= salt_len
;
12588 return (PARSER_OK
);
12591 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12593 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12595 u64
*digest
= (u64
*) hash_buf
->digest
;
12597 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12598 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12599 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12600 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12601 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12602 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12606 digest
[0] -= SHA384M_A
;
12607 digest
[1] -= SHA384M_B
;
12608 digest
[2] -= SHA384M_C
;
12609 digest
[3] -= SHA384M_D
;
12610 digest
[4] -= SHA384M_E
;
12611 digest
[5] -= SHA384M_F
;
12615 return (PARSER_OK
);
12618 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12620 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12622 u64
*digest
= (u64
*) hash_buf
->digest
;
12624 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12625 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12626 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12627 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12628 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12629 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12630 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12631 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12633 digest
[0] -= SHA512M_A
;
12634 digest
[1] -= SHA512M_B
;
12635 digest
[2] -= SHA512M_C
;
12636 digest
[3] -= SHA512M_D
;
12637 digest
[4] -= SHA512M_E
;
12638 digest
[5] -= SHA512M_F
;
12639 digest
[6] -= SHA512M_G
;
12640 digest
[7] -= SHA512M_H
;
12642 return (PARSER_OK
);
12645 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12647 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12649 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12653 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12656 u64
*digest
= (u64
*) hash_buf
->digest
;
12658 salt_t
*salt
= hash_buf
->salt
;
12660 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12661 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12662 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12663 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12664 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12665 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12666 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12667 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12669 digest
[0] -= SHA512M_A
;
12670 digest
[1] -= SHA512M_B
;
12671 digest
[2] -= SHA512M_C
;
12672 digest
[3] -= SHA512M_D
;
12673 digest
[4] -= SHA512M_E
;
12674 digest
[5] -= SHA512M_F
;
12675 digest
[6] -= SHA512M_G
;
12676 digest
[7] -= SHA512M_H
;
12678 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12680 uint salt_len
= input_len
- 128 - 1;
12682 char *salt_buf
= input_buf
+ 128 + 1;
12684 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12686 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12688 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12690 salt
->salt_len
= salt_len
;
12692 return (PARSER_OK
);
12695 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12697 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12699 u64
*digest
= (u64
*) hash_buf
->digest
;
12701 salt_t
*salt
= hash_buf
->salt
;
12703 char *salt_pos
= input_buf
+ 3;
12705 uint iterations_len
= 0;
12707 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12711 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12713 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12714 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12718 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12722 iterations_len
+= 8;
12726 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12729 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12731 char *hash_pos
= strchr (salt_pos
, '$');
12733 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12735 uint salt_len
= hash_pos
- salt_pos
;
12737 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12739 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12741 salt
->salt_len
= salt_len
;
12745 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12747 return (PARSER_OK
);
12750 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12752 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12754 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12756 u64
*digest
= (u64
*) hash_buf
->digest
;
12758 salt_t
*salt
= hash_buf
->salt
;
12760 uint keccak_mdlen
= input_len
/ 2;
12762 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12764 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12766 digest
[i
] = byte_swap_64 (digest
[i
]);
12769 salt
->keccak_mdlen
= keccak_mdlen
;
12771 return (PARSER_OK
);
12774 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12776 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12778 u32
*digest
= (u32
*) hash_buf
->digest
;
12780 salt_t
*salt
= hash_buf
->salt
;
12782 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12785 * Parse that strange long line
12790 size_t in_len
[9] = { 0 };
12792 in_off
[0] = strtok (input_buf
, ":");
12794 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12796 in_len
[0] = strlen (in_off
[0]);
12800 for (i
= 1; i
< 9; i
++)
12802 in_off
[i
] = strtok (NULL
, ":");
12804 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12806 in_len
[i
] = strlen (in_off
[i
]);
12809 char *ptr
= (char *) ikepsk
->msg_buf
;
12811 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12812 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12813 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12814 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12815 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12816 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12820 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12822 ptr
= (char *) ikepsk
->nr_buf
;
12824 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12825 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12829 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12832 * Store to database
12837 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12838 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12839 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12840 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12842 digest
[0] = byte_swap_32 (digest
[0]);
12843 digest
[1] = byte_swap_32 (digest
[1]);
12844 digest
[2] = byte_swap_32 (digest
[2]);
12845 digest
[3] = byte_swap_32 (digest
[3]);
12847 salt
->salt_len
= 32;
12849 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12850 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12851 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12852 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12853 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12854 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12855 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12856 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12858 return (PARSER_OK
);
12861 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12863 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12865 u32
*digest
= (u32
*) hash_buf
->digest
;
12867 salt_t
*salt
= hash_buf
->salt
;
12869 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12872 * Parse that strange long line
12877 size_t in_len
[9] = { 0 };
12879 in_off
[0] = strtok (input_buf
, ":");
12881 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12883 in_len
[0] = strlen (in_off
[0]);
12887 for (i
= 1; i
< 9; i
++)
12889 in_off
[i
] = strtok (NULL
, ":");
12891 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12893 in_len
[i
] = strlen (in_off
[i
]);
12896 char *ptr
= (char *) ikepsk
->msg_buf
;
12898 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12899 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12900 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12901 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12902 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12903 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12907 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12909 ptr
= (char *) ikepsk
->nr_buf
;
12911 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12912 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12916 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12919 * Store to database
12924 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12925 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12926 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12927 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12928 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12930 salt
->salt_len
= 32;
12932 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12933 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12934 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12935 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12936 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12937 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12938 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12939 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12941 return (PARSER_OK
);
12944 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12946 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12948 u32
*digest
= (u32
*) hash_buf
->digest
;
12950 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12951 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12952 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12953 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12954 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12956 digest
[0] = byte_swap_32 (digest
[0]);
12957 digest
[1] = byte_swap_32 (digest
[1]);
12958 digest
[2] = byte_swap_32 (digest
[2]);
12959 digest
[3] = byte_swap_32 (digest
[3]);
12960 digest
[4] = byte_swap_32 (digest
[4]);
12962 return (PARSER_OK
);
12965 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12967 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12969 u32
*digest
= (u32
*) hash_buf
->digest
;
12971 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12972 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12973 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12974 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12975 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12976 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12977 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12978 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12979 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12980 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12981 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12982 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12983 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12984 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12985 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12986 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12988 return (PARSER_OK
);
12991 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12993 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12995 u32
*digest
= (u32
*) hash_buf
->digest
;
12997 salt_t
*salt
= hash_buf
->salt
;
12999 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13000 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13001 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13002 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13003 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13005 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13007 uint salt_len
= input_len
- 40 - 1;
13009 char *salt_buf
= input_buf
+ 40 + 1;
13011 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13013 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13015 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13017 salt
->salt_len
= salt_len
;
13019 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
13021 return (PARSER_OK
);
13024 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13026 u32
*digest
= (u32
*) hash_buf
->digest
;
13028 salt_t
*salt
= hash_buf
->salt
;
13030 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13032 if (input_len
== 0)
13034 log_error ("TrueCrypt container not specified");
13039 FILE *fp
= fopen (input_buf
, "rb");
13043 log_error ("%s: %s", input_buf
, strerror (errno
));
13048 char buf
[512] = { 0 };
13050 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13054 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13056 memcpy (tc
->salt_buf
, buf
, 64);
13058 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13060 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13062 salt
->salt_len
= 4;
13064 salt
->salt_iter
= ROUNDS_TRUECRYPT_1K
- 1;
13066 tc
->signature
= 0x45555254; // "TRUE"
13068 digest
[0] = tc
->data_buf
[0];
13070 return (PARSER_OK
);
13073 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13075 u32
*digest
= (u32
*) hash_buf
->digest
;
13077 salt_t
*salt
= hash_buf
->salt
;
13079 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13081 if (input_len
== 0)
13083 log_error ("TrueCrypt container not specified");
13088 FILE *fp
= fopen (input_buf
, "rb");
13092 log_error ("%s: %s", input_buf
, strerror (errno
));
13097 char buf
[512] = { 0 };
13099 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13103 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13105 memcpy (tc
->salt_buf
, buf
, 64);
13107 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13109 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13111 salt
->salt_len
= 4;
13113 salt
->salt_iter
= ROUNDS_TRUECRYPT_2K
- 1;
13115 tc
->signature
= 0x45555254; // "TRUE"
13117 digest
[0] = tc
->data_buf
[0];
13119 return (PARSER_OK
);
13122 int veracrypt_parse_hash_200000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13124 u32
*digest
= (u32
*) hash_buf
->digest
;
13126 salt_t
*salt
= hash_buf
->salt
;
13128 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13130 if (input_len
== 0)
13132 log_error ("VeraCrypt container not specified");
13137 FILE *fp
= fopen (input_buf
, "rb");
13141 log_error ("%s: %s", input_buf
, strerror (errno
));
13146 char buf
[512] = { 0 };
13148 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13152 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13154 memcpy (tc
->salt_buf
, buf
, 64);
13156 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13158 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13160 salt
->salt_len
= 4;
13162 salt
->salt_iter
= ROUNDS_VERACRYPT_200000
- 1;
13164 tc
->signature
= 0x41524556; // "VERA"
13166 digest
[0] = tc
->data_buf
[0];
13168 return (PARSER_OK
);
13171 int veracrypt_parse_hash_500000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13173 u32
*digest
= (u32
*) hash_buf
->digest
;
13175 salt_t
*salt
= hash_buf
->salt
;
13177 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13179 if (input_len
== 0)
13181 log_error ("VeraCrypt container not specified");
13186 FILE *fp
= fopen (input_buf
, "rb");
13190 log_error ("%s: %s", input_buf
, strerror (errno
));
13195 char buf
[512] = { 0 };
13197 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13201 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13203 memcpy (tc
->salt_buf
, buf
, 64);
13205 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13207 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13209 salt
->salt_len
= 4;
13211 salt
->salt_iter
= ROUNDS_VERACRYPT_500000
- 1;
13213 tc
->signature
= 0x41524556; // "VERA"
13215 digest
[0] = tc
->data_buf
[0];
13217 return (PARSER_OK
);
13220 int veracrypt_parse_hash_327661 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13222 u32
*digest
= (u32
*) hash_buf
->digest
;
13224 salt_t
*salt
= hash_buf
->salt
;
13226 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13228 if (input_len
== 0)
13230 log_error ("VeraCrypt container not specified");
13235 FILE *fp
= fopen (input_buf
, "rb");
13239 log_error ("%s: %s", input_buf
, strerror (errno
));
13244 char buf
[512] = { 0 };
13246 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13250 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13252 memcpy (tc
->salt_buf
, buf
, 64);
13254 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13256 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13258 salt
->salt_len
= 4;
13260 salt
->salt_iter
= ROUNDS_VERACRYPT_327661
- 1;
13262 tc
->signature
= 0x41524556; // "VERA"
13264 digest
[0] = tc
->data_buf
[0];
13266 return (PARSER_OK
);
13269 int veracrypt_parse_hash_655331 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13271 u32
*digest
= (u32
*) hash_buf
->digest
;
13273 salt_t
*salt
= hash_buf
->salt
;
13275 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13277 if (input_len
== 0)
13279 log_error ("VeraCrypt container not specified");
13284 FILE *fp
= fopen (input_buf
, "rb");
13288 log_error ("%s: %s", input_buf
, strerror (errno
));
13293 char buf
[512] = { 0 };
13295 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13299 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13301 memcpy (tc
->salt_buf
, buf
, 64);
13303 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13305 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13307 salt
->salt_len
= 4;
13309 salt
->salt_iter
= ROUNDS_VERACRYPT_655331
- 1;
13311 tc
->signature
= 0x41524556; // "VERA"
13313 digest
[0] = tc
->data_buf
[0];
13315 return (PARSER_OK
);
13318 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13320 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
13322 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13324 u32
*digest
= (u32
*) hash_buf
->digest
;
13326 salt_t
*salt
= hash_buf
->salt
;
13328 char *salt_pos
= input_buf
+ 6;
13330 char *hash_pos
= strchr (salt_pos
, '$');
13332 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13334 uint salt_len
= hash_pos
- salt_pos
;
13336 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
13338 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13340 salt
->salt_len
= salt_len
;
13342 salt
->salt_iter
= 1000;
13346 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13348 return (PARSER_OK
);
13351 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13353 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
13355 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
13357 u32
*digest
= (u32
*) hash_buf
->digest
;
13359 salt_t
*salt
= hash_buf
->salt
;
13361 char *iter_pos
= input_buf
+ 7;
13363 char *salt_pos
= strchr (iter_pos
, '$');
13365 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13369 char *hash_pos
= strchr (salt_pos
, '$');
13371 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13373 uint salt_len
= hash_pos
- salt_pos
;
13375 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13377 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13379 salt
->salt_len
= salt_len
;
13381 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13383 salt
->salt_sign
[0] = atoi (salt_iter
);
13385 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13389 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13391 digest
[0] = byte_swap_32 (digest
[0]);
13392 digest
[1] = byte_swap_32 (digest
[1]);
13393 digest
[2] = byte_swap_32 (digest
[2]);
13394 digest
[3] = byte_swap_32 (digest
[3]);
13395 digest
[4] = byte_swap_32 (digest
[4]);
13397 return (PARSER_OK
);
13400 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13402 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
13404 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13406 u32
*digest
= (u32
*) hash_buf
->digest
;
13408 salt_t
*salt
= hash_buf
->salt
;
13410 char *iter_pos
= input_buf
+ 9;
13412 char *salt_pos
= strchr (iter_pos
, '$');
13414 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13418 char *hash_pos
= strchr (salt_pos
, '$');
13420 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13422 uint salt_len
= hash_pos
- salt_pos
;
13424 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13426 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13428 salt
->salt_len
= salt_len
;
13430 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13432 salt
->salt_sign
[0] = atoi (salt_iter
);
13434 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13438 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13440 digest
[0] = byte_swap_32 (digest
[0]);
13441 digest
[1] = byte_swap_32 (digest
[1]);
13442 digest
[2] = byte_swap_32 (digest
[2]);
13443 digest
[3] = byte_swap_32 (digest
[3]);
13444 digest
[4] = byte_swap_32 (digest
[4]);
13445 digest
[5] = byte_swap_32 (digest
[5]);
13446 digest
[6] = byte_swap_32 (digest
[6]);
13447 digest
[7] = byte_swap_32 (digest
[7]);
13449 return (PARSER_OK
);
13452 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13454 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
13456 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13458 u64
*digest
= (u64
*) hash_buf
->digest
;
13460 salt_t
*salt
= hash_buf
->salt
;
13462 char *iter_pos
= input_buf
+ 9;
13464 char *salt_pos
= strchr (iter_pos
, '$');
13466 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13470 char *hash_pos
= strchr (salt_pos
, '$');
13472 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13474 uint salt_len
= hash_pos
- salt_pos
;
13476 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13478 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13480 salt
->salt_len
= salt_len
;
13482 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13484 salt
->salt_sign
[0] = atoi (salt_iter
);
13486 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13490 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13492 digest
[0] = byte_swap_64 (digest
[0]);
13493 digest
[1] = byte_swap_64 (digest
[1]);
13494 digest
[2] = byte_swap_64 (digest
[2]);
13495 digest
[3] = byte_swap_64 (digest
[3]);
13496 digest
[4] = byte_swap_64 (digest
[4]);
13497 digest
[5] = byte_swap_64 (digest
[5]);
13498 digest
[6] = byte_swap_64 (digest
[6]);
13499 digest
[7] = byte_swap_64 (digest
[7]);
13501 return (PARSER_OK
);
13504 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13506 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
13508 u32
*digest
= (u32
*) hash_buf
->digest
;
13510 salt_t
*salt
= hash_buf
->salt
;
13512 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
13518 char *iterations_pos
= input_buf
;
13520 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13522 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13524 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13526 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13530 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13532 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13534 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13536 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13538 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13540 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13545 * pbkdf2 iterations
13548 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13551 * handle salt encoding
13554 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13556 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13558 const char p0
= saltbuf_pos
[i
+ 0];
13559 const char p1
= saltbuf_pos
[i
+ 1];
13561 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13562 | hex_convert (p0
) << 4;
13565 salt
->salt_len
= saltbuf_len
/ 2;
13568 * handle cipher encoding
13571 uint
*tmp
= (uint
*) mymalloc (32);
13573 char *cipherbuf_ptr
= (char *) tmp
;
13575 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13577 const char p0
= cipherbuf_pos
[i
+ 0];
13578 const char p1
= cipherbuf_pos
[i
+ 1];
13580 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13581 | hex_convert (p0
) << 4;
13584 // iv is stored at salt_buf 4 (length 16)
13585 // data is stored at salt_buf 8 (length 16)
13587 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13588 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13589 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13590 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13592 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13593 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13594 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13595 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13599 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13601 const char p0
= cipherbuf_pos
[j
+ 0];
13602 const char p1
= cipherbuf_pos
[j
+ 1];
13604 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13605 | hex_convert (p0
) << 4;
13612 digest
[0] = 0x10101010;
13613 digest
[1] = 0x10101010;
13614 digest
[2] = 0x10101010;
13615 digest
[3] = 0x10101010;
13617 return (PARSER_OK
);
13620 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13622 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13624 u32
*digest
= (u32
*) hash_buf
->digest
;
13626 salt_t
*salt
= hash_buf
->salt
;
13628 char *hashbuf_pos
= input_buf
;
13630 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13632 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13634 uint hash_len
= iterations_pos
- hashbuf_pos
;
13636 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13640 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13642 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13644 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13648 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13650 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13652 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13654 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13656 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13658 salt
->salt_len
= salt_len
;
13660 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13662 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13663 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13664 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13665 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13667 return (PARSER_OK
);
13670 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13672 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13674 u32
*digest
= (u32
*) hash_buf
->digest
;
13676 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13677 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13678 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13679 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13680 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13681 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13682 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13683 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13685 digest
[0] = byte_swap_32 (digest
[0]);
13686 digest
[1] = byte_swap_32 (digest
[1]);
13687 digest
[2] = byte_swap_32 (digest
[2]);
13688 digest
[3] = byte_swap_32 (digest
[3]);
13689 digest
[4] = byte_swap_32 (digest
[4]);
13690 digest
[5] = byte_swap_32 (digest
[5]);
13691 digest
[6] = byte_swap_32 (digest
[6]);
13692 digest
[7] = byte_swap_32 (digest
[7]);
13694 return (PARSER_OK
);
13697 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13699 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13701 u32
*digest
= (u32
*) hash_buf
->digest
;
13703 salt_t
*salt
= hash_buf
->salt
;
13705 char *salt_pos
= input_buf
+ 3;
13707 uint iterations_len
= 0;
13709 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13713 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13715 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13716 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13720 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13724 iterations_len
+= 8;
13728 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13731 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13733 char *hash_pos
= strchr (salt_pos
, '$');
13735 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13737 uint salt_len
= hash_pos
- salt_pos
;
13739 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13741 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13743 salt
->salt_len
= salt_len
;
13747 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13749 return (PARSER_OK
);
13752 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13754 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13756 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13758 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13760 u64
*digest
= (u64
*) hash_buf
->digest
;
13762 salt_t
*salt
= hash_buf
->salt
;
13764 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13766 char *iter_pos
= input_buf
+ 4;
13768 char *salt_pos
= strchr (iter_pos
, '$');
13770 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13774 char *hash_pos
= strchr (salt_pos
, '$');
13776 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13778 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13782 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13783 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13784 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13785 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13786 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13787 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13788 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13789 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13791 uint salt_len
= hash_pos
- salt_pos
- 1;
13793 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13795 salt
->salt_len
= salt_len
/ 2;
13797 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13798 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13799 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13800 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13801 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13802 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13803 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13804 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13806 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13807 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13808 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13809 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13810 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13811 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13812 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13813 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13814 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13815 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13817 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13819 salt
->salt_iter
= atoi (iter_pos
) - 1;
13821 return (PARSER_OK
);
13824 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13826 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13828 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13830 u32
*digest
= (u32
*) hash_buf
->digest
;
13832 salt_t
*salt
= hash_buf
->salt
;
13834 char *salt_pos
= input_buf
+ 14;
13836 char *hash_pos
= strchr (salt_pos
, '*');
13838 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13842 uint salt_len
= hash_pos
- salt_pos
- 1;
13844 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13846 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13848 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13850 salt
->salt_len
= salt_len
;
13852 u8 tmp_buf
[100] = { 0 };
13854 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13856 memcpy (digest
, tmp_buf
, 32);
13858 digest
[0] = byte_swap_32 (digest
[0]);
13859 digest
[1] = byte_swap_32 (digest
[1]);
13860 digest
[2] = byte_swap_32 (digest
[2]);
13861 digest
[3] = byte_swap_32 (digest
[3]);
13862 digest
[4] = byte_swap_32 (digest
[4]);
13863 digest
[5] = byte_swap_32 (digest
[5]);
13864 digest
[6] = byte_swap_32 (digest
[6]);
13865 digest
[7] = byte_swap_32 (digest
[7]);
13867 digest
[0] -= SHA256M_A
;
13868 digest
[1] -= SHA256M_B
;
13869 digest
[2] -= SHA256M_C
;
13870 digest
[3] -= SHA256M_D
;
13871 digest
[4] -= SHA256M_E
;
13872 digest
[5] -= SHA256M_F
;
13873 digest
[6] -= SHA256M_G
;
13874 digest
[7] -= SHA256M_H
;
13876 return (PARSER_OK
);
13879 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13881 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13883 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13885 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13887 u64
*digest
= (u64
*) hash_buf
->digest
;
13889 salt_t
*salt
= hash_buf
->salt
;
13891 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13893 char *iter_pos
= input_buf
+ 19;
13895 char *salt_pos
= strchr (iter_pos
, '.');
13897 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13901 char *hash_pos
= strchr (salt_pos
, '.');
13903 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13905 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13909 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13910 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13911 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13912 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13913 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13914 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13915 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13916 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13918 uint salt_len
= hash_pos
- salt_pos
- 1;
13922 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13926 for (i
= 0; i
< salt_len
; i
++)
13928 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13931 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13932 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13934 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13936 salt
->salt_len
= salt_len
;
13938 salt
->salt_iter
= atoi (iter_pos
) - 1;
13940 return (PARSER_OK
);
13943 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13945 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13947 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13949 u64
*digest
= (u64
*) hash_buf
->digest
;
13951 salt_t
*salt
= hash_buf
->salt
;
13953 u8 tmp_buf
[120] = { 0 };
13955 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13957 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13959 memcpy (digest
, tmp_buf
, 64);
13961 digest
[0] = byte_swap_64 (digest
[0]);
13962 digest
[1] = byte_swap_64 (digest
[1]);
13963 digest
[2] = byte_swap_64 (digest
[2]);
13964 digest
[3] = byte_swap_64 (digest
[3]);
13965 digest
[4] = byte_swap_64 (digest
[4]);
13966 digest
[5] = byte_swap_64 (digest
[5]);
13967 digest
[6] = byte_swap_64 (digest
[6]);
13968 digest
[7] = byte_swap_64 (digest
[7]);
13970 digest
[0] -= SHA512M_A
;
13971 digest
[1] -= SHA512M_B
;
13972 digest
[2] -= SHA512M_C
;
13973 digest
[3] -= SHA512M_D
;
13974 digest
[4] -= SHA512M_E
;
13975 digest
[5] -= SHA512M_F
;
13976 digest
[6] -= SHA512M_G
;
13977 digest
[7] -= SHA512M_H
;
13979 int salt_len
= tmp_len
- 64;
13981 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13983 salt
->salt_len
= salt_len
;
13985 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13987 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13989 char *ptr
= (char *) salt
->salt_buf
;
13991 ptr
[salt
->salt_len
] = 0x80;
13994 return (PARSER_OK
);
13997 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13999 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14001 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
14005 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
14008 u32
*digest
= (u32
*) hash_buf
->digest
;
14010 salt_t
*salt
= hash_buf
->salt
;
14012 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14013 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14014 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14015 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14017 digest
[0] = byte_swap_32 (digest
[0]);
14018 digest
[1] = byte_swap_32 (digest
[1]);
14019 digest
[2] = byte_swap_32 (digest
[2]);
14020 digest
[3] = byte_swap_32 (digest
[3]);
14022 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14024 uint salt_len
= input_len
- 32 - 1;
14026 char *salt_buf
= input_buf
+ 32 + 1;
14028 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14030 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14032 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14034 salt
->salt_len
= salt_len
;
14036 return (PARSER_OK
);
14039 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14041 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14043 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
14047 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
14050 u32
*digest
= (u32
*) hash_buf
->digest
;
14052 salt_t
*salt
= hash_buf
->salt
;
14054 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14055 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14056 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14057 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14058 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14060 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14062 uint salt_len
= input_len
- 40 - 1;
14064 char *salt_buf
= input_buf
+ 40 + 1;
14066 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14068 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14070 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14072 salt
->salt_len
= salt_len
;
14074 return (PARSER_OK
);
14077 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14079 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14081 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
14085 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
14088 u32
*digest
= (u32
*) hash_buf
->digest
;
14090 salt_t
*salt
= hash_buf
->salt
;
14092 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14093 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14094 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14095 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14096 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14097 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
14098 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
14099 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
14101 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14103 uint salt_len
= input_len
- 64 - 1;
14105 char *salt_buf
= input_buf
+ 64 + 1;
14107 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14109 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14111 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14113 salt
->salt_len
= salt_len
;
14115 return (PARSER_OK
);
14118 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14120 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14122 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
14126 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
14129 u64
*digest
= (u64
*) hash_buf
->digest
;
14131 salt_t
*salt
= hash_buf
->salt
;
14133 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
14134 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
14135 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
14136 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
14137 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
14138 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
14139 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
14140 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
14142 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14144 uint salt_len
= input_len
- 128 - 1;
14146 char *salt_buf
= input_buf
+ 128 + 1;
14148 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14150 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14152 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14154 salt
->salt_len
= salt_len
;
14156 return (PARSER_OK
);
14159 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14161 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
14163 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
14165 u32
*digest
= (u32
*) hash_buf
->digest
;
14167 salt_t
*salt
= hash_buf
->salt
;
14169 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
14175 char *user_pos
= input_buf
+ 10 + 1;
14177 char *realm_pos
= strchr (user_pos
, '$');
14179 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14181 uint user_len
= realm_pos
- user_pos
;
14183 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
14187 char *salt_pos
= strchr (realm_pos
, '$');
14189 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14191 uint realm_len
= salt_pos
- realm_pos
;
14193 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
14197 char *data_pos
= strchr (salt_pos
, '$');
14199 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14201 uint salt_len
= data_pos
- salt_pos
;
14203 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
14207 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
14209 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
14215 memcpy (krb5pa
->user
, user_pos
, user_len
);
14216 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
14217 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
14219 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
14221 for (uint i
= 0; i
< (36 * 2); i
+= 2)
14223 const char p0
= data_pos
[i
+ 0];
14224 const char p1
= data_pos
[i
+ 1];
14226 *timestamp_ptr
++ = hex_convert (p1
) << 0
14227 | hex_convert (p0
) << 4;
14230 char *checksum_ptr
= (char *) krb5pa
->checksum
;
14232 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
14234 const char p0
= data_pos
[i
+ 0];
14235 const char p1
= data_pos
[i
+ 1];
14237 *checksum_ptr
++ = hex_convert (p1
) << 0
14238 | hex_convert (p0
) << 4;
14242 * copy some data to generic buffers to make sorting happy
14245 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
14246 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
14247 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
14248 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
14249 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
14250 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
14251 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
14252 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
14253 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
14255 salt
->salt_len
= 36;
14257 digest
[0] = krb5pa
->checksum
[0];
14258 digest
[1] = krb5pa
->checksum
[1];
14259 digest
[2] = krb5pa
->checksum
[2];
14260 digest
[3] = krb5pa
->checksum
[3];
14262 return (PARSER_OK
);
14265 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14267 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
14269 u32
*digest
= (u32
*) hash_buf
->digest
;
14271 salt_t
*salt
= hash_buf
->salt
;
14277 char *salt_pos
= input_buf
;
14279 char *hash_pos
= strchr (salt_pos
, '$');
14281 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14283 uint salt_len
= hash_pos
- salt_pos
;
14285 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14289 uint hash_len
= input_len
- 1 - salt_len
;
14291 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14299 for (uint i
= 0; i
< salt_len
; i
++)
14301 if (salt_pos
[i
] == ' ') continue;
14306 // SAP user names cannot be longer than 12 characters
14307 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14309 // SAP user name cannot start with ! or ?
14310 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14316 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14318 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14320 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14322 salt
->salt_len
= salt_len
;
14324 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
14325 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
14329 digest
[0] = byte_swap_32 (digest
[0]);
14330 digest
[1] = byte_swap_32 (digest
[1]);
14332 return (PARSER_OK
);
14335 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14337 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
14339 u32
*digest
= (u32
*) hash_buf
->digest
;
14341 salt_t
*salt
= hash_buf
->salt
;
14347 char *salt_pos
= input_buf
;
14349 char *hash_pos
= strchr (salt_pos
, '$');
14351 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14353 uint salt_len
= hash_pos
- salt_pos
;
14355 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14359 uint hash_len
= input_len
- 1 - salt_len
;
14361 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
14369 for (uint i
= 0; i
< salt_len
; i
++)
14371 if (salt_pos
[i
] == ' ') continue;
14376 // SAP user names cannot be longer than 12 characters
14377 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
14378 // so far nobody complained so we stay with this because it helps in optimization
14379 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
14381 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14383 // SAP user name cannot start with ! or ?
14384 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14390 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14392 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14394 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14396 salt
->salt_len
= salt_len
;
14398 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14399 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14400 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14401 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14402 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14404 return (PARSER_OK
);
14407 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14409 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
14411 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14413 u64
*digest
= (u64
*) hash_buf
->digest
;
14415 salt_t
*salt
= hash_buf
->salt
;
14417 char *iter_pos
= input_buf
+ 3;
14419 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
14421 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
14423 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
14425 salt
->salt_iter
= salt_iter
;
14427 char *salt_pos
= iter_pos
+ 1;
14431 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
14433 salt
->salt_len
= salt_len
;
14435 char *hash_pos
= salt_pos
+ salt_len
;
14437 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14441 char *tmp
= (char *) salt
->salt_buf_pc
;
14443 tmp
[0] = hash_pos
[42];
14447 digest
[ 0] = byte_swap_64 (digest
[ 0]);
14448 digest
[ 1] = byte_swap_64 (digest
[ 1]);
14449 digest
[ 2] = byte_swap_64 (digest
[ 2]);
14450 digest
[ 3] = byte_swap_64 (digest
[ 3]);
14456 return (PARSER_OK
);
14459 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14461 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
14463 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14465 u32
*digest
= (u32
*) hash_buf
->digest
;
14467 salt_t
*salt
= hash_buf
->salt
;
14469 char *salt_buf
= input_buf
+ 6;
14471 uint salt_len
= 16;
14473 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14475 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14477 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14479 salt
->salt_len
= salt_len
;
14481 char *hash_pos
= input_buf
+ 6 + 16;
14483 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14484 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14485 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14486 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14487 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14488 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
14489 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
14490 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
14492 return (PARSER_OK
);
14495 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14497 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
14499 u32
*digest
= (u32
*) hash_buf
->digest
;
14501 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14502 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14506 return (PARSER_OK
);
14509 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14511 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
14513 u32
*digest
= (u32
*) hash_buf
->digest
;
14515 salt_t
*salt
= hash_buf
->salt
;
14517 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
14519 char *saltbuf_pos
= input_buf
;
14521 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
14523 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14525 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14527 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14528 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14530 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14534 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14536 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14538 char *salt_ptr
= (char *) saltbuf_pos
;
14539 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14544 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14546 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14549 rakp_ptr
[j
] = 0x80;
14551 rakp
->salt_len
= j
;
14553 for (i
= 0; i
< 64; i
++)
14555 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14558 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14559 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14560 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14561 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14562 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14563 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14564 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14565 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14567 salt
->salt_len
= 32; // muss min. 32 haben
14569 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14570 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14571 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14572 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14573 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14575 return (PARSER_OK
);
14578 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14580 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14582 u32
*digest
= (u32
*) hash_buf
->digest
;
14584 salt_t
*salt
= hash_buf
->salt
;
14586 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14588 char *salt_pos
= input_buf
+ 1;
14590 memcpy (salt
->salt_buf
, salt_pos
, 8);
14592 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14593 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14595 salt
->salt_len
= 8;
14597 char *hash_pos
= salt_pos
+ 8;
14599 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14600 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14601 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14602 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14603 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14605 digest
[0] -= SHA1M_A
;
14606 digest
[1] -= SHA1M_B
;
14607 digest
[2] -= SHA1M_C
;
14608 digest
[3] -= SHA1M_D
;
14609 digest
[4] -= SHA1M_E
;
14611 return (PARSER_OK
);
14614 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14616 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14618 u32
*digest
= (u32
*) hash_buf
->digest
;
14620 salt_t
*salt
= hash_buf
->salt
;
14622 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14623 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14624 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14625 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14627 digest
[0] = byte_swap_32 (digest
[0]);
14628 digest
[1] = byte_swap_32 (digest
[1]);
14629 digest
[2] = byte_swap_32 (digest
[2]);
14630 digest
[3] = byte_swap_32 (digest
[3]);
14632 digest
[0] -= MD5M_A
;
14633 digest
[1] -= MD5M_B
;
14634 digest
[2] -= MD5M_C
;
14635 digest
[3] -= MD5M_D
;
14637 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14639 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14641 u32
*salt_buf
= salt
->salt_buf
;
14643 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14644 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14645 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14646 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14648 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14649 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14650 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14651 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14653 salt
->salt_len
= 16 + 1;
14655 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14657 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14659 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14661 return (PARSER_OK
);
14664 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14666 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14668 u32
*digest
= (u32
*) hash_buf
->digest
;
14670 salt_t
*salt
= hash_buf
->salt
;
14672 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14678 char *hashbuf_pos
= input_buf
;
14680 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14682 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14684 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14686 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14690 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14692 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14694 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14696 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14700 char *databuf_pos
= strchr (iteration_pos
, ':');
14702 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14704 const uint iteration_len
= databuf_pos
- iteration_pos
;
14706 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14707 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14709 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14711 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14712 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14718 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14719 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14720 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14721 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14722 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14723 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14724 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14725 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14729 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14731 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14733 const char p0
= saltbuf_pos
[i
+ 0];
14734 const char p1
= saltbuf_pos
[i
+ 1];
14736 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14737 | hex_convert (p0
) << 4;
14740 salt
->salt_buf
[4] = 0x01000000;
14741 salt
->salt_buf
[5] = 0x80;
14743 salt
->salt_len
= saltbuf_len
/ 2;
14747 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14751 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14753 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14755 const char p0
= databuf_pos
[i
+ 0];
14756 const char p1
= databuf_pos
[i
+ 1];
14758 *databuf_ptr
++ = hex_convert (p1
) << 0
14759 | hex_convert (p0
) << 4;
14762 *databuf_ptr
++ = 0x80;
14764 for (uint i
= 0; i
< 512; i
++)
14766 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14769 cloudkey
->data_len
= databuf_len
/ 2;
14771 return (PARSER_OK
);
14774 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14776 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14778 u32
*digest
= (u32
*) hash_buf
->digest
;
14780 salt_t
*salt
= hash_buf
->salt
;
14786 char *hashbuf_pos
= input_buf
;
14788 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14790 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14792 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14794 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14798 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14800 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14802 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14804 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14806 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14810 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14812 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14814 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14816 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14818 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14822 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14824 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14825 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14827 // ok, the plan for this algorithm is the following:
14828 // we have 2 salts here, the domain-name and a random salt
14829 // while both are used in the initial transformation,
14830 // only the random salt is used in the following iterations
14831 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14832 // and one that includes only the real salt (stored into salt_buf[]).
14833 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14835 u8 tmp_buf
[100] = { 0 };
14837 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14839 memcpy (digest
, tmp_buf
, 20);
14841 digest
[0] = byte_swap_32 (digest
[0]);
14842 digest
[1] = byte_swap_32 (digest
[1]);
14843 digest
[2] = byte_swap_32 (digest
[2]);
14844 digest
[3] = byte_swap_32 (digest
[3]);
14845 digest
[4] = byte_swap_32 (digest
[4]);
14849 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14851 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14853 char *len_ptr
= NULL
;
14855 for (uint i
= 0; i
< domainbuf_len
; i
++)
14857 if (salt_buf_pc_ptr
[i
] == '.')
14859 len_ptr
= &salt_buf_pc_ptr
[i
];
14869 salt
->salt_buf_pc
[7] = domainbuf_len
;
14873 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14875 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14877 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14879 salt
->salt_len
= salt_len
;
14883 salt
->salt_iter
= atoi (iteration_pos
);
14885 return (PARSER_OK
);
14888 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14890 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14892 u32
*digest
= (u32
*) hash_buf
->digest
;
14894 salt_t
*salt
= hash_buf
->salt
;
14896 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14897 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14898 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14899 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14900 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14902 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14904 uint salt_len
= input_len
- 40 - 1;
14906 char *salt_buf
= input_buf
+ 40 + 1;
14908 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14910 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14912 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14914 salt
->salt_len
= salt_len
;
14916 return (PARSER_OK
);
14919 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14921 const u8 ascii_to_ebcdic
[] =
14923 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14924 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14925 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14926 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14927 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14928 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14929 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14930 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14931 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14932 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14933 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14934 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14935 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14936 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14937 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14938 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14941 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14943 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14945 u32
*digest
= (u32
*) hash_buf
->digest
;
14947 salt_t
*salt
= hash_buf
->salt
;
14949 char *salt_pos
= input_buf
+ 6 + 1;
14951 char *digest_pos
= strchr (salt_pos
, '*');
14953 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14955 uint salt_len
= digest_pos
- salt_pos
;
14957 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14959 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14961 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14965 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14966 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14968 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14970 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14972 salt
->salt_len
= salt_len
;
14974 for (uint i
= 0; i
< salt_len
; i
++)
14976 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14978 for (uint i
= salt_len
; i
< 8; i
++)
14980 salt_buf_pc_ptr
[i
] = 0x40;
14985 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14987 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14988 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14990 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14991 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14993 digest
[0] = byte_swap_32 (digest
[0]);
14994 digest
[1] = byte_swap_32 (digest
[1]);
14996 IP (digest
[0], digest
[1], tt
);
14998 digest
[0] = rotr32 (digest
[0], 29);
14999 digest
[1] = rotr32 (digest
[1], 29);
15003 return (PARSER_OK
);
15006 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15008 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
15010 u32
*digest
= (u32
*) hash_buf
->digest
;
15012 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15013 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15014 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15015 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15017 digest
[0] = byte_swap_32 (digest
[0]);
15018 digest
[1] = byte_swap_32 (digest
[1]);
15019 digest
[2] = byte_swap_32 (digest
[2]);
15020 digest
[3] = byte_swap_32 (digest
[3]);
15022 return (PARSER_OK
);
15025 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15027 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
15029 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15031 u32
*digest
= (u32
*) hash_buf
->digest
;
15033 salt_t
*salt
= hash_buf
->salt
;
15035 u8 tmp_buf
[120] = { 0 };
15037 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15039 tmp_buf
[3] += -4; // dont ask!
15041 memcpy (salt
->salt_buf
, tmp_buf
, 5);
15043 salt
->salt_len
= 5;
15045 memcpy (digest
, tmp_buf
+ 5, 9);
15047 // yes, only 9 byte are needed to crack, but 10 to display
15049 salt
->salt_buf_pc
[7] = input_buf
[20];
15051 return (PARSER_OK
);
15054 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15056 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
15058 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15060 u32
*digest
= (u32
*) hash_buf
->digest
;
15062 salt_t
*salt
= hash_buf
->salt
;
15064 u8 tmp_buf
[120] = { 0 };
15066 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15068 tmp_buf
[3] += -4; // dont ask!
15072 memcpy (salt
->salt_buf
, tmp_buf
, 16);
15074 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)
15078 char tmp_iter_buf
[11] = { 0 };
15080 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
15082 tmp_iter_buf
[10] = 0;
15084 salt
->salt_iter
= atoi (tmp_iter_buf
);
15086 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
15088 return (PARSER_SALT_ITERATION
);
15091 salt
->salt_iter
--; // first round in init
15093 // 2 additional bytes for display only
15095 salt
->salt_buf_pc
[0] = tmp_buf
[26];
15096 salt
->salt_buf_pc
[1] = tmp_buf
[27];
15100 memcpy (digest
, tmp_buf
+ 28, 8);
15102 digest
[0] = byte_swap_32 (digest
[0]);
15103 digest
[1] = byte_swap_32 (digest
[1]);
15107 return (PARSER_OK
);
15110 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15112 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
15114 u32
*digest
= (u32
*) hash_buf
->digest
;
15116 salt_t
*salt
= hash_buf
->salt
;
15118 char *salt_buf_pos
= input_buf
;
15120 char *hash_buf_pos
= salt_buf_pos
+ 6;
15122 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
15123 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
15124 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
15125 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
15126 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
15127 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
15128 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
15129 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
15131 digest
[0] -= SHA256M_A
;
15132 digest
[1] -= SHA256M_B
;
15133 digest
[2] -= SHA256M_C
;
15134 digest
[3] -= SHA256M_D
;
15135 digest
[4] -= SHA256M_E
;
15136 digest
[5] -= SHA256M_F
;
15137 digest
[6] -= SHA256M_G
;
15138 digest
[7] -= SHA256M_H
;
15140 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15142 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
15144 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15146 salt
->salt_len
= salt_len
;
15148 return (PARSER_OK
);
15151 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15153 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
15155 u32
*digest
= (u32
*) hash_buf
->digest
;
15157 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15159 salt_t
*salt
= hash_buf
->salt
;
15161 char *salt_buf
= input_buf
+ 6;
15163 char *digest_buf
= strchr (salt_buf
, '$');
15165 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15167 uint salt_len
= digest_buf
- salt_buf
;
15169 digest_buf
++; // skip the '$' symbol
15171 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15173 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15175 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15177 salt
->salt_len
= salt_len
;
15179 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15180 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15181 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15182 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15184 digest
[0] = byte_swap_32 (digest
[0]);
15185 digest
[1] = byte_swap_32 (digest
[1]);
15186 digest
[2] = byte_swap_32 (digest
[2]);
15187 digest
[3] = byte_swap_32 (digest
[3]);
15189 digest
[0] -= MD5M_A
;
15190 digest
[1] -= MD5M_B
;
15191 digest
[2] -= MD5M_C
;
15192 digest
[3] -= MD5M_D
;
15194 return (PARSER_OK
);
15197 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15199 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
15201 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15203 u32
*digest
= (u32
*) hash_buf
->digest
;
15205 salt_t
*salt
= hash_buf
->salt
;
15207 char *salt_buf
= input_buf
+ 3;
15209 char *digest_buf
= strchr (salt_buf
, '$');
15211 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15213 uint salt_len
= digest_buf
- salt_buf
;
15215 digest_buf
++; // skip the '$' symbol
15217 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15219 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15221 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15223 salt_buf_ptr
[salt_len
] = 0x2d;
15225 salt
->salt_len
= salt_len
+ 1;
15227 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15228 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15229 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15230 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15232 digest
[0] = byte_swap_32 (digest
[0]);
15233 digest
[1] = byte_swap_32 (digest
[1]);
15234 digest
[2] = byte_swap_32 (digest
[2]);
15235 digest
[3] = byte_swap_32 (digest
[3]);
15237 digest
[0] -= MD5M_A
;
15238 digest
[1] -= MD5M_B
;
15239 digest
[2] -= MD5M_C
;
15240 digest
[3] -= MD5M_D
;
15242 return (PARSER_OK
);
15245 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15247 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
15249 u32
*digest
= (u32
*) hash_buf
->digest
;
15251 salt_t
*salt
= hash_buf
->salt
;
15253 u8 tmp_buf
[100] = { 0 };
15255 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
15257 memcpy (digest
, tmp_buf
, 20);
15259 digest
[0] = byte_swap_32 (digest
[0]);
15260 digest
[1] = byte_swap_32 (digest
[1]);
15261 digest
[2] = byte_swap_32 (digest
[2]);
15262 digest
[3] = byte_swap_32 (digest
[3]);
15263 digest
[4] = byte_swap_32 (digest
[4]);
15265 digest
[0] -= SHA1M_A
;
15266 digest
[1] -= SHA1M_B
;
15267 digest
[2] -= SHA1M_C
;
15268 digest
[3] -= SHA1M_D
;
15269 digest
[4] -= SHA1M_E
;
15271 salt
->salt_buf
[0] = 0x80;
15273 salt
->salt_len
= 0;
15275 return (PARSER_OK
);
15278 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15280 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
15282 u32
*digest
= (u32
*) hash_buf
->digest
;
15284 salt_t
*salt
= hash_buf
->salt
;
15286 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15287 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15288 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15289 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15291 digest
[0] = byte_swap_32 (digest
[0]);
15292 digest
[1] = byte_swap_32 (digest
[1]);
15293 digest
[2] = byte_swap_32 (digest
[2]);
15294 digest
[3] = byte_swap_32 (digest
[3]);
15296 digest
[0] -= MD5M_A
;
15297 digest
[1] -= MD5M_B
;
15298 digest
[2] -= MD5M_C
;
15299 digest
[3] -= MD5M_D
;
15301 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15303 uint salt_len
= input_len
- 32 - 1;
15305 char *salt_buf
= input_buf
+ 32 + 1;
15307 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15309 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15311 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15314 * add static "salt" part
15317 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
15321 salt
->salt_len
= salt_len
;
15323 return (PARSER_OK
);
15326 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15328 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
15330 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
15332 u32
*digest
= (u32
*) hash_buf
->digest
;
15334 salt_t
*salt
= hash_buf
->salt
;
15336 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
15342 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
15344 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
15346 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15348 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
15350 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
15354 char *keylen_pos
= strchr (saltbuf_pos
, '$');
15356 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15358 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
15360 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15364 char *keybuf_pos
= strchr (keylen_pos
, '$');
15366 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15368 uint keylen_len
= keybuf_pos
- keylen_pos
;
15370 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
15374 char *databuf_pos
= strchr (keybuf_pos
, '$');
15376 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15378 uint keybuf_len
= databuf_pos
- keybuf_pos
;
15380 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15384 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
15386 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
15392 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
15393 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
15394 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
15395 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
15397 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
15398 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
15399 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
15400 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
15402 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15403 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15404 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15405 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15407 salt
->salt_len
= 16;
15408 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
15410 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
15412 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
15415 return (PARSER_OK
);
15418 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15420 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
15422 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15424 u32
*digest
= (u32
*) hash_buf
->digest
;
15426 salt_t
*salt
= hash_buf
->salt
;
15432 // first is the N salt parameter
15434 char *N_pos
= input_buf
+ 6;
15436 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15440 salt
->scrypt_N
= atoi (N_pos
);
15444 char *r_pos
= strchr (N_pos
, ':');
15446 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15450 salt
->scrypt_r
= atoi (r_pos
);
15454 char *p_pos
= strchr (r_pos
, ':');
15456 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15460 salt
->scrypt_p
= atoi (p_pos
);
15464 char *saltbuf_pos
= strchr (p_pos
, ':');
15466 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15470 char *hash_pos
= strchr (saltbuf_pos
, ':');
15472 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15478 int salt_len_base64
= hash_pos
- saltbuf_pos
;
15480 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
15482 u8 tmp_buf
[33] = { 0 };
15484 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
15486 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15488 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
15490 salt
->salt_len
= tmp_len
;
15491 salt
->salt_iter
= 1;
15493 // digest - base64 decode
15495 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15497 tmp_len
= input_len
- (hash_pos
- input_buf
);
15499 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
15501 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
15503 memcpy (digest
, tmp_buf
, 32);
15505 return (PARSER_OK
);
15508 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15510 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
15512 u32
*digest
= (u32
*) hash_buf
->digest
;
15514 salt_t
*salt
= hash_buf
->salt
;
15520 char decrypted
[76] = { 0 }; // iv + hash
15522 juniper_decrypt_hash (input_buf
, decrypted
);
15524 char *md5crypt_hash
= decrypted
+ 12;
15526 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15528 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15530 char *salt_pos
= md5crypt_hash
+ 3;
15532 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15534 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15536 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15540 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15542 return (PARSER_OK
);
15545 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15547 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15549 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15551 u32
*digest
= (u32
*) hash_buf
->digest
;
15553 salt_t
*salt
= hash_buf
->salt
;
15555 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15561 // first is *raw* salt
15563 char *salt_pos
= input_buf
+ 3;
15565 char *hash_pos
= strchr (salt_pos
, '$');
15567 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15569 uint salt_len
= hash_pos
- salt_pos
;
15571 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15575 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15577 memcpy (salt_buf_ptr
, salt_pos
, 14);
15579 salt_buf_ptr
[17] = 0x01;
15580 salt_buf_ptr
[18] = 0x80;
15582 // add some stuff to normal salt to make sorted happy
15584 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15585 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15586 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15587 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15589 salt
->salt_len
= salt_len
;
15590 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15592 // base64 decode hash
15594 u8 tmp_buf
[100] = { 0 };
15596 uint hash_len
= input_len
- 3 - salt_len
- 1;
15598 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15600 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15602 memcpy (digest
, tmp_buf
, 32);
15604 digest
[0] = byte_swap_32 (digest
[0]);
15605 digest
[1] = byte_swap_32 (digest
[1]);
15606 digest
[2] = byte_swap_32 (digest
[2]);
15607 digest
[3] = byte_swap_32 (digest
[3]);
15608 digest
[4] = byte_swap_32 (digest
[4]);
15609 digest
[5] = byte_swap_32 (digest
[5]);
15610 digest
[6] = byte_swap_32 (digest
[6]);
15611 digest
[7] = byte_swap_32 (digest
[7]);
15613 return (PARSER_OK
);
15616 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15618 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15620 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15622 u32
*digest
= (u32
*) hash_buf
->digest
;
15624 salt_t
*salt
= hash_buf
->salt
;
15630 // first is *raw* salt
15632 char *salt_pos
= input_buf
+ 3;
15634 char *hash_pos
= strchr (salt_pos
, '$');
15636 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15638 uint salt_len
= hash_pos
- salt_pos
;
15640 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15642 salt
->salt_len
= salt_len
;
15645 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15647 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15648 salt_buf_ptr
[salt_len
] = 0;
15650 // base64 decode hash
15652 u8 tmp_buf
[100] = { 0 };
15654 uint hash_len
= input_len
- 3 - salt_len
- 1;
15656 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15658 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15660 memcpy (digest
, tmp_buf
, 32);
15663 salt
->scrypt_N
= 16384;
15664 salt
->scrypt_r
= 1;
15665 salt
->scrypt_p
= 1;
15666 salt
->salt_iter
= 1;
15668 return (PARSER_OK
);
15671 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15673 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15675 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15677 u32
*digest
= (u32
*) hash_buf
->digest
;
15679 salt_t
*salt
= hash_buf
->salt
;
15681 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15687 char *version_pos
= input_buf
+ 8 + 1;
15689 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15691 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15693 u32 version_len
= verifierHashSize_pos
- version_pos
;
15695 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15697 verifierHashSize_pos
++;
15699 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15701 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15703 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15705 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15709 char *saltSize_pos
= strchr (keySize_pos
, '*');
15711 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15713 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15715 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15719 char *osalt_pos
= strchr (saltSize_pos
, '*');
15721 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15723 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15725 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15729 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15731 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15733 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15735 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15737 encryptedVerifier_pos
++;
15739 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15741 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15743 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15745 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15747 encryptedVerifierHash_pos
++;
15749 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;
15751 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15753 const uint version
= atoi (version_pos
);
15755 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15757 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15759 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15761 const uint keySize
= atoi (keySize_pos
);
15763 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15765 office2007
->keySize
= keySize
;
15767 const uint saltSize
= atoi (saltSize_pos
);
15769 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15775 salt
->salt_len
= 16;
15776 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15778 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15779 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15780 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15781 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15787 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15788 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15789 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15790 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15792 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15793 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15794 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15795 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15796 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15802 digest
[0] = office2007
->encryptedVerifierHash
[0];
15803 digest
[1] = office2007
->encryptedVerifierHash
[1];
15804 digest
[2] = office2007
->encryptedVerifierHash
[2];
15805 digest
[3] = office2007
->encryptedVerifierHash
[3];
15807 return (PARSER_OK
);
15810 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15812 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15814 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15816 u32
*digest
= (u32
*) hash_buf
->digest
;
15818 salt_t
*salt
= hash_buf
->salt
;
15820 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15826 char *version_pos
= input_buf
+ 8 + 1;
15828 char *spinCount_pos
= strchr (version_pos
, '*');
15830 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15832 u32 version_len
= spinCount_pos
- version_pos
;
15834 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15838 char *keySize_pos
= strchr (spinCount_pos
, '*');
15840 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15842 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15844 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15848 char *saltSize_pos
= strchr (keySize_pos
, '*');
15850 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15852 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15854 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15858 char *osalt_pos
= strchr (saltSize_pos
, '*');
15860 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15862 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15864 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15868 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15870 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15872 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15874 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15876 encryptedVerifier_pos
++;
15878 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15880 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15882 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15884 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15886 encryptedVerifierHash_pos
++;
15888 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;
15890 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15892 const uint version
= atoi (version_pos
);
15894 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15896 const uint spinCount
= atoi (spinCount_pos
);
15898 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15900 const uint keySize
= atoi (keySize_pos
);
15902 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15904 const uint saltSize
= atoi (saltSize_pos
);
15906 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15912 salt
->salt_len
= 16;
15913 salt
->salt_iter
= spinCount
;
15915 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15916 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15917 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15918 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15924 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15925 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15926 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15927 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15929 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15930 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15931 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15932 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15933 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15934 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15935 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15936 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15942 digest
[0] = office2010
->encryptedVerifierHash
[0];
15943 digest
[1] = office2010
->encryptedVerifierHash
[1];
15944 digest
[2] = office2010
->encryptedVerifierHash
[2];
15945 digest
[3] = office2010
->encryptedVerifierHash
[3];
15947 return (PARSER_OK
);
15950 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15952 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15954 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15956 u32
*digest
= (u32
*) hash_buf
->digest
;
15958 salt_t
*salt
= hash_buf
->salt
;
15960 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15966 char *version_pos
= input_buf
+ 8 + 1;
15968 char *spinCount_pos
= strchr (version_pos
, '*');
15970 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15972 u32 version_len
= spinCount_pos
- version_pos
;
15974 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15978 char *keySize_pos
= strchr (spinCount_pos
, '*');
15980 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15982 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15984 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15988 char *saltSize_pos
= strchr (keySize_pos
, '*');
15990 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15992 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15994 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15998 char *osalt_pos
= strchr (saltSize_pos
, '*');
16000 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16002 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
16004 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
16008 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16010 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16012 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16014 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16016 encryptedVerifier_pos
++;
16018 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16020 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16022 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16024 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16026 encryptedVerifierHash_pos
++;
16028 u32 encryptedVerifierHash_len
= input_len
- 8 - 1 - version_len
- 1 - spinCount_len
- 1 - keySize_len
- 1 - saltSize_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16030 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
16032 const uint version
= atoi (version_pos
);
16034 if (version
!= 2013) return (PARSER_SALT_VALUE
);
16036 const uint spinCount
= atoi (spinCount_pos
);
16038 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
16040 const uint keySize
= atoi (keySize_pos
);
16042 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
16044 const uint saltSize
= atoi (saltSize_pos
);
16046 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
16052 salt
->salt_len
= 16;
16053 salt
->salt_iter
= spinCount
;
16055 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16056 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16057 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16058 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16064 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16065 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16066 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16067 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16069 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16070 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16071 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16072 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16073 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16074 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
16075 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
16076 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
16082 digest
[0] = office2013
->encryptedVerifierHash
[0];
16083 digest
[1] = office2013
->encryptedVerifierHash
[1];
16084 digest
[2] = office2013
->encryptedVerifierHash
[2];
16085 digest
[3] = office2013
->encryptedVerifierHash
[3];
16087 return (PARSER_OK
);
16090 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16092 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
16094 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16096 u32
*digest
= (u32
*) hash_buf
->digest
;
16098 salt_t
*salt
= hash_buf
->salt
;
16100 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16106 char *version_pos
= input_buf
+ 11;
16108 char *osalt_pos
= strchr (version_pos
, '*');
16110 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16112 u32 version_len
= osalt_pos
- version_pos
;
16114 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16118 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16120 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16122 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16124 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16126 encryptedVerifier_pos
++;
16128 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16130 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16132 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16134 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16136 encryptedVerifierHash_pos
++;
16138 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16140 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16142 const uint version
= *version_pos
- 0x30;
16144 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16150 oldoffice01
->version
= version
;
16152 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16153 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16154 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16155 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16157 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16158 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16159 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16160 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16162 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16163 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16164 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16165 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16167 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16168 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16169 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16170 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16176 salt
->salt_len
= 16;
16178 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16179 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16180 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16181 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16183 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16184 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16185 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16186 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16188 // this is a workaround as office produces multiple documents with the same salt
16190 salt
->salt_len
+= 32;
16192 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16193 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16194 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16195 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16196 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16197 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16198 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16199 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16205 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
16206 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
16207 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
16208 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
16210 return (PARSER_OK
);
16213 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16215 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
16218 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16220 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
16222 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16224 u32
*digest
= (u32
*) hash_buf
->digest
;
16226 salt_t
*salt
= hash_buf
->salt
;
16228 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16234 char *version_pos
= input_buf
+ 11;
16236 char *osalt_pos
= strchr (version_pos
, '*');
16238 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16240 u32 version_len
= osalt_pos
- version_pos
;
16242 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16246 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16248 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16250 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16252 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16254 encryptedVerifier_pos
++;
16256 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16258 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16260 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16262 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16264 encryptedVerifierHash_pos
++;
16266 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16268 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16270 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16272 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16276 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16278 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16280 const uint version
= *version_pos
- 0x30;
16282 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16288 oldoffice01
->version
= version
;
16290 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16291 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16292 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16293 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16295 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16296 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16297 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16298 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16300 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16301 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16302 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16303 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16305 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16306 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16307 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16308 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16310 oldoffice01
->rc4key
[1] = 0;
16311 oldoffice01
->rc4key
[0] = 0;
16313 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16314 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16315 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16316 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16317 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16318 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16319 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16320 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16321 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16322 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16324 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
16325 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
16331 salt
->salt_len
= 16;
16333 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16334 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16335 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16336 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16338 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16339 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16340 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16341 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16343 // this is a workaround as office produces multiple documents with the same salt
16345 salt
->salt_len
+= 32;
16347 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16348 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16349 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16350 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16351 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16352 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16353 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16354 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16360 digest
[0] = oldoffice01
->rc4key
[0];
16361 digest
[1] = oldoffice01
->rc4key
[1];
16365 return (PARSER_OK
);
16368 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16370 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
16372 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16374 u32
*digest
= (u32
*) hash_buf
->digest
;
16376 salt_t
*salt
= hash_buf
->salt
;
16378 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16384 char *version_pos
= input_buf
+ 11;
16386 char *osalt_pos
= strchr (version_pos
, '*');
16388 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16390 u32 version_len
= osalt_pos
- version_pos
;
16392 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16396 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16398 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16400 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16402 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16404 encryptedVerifier_pos
++;
16406 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16408 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16410 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16412 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16414 encryptedVerifierHash_pos
++;
16416 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16418 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16420 const uint version
= *version_pos
- 0x30;
16422 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16428 oldoffice34
->version
= version
;
16430 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16431 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16432 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16433 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16435 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16436 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16437 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16438 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16440 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16441 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16442 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16443 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16444 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16446 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16447 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16448 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16449 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16450 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16456 salt
->salt_len
= 16;
16458 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16459 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16460 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16461 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16463 // this is a workaround as office produces multiple documents with the same salt
16465 salt
->salt_len
+= 32;
16467 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16468 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16469 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16470 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16471 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16472 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16473 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16474 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16480 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
16481 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
16482 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
16483 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
16485 return (PARSER_OK
);
16488 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16490 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16492 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
16495 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16497 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
16499 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16501 u32
*digest
= (u32
*) hash_buf
->digest
;
16503 salt_t
*salt
= hash_buf
->salt
;
16505 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16511 char *version_pos
= input_buf
+ 11;
16513 char *osalt_pos
= strchr (version_pos
, '*');
16515 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16517 u32 version_len
= osalt_pos
- version_pos
;
16519 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16523 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16525 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16527 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16529 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16531 encryptedVerifier_pos
++;
16533 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16535 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16537 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16539 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16541 encryptedVerifierHash_pos
++;
16543 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16545 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16547 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16549 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16553 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16555 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16557 const uint version
= *version_pos
- 0x30;
16559 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16565 oldoffice34
->version
= version
;
16567 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16568 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16569 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16570 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16572 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16573 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16574 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16575 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16577 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16578 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16579 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16580 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16581 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16583 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16584 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16585 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16586 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16587 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16589 oldoffice34
->rc4key
[1] = 0;
16590 oldoffice34
->rc4key
[0] = 0;
16592 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16593 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16594 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16595 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16596 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16597 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16598 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16599 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16600 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16601 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16603 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16604 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16610 salt
->salt_len
= 16;
16612 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16613 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16614 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16615 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16617 // this is a workaround as office produces multiple documents with the same salt
16619 salt
->salt_len
+= 32;
16621 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16622 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16623 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16624 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16625 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16626 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16627 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16628 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16634 digest
[0] = oldoffice34
->rc4key
[0];
16635 digest
[1] = oldoffice34
->rc4key
[1];
16639 return (PARSER_OK
);
16642 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16644 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16646 u32
*digest
= (u32
*) hash_buf
->digest
;
16648 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16649 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16650 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16651 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16653 digest
[0] = byte_swap_32 (digest
[0]);
16654 digest
[1] = byte_swap_32 (digest
[1]);
16655 digest
[2] = byte_swap_32 (digest
[2]);
16656 digest
[3] = byte_swap_32 (digest
[3]);
16658 return (PARSER_OK
);
16661 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16663 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16665 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16667 u32
*digest
= (u32
*) hash_buf
->digest
;
16669 salt_t
*salt
= hash_buf
->salt
;
16671 char *signature_pos
= input_buf
;
16673 char *salt_pos
= strchr (signature_pos
, '$');
16675 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16677 u32 signature_len
= salt_pos
- signature_pos
;
16679 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16683 char *hash_pos
= strchr (salt_pos
, '$');
16685 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16687 u32 salt_len
= hash_pos
- salt_pos
;
16689 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16693 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16695 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16697 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16698 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16699 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16700 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16701 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16703 digest
[0] -= SHA1M_A
;
16704 digest
[1] -= SHA1M_B
;
16705 digest
[2] -= SHA1M_C
;
16706 digest
[3] -= SHA1M_D
;
16707 digest
[4] -= SHA1M_E
;
16709 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16711 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16713 salt
->salt_len
= salt_len
;
16715 return (PARSER_OK
);
16718 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16720 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16722 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16724 u32
*digest
= (u32
*) hash_buf
->digest
;
16726 salt_t
*salt
= hash_buf
->salt
;
16728 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16734 char *iter_pos
= input_buf
+ 14;
16736 const int iter
= atoi (iter_pos
);
16738 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16740 salt
->salt_iter
= iter
- 1;
16742 char *salt_pos
= strchr (iter_pos
, '$');
16744 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16748 char *hash_pos
= strchr (salt_pos
, '$');
16750 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16752 const uint salt_len
= hash_pos
- salt_pos
;
16756 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16758 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16760 salt
->salt_len
= salt_len
;
16762 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16763 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16765 // add some stuff to normal salt to make sorted happy
16767 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16768 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16769 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16770 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16771 salt
->salt_buf
[4] = salt
->salt_iter
;
16773 // base64 decode hash
16775 u8 tmp_buf
[100] = { 0 };
16777 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16779 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16781 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16783 memcpy (digest
, tmp_buf
, 32);
16785 digest
[0] = byte_swap_32 (digest
[0]);
16786 digest
[1] = byte_swap_32 (digest
[1]);
16787 digest
[2] = byte_swap_32 (digest
[2]);
16788 digest
[3] = byte_swap_32 (digest
[3]);
16789 digest
[4] = byte_swap_32 (digest
[4]);
16790 digest
[5] = byte_swap_32 (digest
[5]);
16791 digest
[6] = byte_swap_32 (digest
[6]);
16792 digest
[7] = byte_swap_32 (digest
[7]);
16794 return (PARSER_OK
);
16797 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16799 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16801 u32
*digest
= (u32
*) hash_buf
->digest
;
16803 salt_t
*salt
= hash_buf
->salt
;
16805 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16806 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16810 digest
[0] = byte_swap_32 (digest
[0]);
16811 digest
[1] = byte_swap_32 (digest
[1]);
16813 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16814 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16815 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16817 char iter_c
= input_buf
[17];
16818 char iter_d
= input_buf
[19];
16820 // atm only defaults, let's see if there's more request
16821 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16822 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16824 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16826 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16827 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16828 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16829 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16831 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16832 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16833 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16834 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16836 salt
->salt_len
= 16;
16838 return (PARSER_OK
);
16841 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16843 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16845 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16847 u32
*digest
= (u32
*) hash_buf
->digest
;
16849 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16851 salt_t
*salt
= hash_buf
->salt
;
16853 char *salt_pos
= input_buf
+ 10;
16855 char *hash_pos
= strchr (salt_pos
, '$');
16857 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16859 uint salt_len
= hash_pos
- salt_pos
;
16863 uint hash_len
= input_len
- 10 - salt_len
- 1;
16865 // base64 decode salt
16867 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16869 u8 tmp_buf
[100] = { 0 };
16871 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16873 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16875 tmp_buf
[salt_len
] = 0x80;
16877 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16879 salt
->salt_len
= salt_len
;
16881 // base64 decode hash
16883 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16885 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16887 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16889 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16891 uint user_len
= hash_len
- 32;
16893 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16895 user_len
--; // skip the trailing space
16897 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16898 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16899 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16900 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16902 digest
[0] = byte_swap_32 (digest
[0]);
16903 digest
[1] = byte_swap_32 (digest
[1]);
16904 digest
[2] = byte_swap_32 (digest
[2]);
16905 digest
[3] = byte_swap_32 (digest
[3]);
16907 // store username for host only (output hash if cracked)
16909 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16910 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16912 return (PARSER_OK
);
16915 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16917 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16919 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16921 u32
*digest
= (u32
*) hash_buf
->digest
;
16923 salt_t
*salt
= hash_buf
->salt
;
16925 char *iter_pos
= input_buf
+ 10;
16927 u32 iter
= atoi (iter_pos
);
16931 return (PARSER_SALT_ITERATION
);
16934 iter
--; // first iteration is special
16936 salt
->salt_iter
= iter
;
16938 char *base64_pos
= strchr (iter_pos
, '}');
16940 if (base64_pos
== NULL
)
16942 return (PARSER_SIGNATURE_UNMATCHED
);
16947 // base64 decode salt
16949 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16951 u8 tmp_buf
[100] = { 0 };
16953 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16955 if (decoded_len
< 24)
16957 return (PARSER_SALT_LENGTH
);
16962 uint salt_len
= decoded_len
- 20;
16964 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16965 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16967 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16969 salt
->salt_len
= salt_len
;
16973 u32
*digest_ptr
= (u32
*) tmp_buf
;
16975 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16976 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16977 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16978 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16979 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16981 return (PARSER_OK
);
16984 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16986 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16988 u32
*digest
= (u32
*) hash_buf
->digest
;
16990 salt_t
*salt
= hash_buf
->salt
;
16992 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16993 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16994 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16995 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16996 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16998 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17000 uint salt_len
= input_len
- 40 - 1;
17002 char *salt_buf
= input_buf
+ 40 + 1;
17004 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17006 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17008 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
17010 salt
->salt_len
= salt_len
;
17012 return (PARSER_OK
);
17015 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17017 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
17019 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17021 u32
*digest
= (u32
*) hash_buf
->digest
;
17023 salt_t
*salt
= hash_buf
->salt
;
17025 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17031 char *V_pos
= input_buf
+ 5;
17033 char *R_pos
= strchr (V_pos
, '*');
17035 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17037 u32 V_len
= R_pos
- V_pos
;
17041 char *bits_pos
= strchr (R_pos
, '*');
17043 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17045 u32 R_len
= bits_pos
- R_pos
;
17049 char *P_pos
= strchr (bits_pos
, '*');
17051 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17053 u32 bits_len
= P_pos
- bits_pos
;
17057 char *enc_md_pos
= strchr (P_pos
, '*');
17059 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17061 u32 P_len
= enc_md_pos
- P_pos
;
17065 char *id_len_pos
= strchr (enc_md_pos
, '*');
17067 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17069 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17073 char *id_buf_pos
= strchr (id_len_pos
, '*');
17075 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17077 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17081 char *u_len_pos
= strchr (id_buf_pos
, '*');
17083 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17085 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17087 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17091 char *u_buf_pos
= strchr (u_len_pos
, '*');
17093 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17095 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17099 char *o_len_pos
= strchr (u_buf_pos
, '*');
17101 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17103 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17105 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17109 char *o_buf_pos
= strchr (o_len_pos
, '*');
17111 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17113 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17117 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;
17119 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17123 const int V
= atoi (V_pos
);
17124 const int R
= atoi (R_pos
);
17125 const int P
= atoi (P_pos
);
17127 if (V
!= 1) return (PARSER_SALT_VALUE
);
17128 if (R
!= 2) return (PARSER_SALT_VALUE
);
17130 const int enc_md
= atoi (enc_md_pos
);
17132 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17134 const int id_len
= atoi (id_len_pos
);
17135 const int u_len
= atoi (u_len_pos
);
17136 const int o_len
= atoi (o_len_pos
);
17138 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17139 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17140 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17142 const int bits
= atoi (bits_pos
);
17144 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17146 // copy data to esalt
17152 pdf
->enc_md
= enc_md
;
17154 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17155 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17156 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17157 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17158 pdf
->id_len
= id_len
;
17160 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17161 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17162 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17163 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17164 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17165 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17166 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17167 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17168 pdf
->u_len
= u_len
;
17170 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17171 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17172 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17173 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17174 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17175 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17176 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17177 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17178 pdf
->o_len
= o_len
;
17180 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17181 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17182 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17183 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17185 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17186 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17187 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17188 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17189 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17190 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17191 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17192 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17194 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17195 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17196 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17197 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17198 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17199 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17200 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17201 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17203 // we use ID for salt, maybe needs to change, we will see...
17205 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17206 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17207 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17208 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17209 salt
->salt_len
= pdf
->id_len
;
17211 digest
[0] = pdf
->u_buf
[0];
17212 digest
[1] = pdf
->u_buf
[1];
17213 digest
[2] = pdf
->u_buf
[2];
17214 digest
[3] = pdf
->u_buf
[3];
17216 return (PARSER_OK
);
17219 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17221 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
17224 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17226 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
17228 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17230 u32
*digest
= (u32
*) hash_buf
->digest
;
17232 salt_t
*salt
= hash_buf
->salt
;
17234 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17240 char *V_pos
= input_buf
+ 5;
17242 char *R_pos
= strchr (V_pos
, '*');
17244 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17246 u32 V_len
= R_pos
- V_pos
;
17250 char *bits_pos
= strchr (R_pos
, '*');
17252 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17254 u32 R_len
= bits_pos
- R_pos
;
17258 char *P_pos
= strchr (bits_pos
, '*');
17260 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17262 u32 bits_len
= P_pos
- bits_pos
;
17266 char *enc_md_pos
= strchr (P_pos
, '*');
17268 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17270 u32 P_len
= enc_md_pos
- P_pos
;
17274 char *id_len_pos
= strchr (enc_md_pos
, '*');
17276 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17278 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17282 char *id_buf_pos
= strchr (id_len_pos
, '*');
17284 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17286 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17290 char *u_len_pos
= strchr (id_buf_pos
, '*');
17292 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17294 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17296 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17300 char *u_buf_pos
= strchr (u_len_pos
, '*');
17302 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17304 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17308 char *o_len_pos
= strchr (u_buf_pos
, '*');
17310 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17312 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17314 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17318 char *o_buf_pos
= strchr (o_len_pos
, '*');
17320 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17322 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17326 char *rc4key_pos
= strchr (o_buf_pos
, ':');
17328 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17330 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
17332 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17336 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;
17338 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
17342 const int V
= atoi (V_pos
);
17343 const int R
= atoi (R_pos
);
17344 const int P
= atoi (P_pos
);
17346 if (V
!= 1) return (PARSER_SALT_VALUE
);
17347 if (R
!= 2) return (PARSER_SALT_VALUE
);
17349 const int enc_md
= atoi (enc_md_pos
);
17351 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17353 const int id_len
= atoi (id_len_pos
);
17354 const int u_len
= atoi (u_len_pos
);
17355 const int o_len
= atoi (o_len_pos
);
17357 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17358 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17359 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17361 const int bits
= atoi (bits_pos
);
17363 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17365 // copy data to esalt
17371 pdf
->enc_md
= enc_md
;
17373 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17374 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17375 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17376 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17377 pdf
->id_len
= id_len
;
17379 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17380 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17381 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17382 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17383 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17384 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17385 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17386 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17387 pdf
->u_len
= u_len
;
17389 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17390 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17391 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17392 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17393 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17394 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17395 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17396 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17397 pdf
->o_len
= o_len
;
17399 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17400 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17401 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17402 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17404 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17405 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17406 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17407 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17408 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17409 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17410 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17411 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17413 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17414 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17415 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17416 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17417 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17418 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17419 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17420 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17422 pdf
->rc4key
[1] = 0;
17423 pdf
->rc4key
[0] = 0;
17425 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
17426 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
17427 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
17428 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
17429 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
17430 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
17431 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
17432 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
17433 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
17434 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
17436 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
17437 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
17439 // we use ID for salt, maybe needs to change, we will see...
17441 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17442 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17443 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17444 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17445 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17446 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17447 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17448 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17449 salt
->salt_len
= pdf
->id_len
+ 16;
17451 digest
[0] = pdf
->rc4key
[0];
17452 digest
[1] = pdf
->rc4key
[1];
17456 return (PARSER_OK
);
17459 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17461 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
17463 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17465 u32
*digest
= (u32
*) hash_buf
->digest
;
17467 salt_t
*salt
= hash_buf
->salt
;
17469 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17475 char *V_pos
= input_buf
+ 5;
17477 char *R_pos
= strchr (V_pos
, '*');
17479 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17481 u32 V_len
= R_pos
- V_pos
;
17485 char *bits_pos
= strchr (R_pos
, '*');
17487 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17489 u32 R_len
= bits_pos
- R_pos
;
17493 char *P_pos
= strchr (bits_pos
, '*');
17495 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17497 u32 bits_len
= P_pos
- bits_pos
;
17501 char *enc_md_pos
= strchr (P_pos
, '*');
17503 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17505 u32 P_len
= enc_md_pos
- P_pos
;
17509 char *id_len_pos
= strchr (enc_md_pos
, '*');
17511 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17513 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17517 char *id_buf_pos
= strchr (id_len_pos
, '*');
17519 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17521 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17525 char *u_len_pos
= strchr (id_buf_pos
, '*');
17527 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17529 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17531 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17535 char *u_buf_pos
= strchr (u_len_pos
, '*');
17537 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17539 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17543 char *o_len_pos
= strchr (u_buf_pos
, '*');
17545 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17547 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17549 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17553 char *o_buf_pos
= strchr (o_len_pos
, '*');
17555 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17557 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17561 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;
17563 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17567 const int V
= atoi (V_pos
);
17568 const int R
= atoi (R_pos
);
17569 const int P
= atoi (P_pos
);
17573 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17574 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17576 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17578 const int id_len
= atoi (id_len_pos
);
17579 const int u_len
= atoi (u_len_pos
);
17580 const int o_len
= atoi (o_len_pos
);
17582 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17584 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17585 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17587 const int bits
= atoi (bits_pos
);
17589 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17595 enc_md
= atoi (enc_md_pos
);
17598 // copy data to esalt
17604 pdf
->enc_md
= enc_md
;
17606 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17607 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17608 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17609 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17613 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17614 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17615 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17616 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17619 pdf
->id_len
= id_len
;
17621 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17622 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17623 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17624 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17625 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17626 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17627 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17628 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17629 pdf
->u_len
= u_len
;
17631 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17632 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17633 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17634 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17635 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17636 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17637 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17638 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17639 pdf
->o_len
= o_len
;
17641 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17642 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17643 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17644 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17648 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17649 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17650 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17651 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17654 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17655 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17656 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17657 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17658 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17659 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17660 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17661 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17663 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17664 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17665 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17666 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17667 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17668 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17669 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17670 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17672 // precompute rc4 data for later use
17688 uint salt_pc_block
[32] = { 0 };
17690 char *salt_pc_ptr
= (char *) salt_pc_block
;
17692 memcpy (salt_pc_ptr
, padding
, 32);
17693 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17695 uint salt_pc_digest
[4] = { 0 };
17697 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17699 pdf
->rc4data
[0] = salt_pc_digest
[0];
17700 pdf
->rc4data
[1] = salt_pc_digest
[1];
17702 // we use ID for salt, maybe needs to change, we will see...
17704 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17705 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17706 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17707 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17708 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17709 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17710 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17711 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17712 salt
->salt_len
= pdf
->id_len
+ 16;
17714 salt
->salt_iter
= ROUNDS_PDF14
;
17716 digest
[0] = pdf
->u_buf
[0];
17717 digest
[1] = pdf
->u_buf
[1];
17721 return (PARSER_OK
);
17724 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17726 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17728 if (ret
!= PARSER_OK
)
17733 u32
*digest
= (u32
*) hash_buf
->digest
;
17735 salt_t
*salt
= hash_buf
->salt
;
17737 digest
[0] -= SHA256M_A
;
17738 digest
[1] -= SHA256M_B
;
17739 digest
[2] -= SHA256M_C
;
17740 digest
[3] -= SHA256M_D
;
17741 digest
[4] -= SHA256M_E
;
17742 digest
[5] -= SHA256M_F
;
17743 digest
[6] -= SHA256M_G
;
17744 digest
[7] -= SHA256M_H
;
17746 salt
->salt_buf
[2] = 0x80;
17748 return (PARSER_OK
);
17751 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17753 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17755 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17757 u32
*digest
= (u32
*) hash_buf
->digest
;
17759 salt_t
*salt
= hash_buf
->salt
;
17761 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17767 char *V_pos
= input_buf
+ 5;
17769 char *R_pos
= strchr (V_pos
, '*');
17771 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17773 u32 V_len
= R_pos
- V_pos
;
17777 char *bits_pos
= strchr (R_pos
, '*');
17779 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17781 u32 R_len
= bits_pos
- R_pos
;
17785 char *P_pos
= strchr (bits_pos
, '*');
17787 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17789 u32 bits_len
= P_pos
- bits_pos
;
17793 char *enc_md_pos
= strchr (P_pos
, '*');
17795 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17797 u32 P_len
= enc_md_pos
- P_pos
;
17801 char *id_len_pos
= strchr (enc_md_pos
, '*');
17803 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17805 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17809 char *id_buf_pos
= strchr (id_len_pos
, '*');
17811 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17813 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17817 char *u_len_pos
= strchr (id_buf_pos
, '*');
17819 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17821 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17825 char *u_buf_pos
= strchr (u_len_pos
, '*');
17827 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17829 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17833 char *o_len_pos
= strchr (u_buf_pos
, '*');
17835 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17837 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17841 char *o_buf_pos
= strchr (o_len_pos
, '*');
17843 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17845 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17849 char *last
= strchr (o_buf_pos
, '*');
17851 if (last
== NULL
) last
= input_buf
+ input_len
;
17853 u32 o_buf_len
= last
- o_buf_pos
;
17857 const int V
= atoi (V_pos
);
17858 const int R
= atoi (R_pos
);
17862 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17863 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17865 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17867 const int bits
= atoi (bits_pos
);
17869 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17871 int enc_md
= atoi (enc_md_pos
);
17873 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17875 const uint id_len
= atoi (id_len_pos
);
17876 const uint u_len
= atoi (u_len_pos
);
17877 const uint o_len
= atoi (o_len_pos
);
17879 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17880 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17881 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17882 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17883 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17884 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17885 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17886 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17888 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17889 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17890 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17892 // copy data to esalt
17894 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17896 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17898 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17901 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17902 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17904 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17905 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17907 salt
->salt_len
= 8;
17908 salt
->salt_iter
= ROUNDS_PDF17L8
;
17910 digest
[0] = pdf
->u_buf
[0];
17911 digest
[1] = pdf
->u_buf
[1];
17912 digest
[2] = pdf
->u_buf
[2];
17913 digest
[3] = pdf
->u_buf
[3];
17914 digest
[4] = pdf
->u_buf
[4];
17915 digest
[5] = pdf
->u_buf
[5];
17916 digest
[6] = pdf
->u_buf
[6];
17917 digest
[7] = pdf
->u_buf
[7];
17919 return (PARSER_OK
);
17922 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17924 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17926 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17928 u32
*digest
= (u32
*) hash_buf
->digest
;
17930 salt_t
*salt
= hash_buf
->salt
;
17932 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17940 char *iter_pos
= input_buf
+ 7;
17942 u32 iter
= atoi (iter_pos
);
17944 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17945 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17947 // first is *raw* salt
17949 char *salt_pos
= strchr (iter_pos
, ':');
17951 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17955 char *hash_pos
= strchr (salt_pos
, ':');
17957 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17959 u32 salt_len
= hash_pos
- salt_pos
;
17961 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17965 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17967 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17971 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17973 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17975 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17977 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17978 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17980 salt
->salt_len
= salt_len
;
17981 salt
->salt_iter
= iter
- 1;
17985 u8 tmp_buf
[100] = { 0 };
17987 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17989 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17991 memcpy (digest
, tmp_buf
, 16);
17993 digest
[0] = byte_swap_32 (digest
[0]);
17994 digest
[1] = byte_swap_32 (digest
[1]);
17995 digest
[2] = byte_swap_32 (digest
[2]);
17996 digest
[3] = byte_swap_32 (digest
[3]);
17998 // add some stuff to normal salt to make sorted happy
18000 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
18001 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
18002 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
18003 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
18004 salt
->salt_buf
[4] = salt
->salt_iter
;
18006 return (PARSER_OK
);
18009 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18011 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
18013 u32
*digest
= (u32
*) hash_buf
->digest
;
18015 salt_t
*salt
= hash_buf
->salt
;
18017 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18018 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18019 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18020 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18022 digest
[0] = byte_swap_32 (digest
[0]);
18023 digest
[1] = byte_swap_32 (digest
[1]);
18024 digest
[2] = byte_swap_32 (digest
[2]);
18025 digest
[3] = byte_swap_32 (digest
[3]);
18027 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18029 uint salt_len
= input_len
- 32 - 1;
18031 char *salt_buf
= input_buf
+ 32 + 1;
18033 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18035 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18037 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18039 salt
->salt_len
= salt_len
;
18041 return (PARSER_OK
);
18044 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18046 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
18048 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18050 u32
*digest
= (u32
*) hash_buf
->digest
;
18052 salt_t
*salt
= hash_buf
->salt
;
18054 char *user_pos
= input_buf
+ 10;
18056 char *salt_pos
= strchr (user_pos
, '*');
18058 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18062 char *hash_pos
= strchr (salt_pos
, '*');
18066 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18068 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
18070 uint user_len
= salt_pos
- user_pos
- 1;
18072 uint salt_len
= hash_pos
- salt_pos
- 1;
18074 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
18080 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18081 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18082 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18083 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18085 digest
[0] = byte_swap_32 (digest
[0]);
18086 digest
[1] = byte_swap_32 (digest
[1]);
18087 digest
[2] = byte_swap_32 (digest
[2]);
18088 digest
[3] = byte_swap_32 (digest
[3]);
18090 digest
[0] -= MD5M_A
;
18091 digest
[1] -= MD5M_B
;
18092 digest
[2] -= MD5M_C
;
18093 digest
[3] -= MD5M_D
;
18099 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18101 // first 4 bytes are the "challenge"
18103 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
18104 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
18105 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
18106 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
18108 // append the user name
18110 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
18112 salt
->salt_len
= 4 + user_len
;
18114 return (PARSER_OK
);
18117 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18119 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
18121 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18123 u32
*digest
= (u32
*) hash_buf
->digest
;
18125 salt_t
*salt
= hash_buf
->salt
;
18127 char *salt_pos
= input_buf
+ 9;
18129 char *hash_pos
= strchr (salt_pos
, '*');
18131 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18135 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18137 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
18139 uint salt_len
= hash_pos
- salt_pos
- 1;
18141 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
18147 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18148 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18149 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18150 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18151 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18157 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18159 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18161 salt
->salt_len
= salt_len
;
18163 return (PARSER_OK
);
18166 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18168 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
18170 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18172 u32
*digest
= (u32
*) hash_buf
->digest
;
18174 salt_t
*salt
= hash_buf
->salt
;
18176 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
18182 char *cry_master_len_pos
= input_buf
+ 9;
18184 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
18186 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18188 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
18190 cry_master_buf_pos
++;
18192 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
18194 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18196 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
18198 cry_salt_len_pos
++;
18200 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
18202 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18204 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
18206 cry_salt_buf_pos
++;
18208 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
18210 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18212 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
18216 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
18218 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18220 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
18224 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
18226 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18228 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
18232 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
18234 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18236 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
18238 public_key_len_pos
++;
18240 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
18242 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18244 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
18246 public_key_buf_pos
++;
18248 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;
18250 const uint cry_master_len
= atoi (cry_master_len_pos
);
18251 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
18252 const uint ckey_len
= atoi (ckey_len_pos
);
18253 const uint public_key_len
= atoi (public_key_len_pos
);
18255 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
18256 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
18257 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
18258 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
18260 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
18262 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
18264 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
18267 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
18269 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
18271 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
18274 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
18276 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
18278 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
18281 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
18282 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
18283 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
18286 * store digest (should be unique enought, hopefully)
18289 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
18290 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
18291 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
18292 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
18298 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
18300 const uint cry_rounds
= atoi (cry_rounds_pos
);
18302 salt
->salt_iter
= cry_rounds
- 1;
18304 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18306 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
18308 salt
->salt_len
= salt_len
;
18310 return (PARSER_OK
);
18313 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18315 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
18317 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18319 u32
*digest
= (u32
*) hash_buf
->digest
;
18321 salt_t
*salt
= hash_buf
->salt
;
18323 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
18325 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
18327 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
18329 memcpy (temp_input_buf
, input_buf
, input_len
);
18333 char *URI_server_pos
= temp_input_buf
+ 6;
18335 char *URI_client_pos
= strchr (URI_server_pos
, '*');
18337 if (URI_client_pos
== NULL
)
18339 myfree (temp_input_buf
);
18341 return (PARSER_SEPARATOR_UNMATCHED
);
18344 URI_client_pos
[0] = 0;
18347 uint URI_server_len
= strlen (URI_server_pos
);
18349 if (URI_server_len
> 512)
18351 myfree (temp_input_buf
);
18353 return (PARSER_SALT_LENGTH
);
18358 char *user_pos
= strchr (URI_client_pos
, '*');
18360 if (user_pos
== NULL
)
18362 myfree (temp_input_buf
);
18364 return (PARSER_SEPARATOR_UNMATCHED
);
18370 uint URI_client_len
= strlen (URI_client_pos
);
18372 if (URI_client_len
> 512)
18374 myfree (temp_input_buf
);
18376 return (PARSER_SALT_LENGTH
);
18381 char *realm_pos
= strchr (user_pos
, '*');
18383 if (realm_pos
== NULL
)
18385 myfree (temp_input_buf
);
18387 return (PARSER_SEPARATOR_UNMATCHED
);
18393 uint user_len
= strlen (user_pos
);
18395 if (user_len
> 116)
18397 myfree (temp_input_buf
);
18399 return (PARSER_SALT_LENGTH
);
18404 char *method_pos
= strchr (realm_pos
, '*');
18406 if (method_pos
== NULL
)
18408 myfree (temp_input_buf
);
18410 return (PARSER_SEPARATOR_UNMATCHED
);
18416 uint realm_len
= strlen (realm_pos
);
18418 if (realm_len
> 116)
18420 myfree (temp_input_buf
);
18422 return (PARSER_SALT_LENGTH
);
18427 char *URI_prefix_pos
= strchr (method_pos
, '*');
18429 if (URI_prefix_pos
== NULL
)
18431 myfree (temp_input_buf
);
18433 return (PARSER_SEPARATOR_UNMATCHED
);
18436 URI_prefix_pos
[0] = 0;
18439 uint method_len
= strlen (method_pos
);
18441 if (method_len
> 246)
18443 myfree (temp_input_buf
);
18445 return (PARSER_SALT_LENGTH
);
18450 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
18452 if (URI_resource_pos
== NULL
)
18454 myfree (temp_input_buf
);
18456 return (PARSER_SEPARATOR_UNMATCHED
);
18459 URI_resource_pos
[0] = 0;
18460 URI_resource_pos
++;
18462 uint URI_prefix_len
= strlen (URI_prefix_pos
);
18464 if (URI_prefix_len
> 245)
18466 myfree (temp_input_buf
);
18468 return (PARSER_SALT_LENGTH
);
18473 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
18475 if (URI_suffix_pos
== NULL
)
18477 myfree (temp_input_buf
);
18479 return (PARSER_SEPARATOR_UNMATCHED
);
18482 URI_suffix_pos
[0] = 0;
18485 uint URI_resource_len
= strlen (URI_resource_pos
);
18487 if (URI_resource_len
< 1 || URI_resource_len
> 246)
18489 myfree (temp_input_buf
);
18491 return (PARSER_SALT_LENGTH
);
18496 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
18498 if (nonce_pos
== NULL
)
18500 myfree (temp_input_buf
);
18502 return (PARSER_SEPARATOR_UNMATCHED
);
18508 uint URI_suffix_len
= strlen (URI_suffix_pos
);
18510 if (URI_suffix_len
> 245)
18512 myfree (temp_input_buf
);
18514 return (PARSER_SALT_LENGTH
);
18519 char *nonce_client_pos
= strchr (nonce_pos
, '*');
18521 if (nonce_client_pos
== NULL
)
18523 myfree (temp_input_buf
);
18525 return (PARSER_SEPARATOR_UNMATCHED
);
18528 nonce_client_pos
[0] = 0;
18529 nonce_client_pos
++;
18531 uint nonce_len
= strlen (nonce_pos
);
18533 if (nonce_len
< 1 || nonce_len
> 50)
18535 myfree (temp_input_buf
);
18537 return (PARSER_SALT_LENGTH
);
18542 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18544 if (nonce_count_pos
== NULL
)
18546 myfree (temp_input_buf
);
18548 return (PARSER_SEPARATOR_UNMATCHED
);
18551 nonce_count_pos
[0] = 0;
18554 uint nonce_client_len
= strlen (nonce_client_pos
);
18556 if (nonce_client_len
> 50)
18558 myfree (temp_input_buf
);
18560 return (PARSER_SALT_LENGTH
);
18565 char *qop_pos
= strchr (nonce_count_pos
, '*');
18567 if (qop_pos
== NULL
)
18569 myfree (temp_input_buf
);
18571 return (PARSER_SEPARATOR_UNMATCHED
);
18577 uint nonce_count_len
= strlen (nonce_count_pos
);
18579 if (nonce_count_len
> 50)
18581 myfree (temp_input_buf
);
18583 return (PARSER_SALT_LENGTH
);
18588 char *directive_pos
= strchr (qop_pos
, '*');
18590 if (directive_pos
== NULL
)
18592 myfree (temp_input_buf
);
18594 return (PARSER_SEPARATOR_UNMATCHED
);
18597 directive_pos
[0] = 0;
18600 uint qop_len
= strlen (qop_pos
);
18604 myfree (temp_input_buf
);
18606 return (PARSER_SALT_LENGTH
);
18611 char *digest_pos
= strchr (directive_pos
, '*');
18613 if (digest_pos
== NULL
)
18615 myfree (temp_input_buf
);
18617 return (PARSER_SEPARATOR_UNMATCHED
);
18623 uint directive_len
= strlen (directive_pos
);
18625 if (directive_len
!= 3)
18627 myfree (temp_input_buf
);
18629 return (PARSER_SALT_LENGTH
);
18632 if (memcmp (directive_pos
, "MD5", 3))
18634 log_info ("ERROR: only the MD5 directive is currently supported\n");
18636 myfree (temp_input_buf
);
18638 return (PARSER_SIP_AUTH_DIRECTIVE
);
18642 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18647 uint md5_max_len
= 4 * 64;
18649 uint md5_remaining_len
= md5_max_len
;
18651 uint tmp_md5_buf
[64] = { 0 };
18653 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18655 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18657 md5_len
+= method_len
+ 1;
18658 tmp_md5_ptr
+= method_len
+ 1;
18660 if (URI_prefix_len
> 0)
18662 md5_remaining_len
= md5_max_len
- md5_len
;
18664 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18666 md5_len
+= URI_prefix_len
+ 1;
18667 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18670 md5_remaining_len
= md5_max_len
- md5_len
;
18672 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18674 md5_len
+= URI_resource_len
;
18675 tmp_md5_ptr
+= URI_resource_len
;
18677 if (URI_suffix_len
> 0)
18679 md5_remaining_len
= md5_max_len
- md5_len
;
18681 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18683 md5_len
+= 1 + URI_suffix_len
;
18686 uint tmp_digest
[4] = { 0 };
18688 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18690 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18691 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18692 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18693 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18699 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18701 uint esalt_len
= 0;
18703 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18705 // there are 2 possibilities for the esalt:
18707 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18709 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18711 if (esalt_len
> max_esalt_len
)
18713 myfree (temp_input_buf
);
18715 return (PARSER_SALT_LENGTH
);
18718 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18730 esalt_len
= 1 + nonce_len
+ 1 + 32;
18732 if (esalt_len
> max_esalt_len
)
18734 myfree (temp_input_buf
);
18736 return (PARSER_SALT_LENGTH
);
18739 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18747 // add 0x80 to esalt
18749 esalt_buf_ptr
[esalt_len
] = 0x80;
18751 sip
->esalt_len
= esalt_len
;
18757 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18759 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18761 uint max_salt_len
= 119;
18763 if (salt_len
> max_salt_len
)
18765 myfree (temp_input_buf
);
18767 return (PARSER_SALT_LENGTH
);
18770 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18772 sip
->salt_len
= salt_len
;
18775 * fake salt (for sorting)
18778 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18782 uint fake_salt_len
= salt_len
;
18784 if (fake_salt_len
> max_salt_len
)
18786 fake_salt_len
= max_salt_len
;
18789 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18791 salt
->salt_len
= fake_salt_len
;
18797 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18798 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18799 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18800 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18802 digest
[0] = byte_swap_32 (digest
[0]);
18803 digest
[1] = byte_swap_32 (digest
[1]);
18804 digest
[2] = byte_swap_32 (digest
[2]);
18805 digest
[3] = byte_swap_32 (digest
[3]);
18807 myfree (temp_input_buf
);
18809 return (PARSER_OK
);
18812 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18814 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18816 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18818 u32
*digest
= (u32
*) hash_buf
->digest
;
18820 salt_t
*salt
= hash_buf
->salt
;
18824 char *digest_pos
= input_buf
;
18826 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18833 char *salt_buf
= input_buf
+ 8 + 1;
18837 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18839 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18841 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18843 salt
->salt_len
= salt_len
;
18845 return (PARSER_OK
);
18848 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18850 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18852 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18854 u32
*digest
= (u32
*) hash_buf
->digest
;
18856 salt_t
*salt
= hash_buf
->salt
;
18858 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18864 char *p_buf_pos
= input_buf
+ 4;
18866 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18868 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18870 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18872 NumCyclesPower_pos
++;
18874 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18876 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18878 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18882 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18884 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18886 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18890 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18892 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18894 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18898 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18900 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18902 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18906 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18908 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18910 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18914 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18916 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18918 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18922 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18924 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18926 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18930 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18932 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18934 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18938 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;
18940 const uint iter
= atoi (NumCyclesPower_pos
);
18941 const uint crc
= atoi (crc_buf_pos
);
18942 const uint p_buf
= atoi (p_buf_pos
);
18943 const uint salt_len
= atoi (salt_len_pos
);
18944 const uint iv_len
= atoi (iv_len_pos
);
18945 const uint unpack_size
= atoi (unpack_size_pos
);
18946 const uint data_len
= atoi (data_len_pos
);
18952 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18953 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18955 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18957 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18959 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18965 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18966 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18967 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18968 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18970 seven_zip
->iv_len
= iv_len
;
18972 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18974 seven_zip
->salt_len
= 0;
18976 seven_zip
->crc
= crc
;
18978 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18980 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18982 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18985 seven_zip
->data_len
= data_len
;
18987 seven_zip
->unpack_size
= unpack_size
;
18991 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18992 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18993 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18994 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18996 salt
->salt_len
= 16;
18998 salt
->salt_sign
[0] = iter
;
19000 salt
->salt_iter
= 1 << iter
;
19011 return (PARSER_OK
);
19014 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19016 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
19018 u32
*digest
= (u32
*) hash_buf
->digest
;
19020 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19021 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19022 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19023 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19024 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19025 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19026 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19027 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19029 digest
[0] = byte_swap_32 (digest
[0]);
19030 digest
[1] = byte_swap_32 (digest
[1]);
19031 digest
[2] = byte_swap_32 (digest
[2]);
19032 digest
[3] = byte_swap_32 (digest
[3]);
19033 digest
[4] = byte_swap_32 (digest
[4]);
19034 digest
[5] = byte_swap_32 (digest
[5]);
19035 digest
[6] = byte_swap_32 (digest
[6]);
19036 digest
[7] = byte_swap_32 (digest
[7]);
19038 return (PARSER_OK
);
19041 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19043 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
19045 u32
*digest
= (u32
*) hash_buf
->digest
;
19047 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19048 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19049 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
19050 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
19051 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
19052 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
19053 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
19054 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
19055 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
19056 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
19057 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
19058 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
19059 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
19060 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
19061 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
19062 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
19064 digest
[ 0] = byte_swap_32 (digest
[ 0]);
19065 digest
[ 1] = byte_swap_32 (digest
[ 1]);
19066 digest
[ 2] = byte_swap_32 (digest
[ 2]);
19067 digest
[ 3] = byte_swap_32 (digest
[ 3]);
19068 digest
[ 4] = byte_swap_32 (digest
[ 4]);
19069 digest
[ 5] = byte_swap_32 (digest
[ 5]);
19070 digest
[ 6] = byte_swap_32 (digest
[ 6]);
19071 digest
[ 7] = byte_swap_32 (digest
[ 7]);
19072 digest
[ 8] = byte_swap_32 (digest
[ 8]);
19073 digest
[ 9] = byte_swap_32 (digest
[ 9]);
19074 digest
[10] = byte_swap_32 (digest
[10]);
19075 digest
[11] = byte_swap_32 (digest
[11]);
19076 digest
[12] = byte_swap_32 (digest
[12]);
19077 digest
[13] = byte_swap_32 (digest
[13]);
19078 digest
[14] = byte_swap_32 (digest
[14]);
19079 digest
[15] = byte_swap_32 (digest
[15]);
19081 return (PARSER_OK
);
19084 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19086 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
19088 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
19090 u32
*digest
= (u32
*) hash_buf
->digest
;
19092 salt_t
*salt
= hash_buf
->salt
;
19094 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
19102 char *iter_pos
= input_buf
+ 4;
19104 u32 iter
= atoi (iter_pos
);
19106 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19107 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19109 // first is *raw* salt
19111 char *salt_pos
= strchr (iter_pos
, ':');
19113 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19117 char *hash_pos
= strchr (salt_pos
, ':');
19119 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19121 u32 salt_len
= hash_pos
- salt_pos
;
19123 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19127 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19129 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19133 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
19135 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19137 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19139 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19140 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19142 salt
->salt_len
= salt_len
;
19143 salt
->salt_iter
= iter
- 1;
19147 u8 tmp_buf
[100] = { 0 };
19149 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19151 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19153 memcpy (digest
, tmp_buf
, 16);
19155 // add some stuff to normal salt to make sorted happy
19157 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
19158 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
19159 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
19160 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
19161 salt
->salt_buf
[4] = salt
->salt_iter
;
19163 return (PARSER_OK
);
19166 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19168 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
19170 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
19172 u32
*digest
= (u32
*) hash_buf
->digest
;
19174 salt_t
*salt
= hash_buf
->salt
;
19176 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
19184 char *iter_pos
= input_buf
+ 5;
19186 u32 iter
= atoi (iter_pos
);
19188 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19189 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19191 // first is *raw* salt
19193 char *salt_pos
= strchr (iter_pos
, ':');
19195 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19199 char *hash_pos
= strchr (salt_pos
, ':');
19201 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19203 u32 salt_len
= hash_pos
- salt_pos
;
19205 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19209 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19211 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19215 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
19217 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19219 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19221 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19222 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19224 salt
->salt_len
= salt_len
;
19225 salt
->salt_iter
= iter
- 1;
19229 u8 tmp_buf
[100] = { 0 };
19231 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19233 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19235 memcpy (digest
, tmp_buf
, 16);
19237 digest
[0] = byte_swap_32 (digest
[0]);
19238 digest
[1] = byte_swap_32 (digest
[1]);
19239 digest
[2] = byte_swap_32 (digest
[2]);
19240 digest
[3] = byte_swap_32 (digest
[3]);
19242 // add some stuff to normal salt to make sorted happy
19244 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
19245 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
19246 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
19247 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
19248 salt
->salt_buf
[4] = salt
->salt_iter
;
19250 return (PARSER_OK
);
19253 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19255 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
19257 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
19259 u64
*digest
= (u64
*) hash_buf
->digest
;
19261 salt_t
*salt
= hash_buf
->salt
;
19263 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
19271 char *iter_pos
= input_buf
+ 7;
19273 u32 iter
= atoi (iter_pos
);
19275 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19276 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19278 // first is *raw* salt
19280 char *salt_pos
= strchr (iter_pos
, ':');
19282 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19286 char *hash_pos
= strchr (salt_pos
, ':');
19288 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19290 u32 salt_len
= hash_pos
- salt_pos
;
19292 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19296 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19298 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19302 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
19304 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19306 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19308 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19309 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19311 salt
->salt_len
= salt_len
;
19312 salt
->salt_iter
= iter
- 1;
19316 u8 tmp_buf
[100] = { 0 };
19318 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19320 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19322 memcpy (digest
, tmp_buf
, 64);
19324 digest
[0] = byte_swap_64 (digest
[0]);
19325 digest
[1] = byte_swap_64 (digest
[1]);
19326 digest
[2] = byte_swap_64 (digest
[2]);
19327 digest
[3] = byte_swap_64 (digest
[3]);
19328 digest
[4] = byte_swap_64 (digest
[4]);
19329 digest
[5] = byte_swap_64 (digest
[5]);
19330 digest
[6] = byte_swap_64 (digest
[6]);
19331 digest
[7] = byte_swap_64 (digest
[7]);
19333 // add some stuff to normal salt to make sorted happy
19335 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
19336 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
19337 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
19338 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
19339 salt
->salt_buf
[4] = salt
->salt_iter
;
19341 return (PARSER_OK
);
19344 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19346 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
19348 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
19350 uint
*digest
= (uint
*) hash_buf
->digest
;
19352 salt_t
*salt
= hash_buf
->salt
;
19358 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
19360 char *hash_pos
= strchr (salt_pos
, '$');
19362 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19364 u32 salt_len
= hash_pos
- salt_pos
;
19366 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19370 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
19372 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
19376 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
19377 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
19395 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19396 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19398 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
19399 salt
->salt_len
= 8;
19401 return (PARSER_OK
);
19404 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19406 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
19408 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19410 unsigned char c19
= itoa64_to_int (input_buf
[19]);
19412 if (c19
& 3) return (PARSER_HASH_VALUE
);
19414 salt_t
*salt
= hash_buf
->salt
;
19416 u32
*digest
= (u32
*) hash_buf
->digest
;
19420 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
19421 | itoa64_to_int (input_buf
[2]) << 6
19422 | itoa64_to_int (input_buf
[3]) << 12
19423 | itoa64_to_int (input_buf
[4]) << 18;
19427 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
19428 | itoa64_to_int (input_buf
[6]) << 6
19429 | itoa64_to_int (input_buf
[7]) << 12
19430 | itoa64_to_int (input_buf
[8]) << 18;
19432 salt
->salt_len
= 4;
19434 u8 tmp_buf
[100] = { 0 };
19436 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
19438 memcpy (digest
, tmp_buf
, 8);
19442 IP (digest
[0], digest
[1], tt
);
19444 digest
[0] = rotr32 (digest
[0], 31);
19445 digest
[1] = rotr32 (digest
[1], 31);
19449 return (PARSER_OK
);
19452 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19454 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
19456 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
19458 u32
*digest
= (u32
*) hash_buf
->digest
;
19460 salt_t
*salt
= hash_buf
->salt
;
19466 char *type_pos
= input_buf
+ 6 + 1;
19468 char *salt_pos
= strchr (type_pos
, '*');
19470 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19472 u32 type_len
= salt_pos
- type_pos
;
19474 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
19478 char *crypted_pos
= strchr (salt_pos
, '*');
19480 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19482 u32 salt_len
= crypted_pos
- salt_pos
;
19484 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19488 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
19490 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
19496 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19497 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19499 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19500 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19502 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
19503 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
19504 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
19505 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
19507 salt
->salt_len
= 24;
19508 salt
->salt_iter
= ROUNDS_RAR3
;
19510 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
19511 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
19513 digest
[0] = 0xc43d7b00;
19514 digest
[1] = 0x40070000;
19518 return (PARSER_OK
);
19521 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19523 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19525 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19527 u32
*digest
= (u32
*) hash_buf
->digest
;
19529 salt_t
*salt
= hash_buf
->salt
;
19531 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19537 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19539 char *param1_pos
= strchr (param0_pos
, '$');
19541 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19543 u32 param0_len
= param1_pos
- param0_pos
;
19547 char *param2_pos
= strchr (param1_pos
, '$');
19549 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19551 u32 param1_len
= param2_pos
- param1_pos
;
19555 char *param3_pos
= strchr (param2_pos
, '$');
19557 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19559 u32 param2_len
= param3_pos
- param2_pos
;
19563 char *param4_pos
= strchr (param3_pos
, '$');
19565 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19567 u32 param3_len
= param4_pos
- param3_pos
;
19571 char *param5_pos
= strchr (param4_pos
, '$');
19573 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19575 u32 param4_len
= param5_pos
- param4_pos
;
19579 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19581 char *salt_buf
= param1_pos
;
19582 char *iv
= param3_pos
;
19583 char *pswcheck
= param5_pos
;
19585 const uint salt_len
= atoi (param0_pos
);
19586 const uint iterations
= atoi (param2_pos
);
19587 const uint pswcheck_len
= atoi (param4_pos
);
19593 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19594 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19595 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19597 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19598 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19599 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19605 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19606 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19607 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19608 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19610 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19611 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19612 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19613 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19615 salt
->salt_len
= 16;
19617 salt
->salt_sign
[0] = iterations
;
19619 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19625 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19626 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19630 return (PARSER_OK
);
19633 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19635 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19637 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19639 u32
*digest
= (u32
*) hash_buf
->digest
;
19641 salt_t
*salt
= hash_buf
->salt
;
19643 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19650 char *account_pos
= input_buf
+ 11 + 1;
19656 if (account_pos
[0] == '*')
19660 data_pos
= strchr (account_pos
, '*');
19665 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19667 uint account_len
= data_pos
- account_pos
+ 1;
19669 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19674 data_len
= input_len
- 11 - 1 - account_len
- 2;
19676 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19680 /* assume $krb5tgs$23$checksum$edata2 */
19681 data_pos
= account_pos
;
19683 memcpy (krb5tgs
->account_info
, "**", 3);
19685 data_len
= input_len
- 11 - 1 - 1;
19688 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19690 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19692 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19694 const char p0
= data_pos
[i
+ 0];
19695 const char p1
= data_pos
[i
+ 1];
19697 *checksum_ptr
++ = hex_convert (p1
) << 0
19698 | hex_convert (p0
) << 4;
19701 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19703 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19706 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19708 const char p0
= data_pos
[i
+ 0];
19709 const char p1
= data_pos
[i
+ 1];
19710 *edata_ptr
++ = hex_convert (p1
) << 0
19711 | hex_convert (p0
) << 4;
19714 /* this is needed for hmac_md5 */
19715 *edata_ptr
++ = 0x80;
19717 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19718 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19719 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19720 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19722 salt
->salt_len
= 32;
19724 digest
[0] = krb5tgs
->checksum
[0];
19725 digest
[1] = krb5tgs
->checksum
[1];
19726 digest
[2] = krb5tgs
->checksum
[2];
19727 digest
[3] = krb5tgs
->checksum
[3];
19729 return (PARSER_OK
);
19732 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19734 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19736 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19738 u32
*digest
= (u32
*) hash_buf
->digest
;
19740 salt_t
*salt
= hash_buf
->salt
;
19747 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19751 char *wrapped_key_pos
;
19755 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19757 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19759 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19761 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19766 data_pos
= salt_pos
;
19768 wrapped_key_pos
= strchr (salt_pos
, '*');
19770 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19772 uint salt_len
= wrapped_key_pos
- salt_pos
;
19774 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19779 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19781 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19783 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19784 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19785 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19786 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19790 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19791 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19792 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19793 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19794 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19795 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19797 salt
->salt_len
= 40;
19799 digest
[0] = salt
->salt_buf
[0];
19800 digest
[1] = salt
->salt_buf
[1];
19801 digest
[2] = salt
->salt_buf
[2];
19802 digest
[3] = salt
->salt_buf
[3];
19804 return (PARSER_OK
);
19807 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19809 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19811 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19813 u32
*digest
= (u32
*) hash_buf
->digest
;
19815 salt_t
*salt
= hash_buf
->salt
;
19817 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19827 char *algorithm_pos
;
19829 char *final_random_seed_pos
;
19830 u32 final_random_seed_len
;
19832 char *transf_random_seed_pos
;
19833 u32 transf_random_seed_len
;
19838 /* default is no keyfile provided */
19839 char *keyfile_len_pos
;
19840 u32 keyfile_len
= 0;
19841 u32 is_keyfile_present
= 0;
19842 char *keyfile_inline_pos
;
19845 /* specific to version 1 */
19846 char *contents_len_pos
;
19848 char *contents_pos
;
19850 /* specific to version 2 */
19851 char *expected_bytes_pos
;
19852 u32 expected_bytes_len
;
19854 char *contents_hash_pos
;
19855 u32 contents_hash_len
;
19857 version_pos
= input_buf
+ 8 + 1 + 1;
19859 keepass
->version
= atoi (version_pos
);
19861 rounds_pos
= strchr (version_pos
, '*');
19863 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19867 salt
->salt_iter
= (atoi (rounds_pos
));
19869 algorithm_pos
= strchr (rounds_pos
, '*');
19871 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19875 keepass
->algorithm
= atoi (algorithm_pos
);
19877 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19879 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19881 final_random_seed_pos
++;
19883 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19884 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19885 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19886 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19888 if (keepass
->version
== 2)
19890 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19891 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19892 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19893 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19896 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19898 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19900 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19902 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19903 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19905 transf_random_seed_pos
++;
19907 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19908 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19909 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19910 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19911 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19912 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19913 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19914 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19916 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19918 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19920 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19922 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19926 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19927 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19928 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19929 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19931 if (keepass
->version
== 1)
19933 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19935 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19937 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19939 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19941 contents_hash_pos
++;
19943 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19944 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19945 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19946 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19947 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19948 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19949 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19950 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19952 /* get length of contents following */
19953 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19955 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19957 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19959 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19963 u32 inline_flag
= atoi (inline_flag_pos
);
19965 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19967 contents_len_pos
= strchr (inline_flag_pos
, '*');
19969 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19971 contents_len_pos
++;
19973 contents_len
= atoi (contents_len_pos
);
19975 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19977 contents_pos
= strchr (contents_len_pos
, '*');
19979 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19985 keepass
->contents_len
= contents_len
;
19987 contents_len
= contents_len
/ 4;
19989 keyfile_inline_pos
= strchr (contents_pos
, '*');
19991 u32 real_contents_len
;
19993 if (keyfile_inline_pos
== NULL
)
19994 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19997 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19998 keyfile_inline_pos
++;
19999 is_keyfile_present
= 1;
20002 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
20004 for (i
= 0; i
< contents_len
; i
++)
20005 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
20007 else if (keepass
->version
== 2)
20009 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
20011 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20013 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
20015 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
20017 expected_bytes_pos
++;
20019 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
20020 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
20021 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
20022 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
20023 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
20024 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
20025 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
20026 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
20028 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
20030 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20032 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
20034 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
20036 contents_hash_pos
++;
20038 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
20039 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
20040 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
20041 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
20042 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
20043 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
20044 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
20045 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
20047 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
20049 if (keyfile_inline_pos
== NULL
)
20050 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
20053 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
20054 keyfile_inline_pos
++;
20055 is_keyfile_present
= 1;
20057 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
20060 if (is_keyfile_present
!= 0)
20062 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
20066 keyfile_len
= atoi (keyfile_len_pos
);
20068 keepass
->keyfile_len
= keyfile_len
;
20070 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20072 keyfile_pos
= strchr (keyfile_len_pos
, '*');
20074 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20078 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
20080 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20082 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
20083 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
20084 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
20085 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
20086 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
20087 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
20088 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
20089 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
20092 digest
[0] = keepass
->enc_iv
[0];
20093 digest
[1] = keepass
->enc_iv
[1];
20094 digest
[2] = keepass
->enc_iv
[2];
20095 digest
[3] = keepass
->enc_iv
[3];
20097 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
20098 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
20099 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
20100 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
20101 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
20102 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
20103 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
20104 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
20106 return (PARSER_OK
);
20109 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20111 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
20113 u32
*digest
= (u32
*) hash_buf
->digest
;
20115 salt_t
*salt
= hash_buf
->salt
;
20117 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20118 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20119 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20120 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20121 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20122 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20123 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20124 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20126 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20128 uint salt_len
= input_len
- 64 - 1;
20130 char *salt_buf
= input_buf
+ 64 + 1;
20132 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
20134 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
20136 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
20138 salt
->salt_len
= salt_len
;
20141 * we can precompute the first sha256 transform
20144 uint w
[16] = { 0 };
20146 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
20147 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
20148 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
20149 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
20150 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
20151 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
20152 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
20153 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
20154 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
20155 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
20156 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
20157 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
20158 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
20159 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
20160 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
20161 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
20163 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
20165 sha256_64 (w
, pc256
);
20167 salt
->salt_buf_pc
[0] = pc256
[0];
20168 salt
->salt_buf_pc
[1] = pc256
[1];
20169 salt
->salt_buf_pc
[2] = pc256
[2];
20170 salt
->salt_buf_pc
[3] = pc256
[3];
20171 salt
->salt_buf_pc
[4] = pc256
[4];
20172 salt
->salt_buf_pc
[5] = pc256
[5];
20173 salt
->salt_buf_pc
[6] = pc256
[6];
20174 salt
->salt_buf_pc
[7] = pc256
[7];
20176 digest
[0] -= pc256
[0];
20177 digest
[1] -= pc256
[1];
20178 digest
[2] -= pc256
[2];
20179 digest
[3] -= pc256
[3];
20180 digest
[4] -= pc256
[4];
20181 digest
[5] -= pc256
[5];
20182 digest
[6] -= pc256
[6];
20183 digest
[7] -= pc256
[7];
20185 return (PARSER_OK
);
20188 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20190 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
20192 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
20194 u32
*digest
= (u32
*) hash_buf
->digest
;
20196 salt_t
*salt
= hash_buf
->salt
;
20202 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
20204 char *data_buf_pos
= strchr (data_len_pos
, '$');
20206 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20208 u32 data_len_len
= data_buf_pos
- data_len_pos
;
20210 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
20211 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
20215 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
20217 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
20219 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
20221 u32 data_len
= atoi (data_len_pos
);
20223 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
20229 char *salt_pos
= data_buf_pos
;
20231 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20232 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20233 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
20234 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
20236 // this is actually the CT, which is also the hash later (if matched)
20238 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
20239 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
20240 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
20241 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
20243 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
20245 salt
->salt_iter
= 10 - 1;
20251 digest
[0] = salt
->salt_buf
[4];
20252 digest
[1] = salt
->salt_buf
[5];
20253 digest
[2] = salt
->salt_buf
[6];
20254 digest
[3] = salt
->salt_buf
[7];
20256 return (PARSER_OK
);
20259 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20261 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
20263 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
20265 u32
*digest
= (u32
*) hash_buf
->digest
;
20267 salt_t
*salt
= hash_buf
->salt
;
20273 char *salt_pos
= input_buf
+ 11 + 1;
20275 char *iter_pos
= strchr (salt_pos
, ',');
20277 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20279 u32 salt_len
= iter_pos
- salt_pos
;
20281 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
20285 char *hash_pos
= strchr (iter_pos
, ',');
20287 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20289 u32 iter_len
= hash_pos
- iter_pos
;
20291 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
20295 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
20297 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
20303 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20304 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20305 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
20306 salt
->salt_buf
[3] = 0x00018000;
20308 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
20309 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
20310 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
20311 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
20313 salt
->salt_len
= salt_len
/ 2;
20315 salt
->salt_iter
= atoi (iter_pos
) - 1;
20321 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20322 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20323 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20324 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20325 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20326 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20327 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20328 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20330 return (PARSER_OK
);
20333 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20335 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
20337 u32
*digest
= (u32
*) hash_buf
->digest
;
20339 salt_t
*salt
= hash_buf
->salt
;
20345 char *hash_pos
= input_buf
+ 64;
20346 char *salt1_pos
= input_buf
+ 128;
20347 char *salt2_pos
= input_buf
;
20353 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
20354 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
20355 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
20356 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
20358 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
20359 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
20360 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
20361 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
20363 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
20364 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
20365 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
20366 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
20368 salt
->salt_len
= 48;
20370 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
20376 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20377 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20378 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20379 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20380 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20381 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20382 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20383 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20385 return (PARSER_OK
);
20388 int zip2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20390 if ((input_len
< DISPLAY_LEN_MIN_13600
) || (input_len
> DISPLAY_LEN_MAX_13600
)) return (PARSER_GLOBAL_LENGTH
);
20392 if (memcmp (SIGNATURE_ZIP2_START
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
20393 if (memcmp (SIGNATURE_ZIP2_STOP
, input_buf
+ input_len
- 7, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
20395 u32
*digest
= (u32
*) hash_buf
->digest
;
20397 salt_t
*salt
= hash_buf
->salt
;
20399 zip2_t
*zip2
= (zip2_t
*) hash_buf
->esalt
;
20405 char *param0_pos
= input_buf
+ 6 + 1;
20407 char *param1_pos
= strchr (param0_pos
, '*');
20409 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20411 u32 param0_len
= param1_pos
- param0_pos
;
20415 char *param2_pos
= strchr (param1_pos
, '*');
20417 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20419 u32 param1_len
= param2_pos
- param1_pos
;
20423 char *param3_pos
= strchr (param2_pos
, '*');
20425 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20427 u32 param2_len
= param3_pos
- param2_pos
;
20431 char *param4_pos
= strchr (param3_pos
, '*');
20433 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20435 u32 param3_len
= param4_pos
- param3_pos
;
20439 char *param5_pos
= strchr (param4_pos
, '*');
20441 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20443 u32 param4_len
= param5_pos
- param4_pos
;
20447 char *param6_pos
= strchr (param5_pos
, '*');
20449 if (param6_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20451 u32 param5_len
= param6_pos
- param5_pos
;
20455 char *param7_pos
= strchr (param6_pos
, '*');
20457 if (param7_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20459 u32 param6_len
= param7_pos
- param6_pos
;
20463 char *param8_pos
= strchr (param7_pos
, '*');
20465 if (param8_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20467 u32 param7_len
= param8_pos
- param7_pos
;
20471 const uint type
= atoi (param0_pos
);
20472 const uint mode
= atoi (param1_pos
);
20473 const uint magic
= atoi (param2_pos
);
20475 char *salt_buf
= param3_pos
;
20477 uint verify_bytes
; sscanf (param4_pos
, "%4x*", &verify_bytes
);
20479 const uint compress_length
= atoi (param5_pos
);
20481 char *data_buf
= param6_pos
;
20482 char *auth
= param7_pos
;
20488 if (param0_len
!= 1) return (PARSER_SALT_VALUE
);
20490 if (param1_len
!= 1) return (PARSER_SALT_VALUE
);
20492 if (param2_len
!= 1) return (PARSER_SALT_VALUE
);
20494 if ((param3_len
!= 16) && (param3_len
!= 24) && (param3_len
!= 32)) return (PARSER_SALT_VALUE
);
20496 if (param4_len
>= 5) return (PARSER_SALT_VALUE
);
20498 if (param5_len
>= 5) return (PARSER_SALT_VALUE
);
20500 if (param6_len
>= 8192) return (PARSER_SALT_VALUE
);
20502 if (param6_len
& 1) return (PARSER_SALT_VALUE
);
20504 if (param7_len
!= 20) return (PARSER_SALT_VALUE
);
20506 if (type
!= 0) return (PARSER_SALT_VALUE
);
20508 if ((mode
!= 1) && (mode
!= 2) && (mode
!= 3)) return (PARSER_SALT_VALUE
);
20510 if (magic
!= 0) return (PARSER_SALT_VALUE
);
20512 if (verify_bytes
>= 0x10000) return (PARSER_SALT_VALUE
);
20520 zip2
->magic
= magic
;
20524 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20525 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20526 zip2
->salt_buf
[2] = 0;
20527 zip2
->salt_buf
[3] = 0;
20529 zip2
->salt_len
= 8;
20531 else if (mode
== 2)
20533 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20534 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20535 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20536 zip2
->salt_buf
[3] = 0;
20538 zip2
->salt_len
= 12;
20540 else if (mode
== 3)
20542 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20543 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20544 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20545 zip2
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
20547 zip2
->salt_len
= 16;
20550 zip2
->salt_buf
[0] = byte_swap_32 (zip2
->salt_buf
[0]);
20551 zip2
->salt_buf
[1] = byte_swap_32 (zip2
->salt_buf
[1]);
20552 zip2
->salt_buf
[2] = byte_swap_32 (zip2
->salt_buf
[2]);
20553 zip2
->salt_buf
[3] = byte_swap_32 (zip2
->salt_buf
[3]);
20555 zip2
->verify_bytes
= verify_bytes
;
20557 zip2
->compress_length
= compress_length
;
20559 char *data_buf_ptr
= (char *) zip2
->data_buf
;
20561 for (uint i
= 0; i
< param6_len
; i
+= 2)
20563 const char p0
= data_buf
[i
+ 0];
20564 const char p1
= data_buf
[i
+ 1];
20566 *data_buf_ptr
++ = hex_convert (p1
) << 0
20567 | hex_convert (p0
) << 4;
20572 *data_buf_ptr
= 0x80;
20574 char *auth_ptr
= (char *) zip2
->auth_buf
;
20576 for (uint i
= 0; i
< param7_len
; i
+= 2)
20578 const char p0
= auth
[i
+ 0];
20579 const char p1
= auth
[i
+ 1];
20581 *auth_ptr
++ = hex_convert (p1
) << 0
20582 | hex_convert (p0
) << 4;
20591 salt
->salt_buf
[0] = zip2
->salt_buf
[0];
20592 salt
->salt_buf
[1] = zip2
->salt_buf
[1];
20593 salt
->salt_buf
[2] = zip2
->salt_buf
[2];
20594 salt
->salt_buf
[3] = zip2
->salt_buf
[3];
20595 salt
->salt_buf
[4] = zip2
->data_buf
[0];
20596 salt
->salt_buf
[5] = zip2
->data_buf
[1];
20597 salt
->salt_buf
[6] = zip2
->data_buf
[2];
20598 salt
->salt_buf
[7] = zip2
->data_buf
[3];
20600 salt
->salt_len
= 32;
20602 salt
->salt_iter
= ROUNDS_ZIP2
- 1;
20605 * digest buf (fake)
20608 digest
[0] = zip2
->auth_buf
[0];
20609 digest
[1] = zip2
->auth_buf
[1];
20610 digest
[2] = zip2
->auth_buf
[2];
20611 digest
[3] = zip2
->auth_buf
[3];
20613 return (PARSER_OK
);
20617 * parallel running threads
20622 BOOL WINAPI
sigHandler_default (DWORD sig
)
20626 case CTRL_CLOSE_EVENT
:
20629 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
20630 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
20631 * function otherwise it is too late (e.g. after returning from this function)
20636 SetConsoleCtrlHandler (NULL
, TRUE
);
20643 case CTRL_LOGOFF_EVENT
:
20644 case CTRL_SHUTDOWN_EVENT
:
20648 SetConsoleCtrlHandler (NULL
, TRUE
);
20656 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
20660 case CTRL_CLOSE_EVENT
:
20664 SetConsoleCtrlHandler (NULL
, TRUE
);
20671 case CTRL_LOGOFF_EVENT
:
20672 case CTRL_SHUTDOWN_EVENT
:
20676 SetConsoleCtrlHandler (NULL
, TRUE
);
20684 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
20686 if (callback
== NULL
)
20688 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
20692 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
20698 void sigHandler_default (int sig
)
20702 signal (sig
, NULL
);
20705 void sigHandler_benchmark (int sig
)
20709 signal (sig
, NULL
);
20712 void hc_signal (void (callback
) (int))
20714 if (callback
== NULL
) callback
= SIG_DFL
;
20716 signal (SIGINT
, callback
);
20717 signal (SIGTERM
, callback
);
20718 signal (SIGABRT
, callback
);
20723 void status_display ();
20725 void *thread_keypress (void *p
)
20727 int benchmark
= *((int *) p
);
20729 uint quiet
= data
.quiet
;
20733 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
20735 int ch
= tty_getchar();
20737 if (ch
== -1) break;
20739 if (ch
== 0) continue;
20741 //https://github.com/hashcat/hashcat/issues/302
20746 hc_thread_mutex_lock (mux_display
);
20762 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20763 if (quiet
== 0) fflush (stdout
);
20775 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20776 if (quiet
== 0) fflush (stdout
);
20788 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20789 if (quiet
== 0) fflush (stdout
);
20801 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20802 if (quiet
== 0) fflush (stdout
);
20810 if (benchmark
== 1) break;
20812 stop_at_checkpoint ();
20816 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20817 if (quiet
== 0) fflush (stdout
);
20825 if (benchmark
== 1)
20837 //https://github.com/hashcat/hashcat/issues/302
20842 hc_thread_mutex_unlock (mux_display
);
20854 bool class_num (const u8 c
)
20856 return ((c
>= '0') && (c
<= '9'));
20859 bool class_lower (const u8 c
)
20861 return ((c
>= 'a') && (c
<= 'z'));
20864 bool class_upper (const u8 c
)
20866 return ((c
>= 'A') && (c
<= 'Z'));
20869 bool class_alpha (const u8 c
)
20871 return (class_lower (c
) || class_upper (c
));
20874 int conv_ctoi (const u8 c
)
20880 else if (class_upper (c
))
20882 return c
- 'A' + 10;
20888 int conv_itoc (const u8 c
)
20896 return c
+ 'A' - 10;
20906 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20907 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20908 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20909 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20910 #define MAX_KERNEL_RULES 255
20911 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20912 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20913 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20915 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20916 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20917 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20918 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20920 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20925 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20927 switch (rule_buf
[rule_pos
])
20933 case RULE_OP_MANGLE_NOOP
:
20934 SET_NAME (rule
, rule_buf
[rule_pos
]);
20937 case RULE_OP_MANGLE_LREST
:
20938 SET_NAME (rule
, rule_buf
[rule_pos
]);
20941 case RULE_OP_MANGLE_UREST
:
20942 SET_NAME (rule
, rule_buf
[rule_pos
]);
20945 case RULE_OP_MANGLE_LREST_UFIRST
:
20946 SET_NAME (rule
, rule_buf
[rule_pos
]);
20949 case RULE_OP_MANGLE_UREST_LFIRST
:
20950 SET_NAME (rule
, rule_buf
[rule_pos
]);
20953 case RULE_OP_MANGLE_TREST
:
20954 SET_NAME (rule
, rule_buf
[rule_pos
]);
20957 case RULE_OP_MANGLE_TOGGLE_AT
:
20958 SET_NAME (rule
, rule_buf
[rule_pos
]);
20959 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20962 case RULE_OP_MANGLE_REVERSE
:
20963 SET_NAME (rule
, rule_buf
[rule_pos
]);
20966 case RULE_OP_MANGLE_DUPEWORD
:
20967 SET_NAME (rule
, rule_buf
[rule_pos
]);
20970 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20971 SET_NAME (rule
, rule_buf
[rule_pos
]);
20972 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20975 case RULE_OP_MANGLE_REFLECT
:
20976 SET_NAME (rule
, rule_buf
[rule_pos
]);
20979 case RULE_OP_MANGLE_ROTATE_LEFT
:
20980 SET_NAME (rule
, rule_buf
[rule_pos
]);
20983 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20984 SET_NAME (rule
, rule_buf
[rule_pos
]);
20987 case RULE_OP_MANGLE_APPEND
:
20988 SET_NAME (rule
, rule_buf
[rule_pos
]);
20989 SET_P0 (rule
, rule_buf
[rule_pos
]);
20992 case RULE_OP_MANGLE_PREPEND
:
20993 SET_NAME (rule
, rule_buf
[rule_pos
]);
20994 SET_P0 (rule
, rule_buf
[rule_pos
]);
20997 case RULE_OP_MANGLE_DELETE_FIRST
:
20998 SET_NAME (rule
, rule_buf
[rule_pos
]);
21001 case RULE_OP_MANGLE_DELETE_LAST
:
21002 SET_NAME (rule
, rule_buf
[rule_pos
]);
21005 case RULE_OP_MANGLE_DELETE_AT
:
21006 SET_NAME (rule
, rule_buf
[rule_pos
]);
21007 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21010 case RULE_OP_MANGLE_EXTRACT
:
21011 SET_NAME (rule
, rule_buf
[rule_pos
]);
21012 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21013 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21016 case RULE_OP_MANGLE_OMIT
:
21017 SET_NAME (rule
, rule_buf
[rule_pos
]);
21018 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21019 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21022 case RULE_OP_MANGLE_INSERT
:
21023 SET_NAME (rule
, rule_buf
[rule_pos
]);
21024 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21025 SET_P1 (rule
, rule_buf
[rule_pos
]);
21028 case RULE_OP_MANGLE_OVERSTRIKE
:
21029 SET_NAME (rule
, rule_buf
[rule_pos
]);
21030 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21031 SET_P1 (rule
, rule_buf
[rule_pos
]);
21034 case RULE_OP_MANGLE_TRUNCATE_AT
:
21035 SET_NAME (rule
, rule_buf
[rule_pos
]);
21036 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21039 case RULE_OP_MANGLE_REPLACE
:
21040 SET_NAME (rule
, rule_buf
[rule_pos
]);
21041 SET_P0 (rule
, rule_buf
[rule_pos
]);
21042 SET_P1 (rule
, rule_buf
[rule_pos
]);
21045 case RULE_OP_MANGLE_PURGECHAR
:
21049 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21053 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21054 SET_NAME (rule
, rule_buf
[rule_pos
]);
21055 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21058 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21059 SET_NAME (rule
, rule_buf
[rule_pos
]);
21060 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21063 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21064 SET_NAME (rule
, rule_buf
[rule_pos
]);
21067 case RULE_OP_MANGLE_SWITCH_FIRST
:
21068 SET_NAME (rule
, rule_buf
[rule_pos
]);
21071 case RULE_OP_MANGLE_SWITCH_LAST
:
21072 SET_NAME (rule
, rule_buf
[rule_pos
]);
21075 case RULE_OP_MANGLE_SWITCH_AT
:
21076 SET_NAME (rule
, rule_buf
[rule_pos
]);
21077 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21078 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21081 case RULE_OP_MANGLE_CHR_SHIFTL
:
21082 SET_NAME (rule
, rule_buf
[rule_pos
]);
21083 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21086 case RULE_OP_MANGLE_CHR_SHIFTR
:
21087 SET_NAME (rule
, rule_buf
[rule_pos
]);
21088 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21091 case RULE_OP_MANGLE_CHR_INCR
:
21092 SET_NAME (rule
, rule_buf
[rule_pos
]);
21093 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21096 case RULE_OP_MANGLE_CHR_DECR
:
21097 SET_NAME (rule
, rule_buf
[rule_pos
]);
21098 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21101 case RULE_OP_MANGLE_REPLACE_NP1
:
21102 SET_NAME (rule
, rule_buf
[rule_pos
]);
21103 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21106 case RULE_OP_MANGLE_REPLACE_NM1
:
21107 SET_NAME (rule
, rule_buf
[rule_pos
]);
21108 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21111 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21112 SET_NAME (rule
, rule_buf
[rule_pos
]);
21113 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21116 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21117 SET_NAME (rule
, rule_buf
[rule_pos
]);
21118 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21121 case RULE_OP_MANGLE_TITLE
:
21122 SET_NAME (rule
, rule_buf
[rule_pos
]);
21131 if (rule_pos
< rule_len
) return (-1);
21136 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
21140 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
21144 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
21148 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
21152 case RULE_OP_MANGLE_NOOP
:
21153 rule_buf
[rule_pos
] = rule_cmd
;
21156 case RULE_OP_MANGLE_LREST
:
21157 rule_buf
[rule_pos
] = rule_cmd
;
21160 case RULE_OP_MANGLE_UREST
:
21161 rule_buf
[rule_pos
] = rule_cmd
;
21164 case RULE_OP_MANGLE_LREST_UFIRST
:
21165 rule_buf
[rule_pos
] = rule_cmd
;
21168 case RULE_OP_MANGLE_UREST_LFIRST
:
21169 rule_buf
[rule_pos
] = rule_cmd
;
21172 case RULE_OP_MANGLE_TREST
:
21173 rule_buf
[rule_pos
] = rule_cmd
;
21176 case RULE_OP_MANGLE_TOGGLE_AT
:
21177 rule_buf
[rule_pos
] = rule_cmd
;
21178 GET_P0_CONV (rule
);
21181 case RULE_OP_MANGLE_REVERSE
:
21182 rule_buf
[rule_pos
] = rule_cmd
;
21185 case RULE_OP_MANGLE_DUPEWORD
:
21186 rule_buf
[rule_pos
] = rule_cmd
;
21189 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21190 rule_buf
[rule_pos
] = rule_cmd
;
21191 GET_P0_CONV (rule
);
21194 case RULE_OP_MANGLE_REFLECT
:
21195 rule_buf
[rule_pos
] = rule_cmd
;
21198 case RULE_OP_MANGLE_ROTATE_LEFT
:
21199 rule_buf
[rule_pos
] = rule_cmd
;
21202 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21203 rule_buf
[rule_pos
] = rule_cmd
;
21206 case RULE_OP_MANGLE_APPEND
:
21207 rule_buf
[rule_pos
] = rule_cmd
;
21211 case RULE_OP_MANGLE_PREPEND
:
21212 rule_buf
[rule_pos
] = rule_cmd
;
21216 case RULE_OP_MANGLE_DELETE_FIRST
:
21217 rule_buf
[rule_pos
] = rule_cmd
;
21220 case RULE_OP_MANGLE_DELETE_LAST
:
21221 rule_buf
[rule_pos
] = rule_cmd
;
21224 case RULE_OP_MANGLE_DELETE_AT
:
21225 rule_buf
[rule_pos
] = rule_cmd
;
21226 GET_P0_CONV (rule
);
21229 case RULE_OP_MANGLE_EXTRACT
:
21230 rule_buf
[rule_pos
] = rule_cmd
;
21231 GET_P0_CONV (rule
);
21232 GET_P1_CONV (rule
);
21235 case RULE_OP_MANGLE_OMIT
:
21236 rule_buf
[rule_pos
] = rule_cmd
;
21237 GET_P0_CONV (rule
);
21238 GET_P1_CONV (rule
);
21241 case RULE_OP_MANGLE_INSERT
:
21242 rule_buf
[rule_pos
] = rule_cmd
;
21243 GET_P0_CONV (rule
);
21247 case RULE_OP_MANGLE_OVERSTRIKE
:
21248 rule_buf
[rule_pos
] = rule_cmd
;
21249 GET_P0_CONV (rule
);
21253 case RULE_OP_MANGLE_TRUNCATE_AT
:
21254 rule_buf
[rule_pos
] = rule_cmd
;
21255 GET_P0_CONV (rule
);
21258 case RULE_OP_MANGLE_REPLACE
:
21259 rule_buf
[rule_pos
] = rule_cmd
;
21264 case RULE_OP_MANGLE_PURGECHAR
:
21268 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21272 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21273 rule_buf
[rule_pos
] = rule_cmd
;
21274 GET_P0_CONV (rule
);
21277 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21278 rule_buf
[rule_pos
] = rule_cmd
;
21279 GET_P0_CONV (rule
);
21282 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21283 rule_buf
[rule_pos
] = rule_cmd
;
21286 case RULE_OP_MANGLE_SWITCH_FIRST
:
21287 rule_buf
[rule_pos
] = rule_cmd
;
21290 case RULE_OP_MANGLE_SWITCH_LAST
:
21291 rule_buf
[rule_pos
] = rule_cmd
;
21294 case RULE_OP_MANGLE_SWITCH_AT
:
21295 rule_buf
[rule_pos
] = rule_cmd
;
21296 GET_P0_CONV (rule
);
21297 GET_P1_CONV (rule
);
21300 case RULE_OP_MANGLE_CHR_SHIFTL
:
21301 rule_buf
[rule_pos
] = rule_cmd
;
21302 GET_P0_CONV (rule
);
21305 case RULE_OP_MANGLE_CHR_SHIFTR
:
21306 rule_buf
[rule_pos
] = rule_cmd
;
21307 GET_P0_CONV (rule
);
21310 case RULE_OP_MANGLE_CHR_INCR
:
21311 rule_buf
[rule_pos
] = rule_cmd
;
21312 GET_P0_CONV (rule
);
21315 case RULE_OP_MANGLE_CHR_DECR
:
21316 rule_buf
[rule_pos
] = rule_cmd
;
21317 GET_P0_CONV (rule
);
21320 case RULE_OP_MANGLE_REPLACE_NP1
:
21321 rule_buf
[rule_pos
] = rule_cmd
;
21322 GET_P0_CONV (rule
);
21325 case RULE_OP_MANGLE_REPLACE_NM1
:
21326 rule_buf
[rule_pos
] = rule_cmd
;
21327 GET_P0_CONV (rule
);
21330 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21331 rule_buf
[rule_pos
] = rule_cmd
;
21332 GET_P0_CONV (rule
);
21335 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21336 rule_buf
[rule_pos
] = rule_cmd
;
21337 GET_P0_CONV (rule
);
21340 case RULE_OP_MANGLE_TITLE
:
21341 rule_buf
[rule_pos
] = rule_cmd
;
21345 return rule_pos
- 1;
21363 * CPU rules : this is from hashcat sources, cpu based rules
21366 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
21367 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
21369 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
21370 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
21371 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
21373 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
21374 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
21375 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
21377 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
21381 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
21386 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
21390 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
21395 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
21399 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
21404 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
21409 for (l
= 0; l
< arr_len
; l
++)
21411 r
= arr_len
- 1 - l
;
21415 MANGLE_SWITCH (arr
, l
, r
);
21421 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
21423 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21425 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
21427 return (arr_len
* 2);
21430 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
21432 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21434 int orig_len
= arr_len
;
21438 for (i
= 0; i
< times
; i
++)
21440 memcpy (&arr
[arr_len
], arr
, orig_len
);
21442 arr_len
+= orig_len
;
21448 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
21450 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21452 mangle_double (arr
, arr_len
);
21454 mangle_reverse (arr
+ arr_len
, arr_len
);
21456 return (arr_len
* 2);
21459 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
21464 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
21466 MANGLE_SWITCH (arr
, l
, r
);
21472 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
21477 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
21479 MANGLE_SWITCH (arr
, l
, r
);
21485 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21487 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21491 return (arr_len
+ 1);
21494 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21496 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21500 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21502 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21507 return (arr_len
+ 1);
21510 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21512 if (upos
>= arr_len
) return (arr_len
);
21516 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
21518 arr
[arr_pos
] = arr
[arr_pos
+ 1];
21521 return (arr_len
- 1);
21524 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21526 if (upos
>= arr_len
) return (arr_len
);
21528 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
21532 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
21534 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
21540 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21542 if (upos
>= arr_len
) return (arr_len
);
21544 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
21548 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
21550 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
21553 return (arr_len
- ulen
);
21556 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21558 if (upos
>= arr_len
) return (arr_len
);
21560 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21564 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
21566 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21571 return (arr_len
+ 1);
21574 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
)
21576 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21578 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
21580 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
21582 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
21584 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
21586 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
21588 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
21590 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
21592 return (arr_len
+ arr2_cpy
);
21595 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21597 if (upos
>= arr_len
) return (arr_len
);
21604 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21606 if (upos
>= arr_len
) return (arr_len
);
21608 memset (arr
+ upos
, 0, arr_len
- upos
);
21613 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
21617 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21619 if (arr
[arr_pos
] != oldc
) continue;
21621 arr
[arr_pos
] = newc
;
21627 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21633 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21635 if (arr
[arr_pos
] == c
) continue;
21637 arr
[ret_len
] = arr
[arr_pos
];
21645 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21647 if (ulen
> arr_len
) return (arr_len
);
21649 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21651 char cs
[100] = { 0 };
21653 memcpy (cs
, arr
, ulen
);
21657 for (i
= 0; i
< ulen
; i
++)
21661 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
21667 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21669 if (ulen
> arr_len
) return (arr_len
);
21671 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21673 int upos
= arr_len
- ulen
;
21677 for (i
= 0; i
< ulen
; i
++)
21679 char c
= arr
[upos
+ i
];
21681 arr_len
= mangle_append (arr
, arr_len
, c
);
21687 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21689 if ( arr_len
== 0) return (arr_len
);
21690 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21692 char c
= arr
[upos
];
21696 for (i
= 0; i
< ulen
; i
++)
21698 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
21704 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
21706 if ( arr_len
== 0) return (arr_len
);
21707 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21711 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21713 int new_pos
= arr_pos
* 2;
21715 arr
[new_pos
] = arr
[arr_pos
];
21717 arr
[new_pos
+ 1] = arr
[arr_pos
];
21720 return (arr_len
* 2);
21723 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21725 if (upos
>= arr_len
) return (arr_len
);
21726 if (upos2
>= arr_len
) return (arr_len
);
21728 MANGLE_SWITCH (arr
, upos
, upos2
);
21733 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21735 MANGLE_SWITCH (arr
, upos
, upos2
);
21740 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21742 if (upos
>= arr_len
) return (arr_len
);
21749 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21751 if (upos
>= arr_len
) return (arr_len
);
21758 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21760 if (upos
>= arr_len
) return (arr_len
);
21767 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21769 if (upos
>= arr_len
) return (arr_len
);
21776 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21778 int upper_next
= 1;
21782 for (pos
= 0; pos
< arr_len
; pos
++)
21784 if (arr
[pos
] == ' ')
21795 MANGLE_UPPER_AT (arr
, pos
);
21799 MANGLE_LOWER_AT (arr
, pos
);
21806 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21808 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21814 for (j
= 0; j
< rp_gen_num
; j
++)
21821 switch ((char) get_random_num (0, 9))
21824 r
= get_random_num (0, sizeof (grp_op_nop
));
21825 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21829 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21830 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21831 p1
= get_random_num (0, sizeof (grp_pos
));
21832 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21836 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21837 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21838 p1
= get_random_num (1, 6);
21839 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21843 r
= get_random_num (0, sizeof (grp_op_chr
));
21844 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21845 p1
= get_random_num (0x20, 0x7e);
21846 rule_buf
[rule_pos
++] = (char) p1
;
21850 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21851 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21852 p1
= get_random_num (0x20, 0x7e);
21853 rule_buf
[rule_pos
++] = (char) p1
;
21854 p2
= get_random_num (0x20, 0x7e);
21856 p2
= get_random_num (0x20, 0x7e);
21857 rule_buf
[rule_pos
++] = (char) p2
;
21861 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21862 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21863 p1
= get_random_num (0, sizeof (grp_pos
));
21864 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21865 p2
= get_random_num (0x20, 0x7e);
21866 rule_buf
[rule_pos
++] = (char) p2
;
21870 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21871 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21872 p1
= get_random_num (0, sizeof (grp_pos
));
21873 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21874 p2
= get_random_num (0, sizeof (grp_pos
));
21876 p2
= get_random_num (0, sizeof (grp_pos
));
21877 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21881 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21882 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21883 p1
= get_random_num (0, sizeof (grp_pos
));
21884 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21885 p2
= get_random_num (1, sizeof (grp_pos
));
21887 p2
= get_random_num (1, sizeof (grp_pos
));
21888 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21892 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21893 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21894 p1
= get_random_num (0, sizeof (grp_pos
));
21895 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21896 p2
= get_random_num (1, sizeof (grp_pos
));
21897 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21898 p3
= get_random_num (0, sizeof (grp_pos
));
21899 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21907 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21909 char mem
[BLOCK_SIZE
] = { 0 };
21911 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21913 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21915 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21917 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21919 int out_len
= in_len
;
21920 int mem_len
= in_len
;
21922 memcpy (out
, in
, out_len
);
21926 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21931 switch (rule
[rule_pos
])
21936 case RULE_OP_MANGLE_NOOP
:
21939 case RULE_OP_MANGLE_LREST
:
21940 out_len
= mangle_lrest (out
, out_len
);
21943 case RULE_OP_MANGLE_UREST
:
21944 out_len
= mangle_urest (out
, out_len
);
21947 case RULE_OP_MANGLE_LREST_UFIRST
:
21948 out_len
= mangle_lrest (out
, out_len
);
21949 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21952 case RULE_OP_MANGLE_UREST_LFIRST
:
21953 out_len
= mangle_urest (out
, out_len
);
21954 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21957 case RULE_OP_MANGLE_TREST
:
21958 out_len
= mangle_trest (out
, out_len
);
21961 case RULE_OP_MANGLE_TOGGLE_AT
:
21962 NEXT_RULEPOS (rule_pos
);
21963 NEXT_RPTOI (rule
, rule_pos
, upos
);
21964 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21967 case RULE_OP_MANGLE_REVERSE
:
21968 out_len
= mangle_reverse (out
, out_len
);
21971 case RULE_OP_MANGLE_DUPEWORD
:
21972 out_len
= mangle_double (out
, out_len
);
21975 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21976 NEXT_RULEPOS (rule_pos
);
21977 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21978 out_len
= mangle_double_times (out
, out_len
, ulen
);
21981 case RULE_OP_MANGLE_REFLECT
:
21982 out_len
= mangle_reflect (out
, out_len
);
21985 case RULE_OP_MANGLE_ROTATE_LEFT
:
21986 mangle_rotate_left (out
, out_len
);
21989 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21990 mangle_rotate_right (out
, out_len
);
21993 case RULE_OP_MANGLE_APPEND
:
21994 NEXT_RULEPOS (rule_pos
);
21995 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
21998 case RULE_OP_MANGLE_PREPEND
:
21999 NEXT_RULEPOS (rule_pos
);
22000 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
22003 case RULE_OP_MANGLE_DELETE_FIRST
:
22004 out_len
= mangle_delete_at (out
, out_len
, 0);
22007 case RULE_OP_MANGLE_DELETE_LAST
:
22008 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
22011 case RULE_OP_MANGLE_DELETE_AT
:
22012 NEXT_RULEPOS (rule_pos
);
22013 NEXT_RPTOI (rule
, rule_pos
, upos
);
22014 out_len
= mangle_delete_at (out
, out_len
, upos
);
22017 case RULE_OP_MANGLE_EXTRACT
:
22018 NEXT_RULEPOS (rule_pos
);
22019 NEXT_RPTOI (rule
, rule_pos
, upos
);
22020 NEXT_RULEPOS (rule_pos
);
22021 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22022 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
22025 case RULE_OP_MANGLE_OMIT
:
22026 NEXT_RULEPOS (rule_pos
);
22027 NEXT_RPTOI (rule
, rule_pos
, upos
);
22028 NEXT_RULEPOS (rule_pos
);
22029 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22030 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
22033 case RULE_OP_MANGLE_INSERT
:
22034 NEXT_RULEPOS (rule_pos
);
22035 NEXT_RPTOI (rule
, rule_pos
, upos
);
22036 NEXT_RULEPOS (rule_pos
);
22037 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
22040 case RULE_OP_MANGLE_OVERSTRIKE
:
22041 NEXT_RULEPOS (rule_pos
);
22042 NEXT_RPTOI (rule
, rule_pos
, upos
);
22043 NEXT_RULEPOS (rule_pos
);
22044 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
22047 case RULE_OP_MANGLE_TRUNCATE_AT
:
22048 NEXT_RULEPOS (rule_pos
);
22049 NEXT_RPTOI (rule
, rule_pos
, upos
);
22050 out_len
= mangle_truncate_at (out
, out_len
, upos
);
22053 case RULE_OP_MANGLE_REPLACE
:
22054 NEXT_RULEPOS (rule_pos
);
22055 NEXT_RULEPOS (rule_pos
);
22056 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
22059 case RULE_OP_MANGLE_PURGECHAR
:
22060 NEXT_RULEPOS (rule_pos
);
22061 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
22064 case RULE_OP_MANGLE_TOGGLECASE_REC
:
22068 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
22069 NEXT_RULEPOS (rule_pos
);
22070 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22071 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
22074 case RULE_OP_MANGLE_DUPECHAR_LAST
:
22075 NEXT_RULEPOS (rule_pos
);
22076 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22077 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
22080 case RULE_OP_MANGLE_DUPECHAR_ALL
:
22081 out_len
= mangle_dupechar (out
, out_len
);
22084 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
22085 NEXT_RULEPOS (rule_pos
);
22086 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22087 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
22090 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
22091 NEXT_RULEPOS (rule_pos
);
22092 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22093 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
22096 case RULE_OP_MANGLE_SWITCH_FIRST
:
22097 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
22100 case RULE_OP_MANGLE_SWITCH_LAST
:
22101 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
22104 case RULE_OP_MANGLE_SWITCH_AT
:
22105 NEXT_RULEPOS (rule_pos
);
22106 NEXT_RPTOI (rule
, rule_pos
, upos
);
22107 NEXT_RULEPOS (rule_pos
);
22108 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22109 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
22112 case RULE_OP_MANGLE_CHR_SHIFTL
:
22113 NEXT_RULEPOS (rule_pos
);
22114 NEXT_RPTOI (rule
, rule_pos
, upos
);
22115 mangle_chr_shiftl (out
, out_len
, upos
);
22118 case RULE_OP_MANGLE_CHR_SHIFTR
:
22119 NEXT_RULEPOS (rule_pos
);
22120 NEXT_RPTOI (rule
, rule_pos
, upos
);
22121 mangle_chr_shiftr (out
, out_len
, upos
);
22124 case RULE_OP_MANGLE_CHR_INCR
:
22125 NEXT_RULEPOS (rule_pos
);
22126 NEXT_RPTOI (rule
, rule_pos
, upos
);
22127 mangle_chr_incr (out
, out_len
, upos
);
22130 case RULE_OP_MANGLE_CHR_DECR
:
22131 NEXT_RULEPOS (rule_pos
);
22132 NEXT_RPTOI (rule
, rule_pos
, upos
);
22133 mangle_chr_decr (out
, out_len
, upos
);
22136 case RULE_OP_MANGLE_REPLACE_NP1
:
22137 NEXT_RULEPOS (rule_pos
);
22138 NEXT_RPTOI (rule
, rule_pos
, upos
);
22139 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
22142 case RULE_OP_MANGLE_REPLACE_NM1
:
22143 NEXT_RULEPOS (rule_pos
);
22144 NEXT_RPTOI (rule
, rule_pos
, upos
);
22145 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
22148 case RULE_OP_MANGLE_TITLE
:
22149 out_len
= mangle_title (out
, out_len
);
22152 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
22153 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22154 NEXT_RULEPOS (rule_pos
);
22155 NEXT_RPTOI (rule
, rule_pos
, upos
);
22156 NEXT_RULEPOS (rule_pos
);
22157 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22158 NEXT_RULEPOS (rule_pos
);
22159 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22160 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
22163 case RULE_OP_MANGLE_APPEND_MEMORY
:
22164 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22165 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22166 memcpy (out
+ out_len
, mem
, mem_len
);
22167 out_len
+= mem_len
;
22170 case RULE_OP_MANGLE_PREPEND_MEMORY
:
22171 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22172 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22173 memcpy (mem
+ mem_len
, out
, out_len
);
22174 out_len
+= mem_len
;
22175 memcpy (out
, mem
, out_len
);
22178 case RULE_OP_MEMORIZE_WORD
:
22179 memcpy (mem
, out
, out_len
);
22183 case RULE_OP_REJECT_LESS
:
22184 NEXT_RULEPOS (rule_pos
);
22185 NEXT_RPTOI (rule
, rule_pos
, upos
);
22186 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
22189 case RULE_OP_REJECT_GREATER
:
22190 NEXT_RULEPOS (rule_pos
);
22191 NEXT_RPTOI (rule
, rule_pos
, upos
);
22192 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
22195 case RULE_OP_REJECT_CONTAIN
:
22196 NEXT_RULEPOS (rule_pos
);
22197 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
22200 case RULE_OP_REJECT_NOT_CONTAIN
:
22201 NEXT_RULEPOS (rule_pos
);
22202 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
22205 case RULE_OP_REJECT_EQUAL_FIRST
:
22206 NEXT_RULEPOS (rule_pos
);
22207 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22210 case RULE_OP_REJECT_EQUAL_LAST
:
22211 NEXT_RULEPOS (rule_pos
);
22212 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22215 case RULE_OP_REJECT_EQUAL_AT
:
22216 NEXT_RULEPOS (rule_pos
);
22217 NEXT_RPTOI (rule
, rule_pos
, upos
);
22218 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22219 NEXT_RULEPOS (rule_pos
);
22220 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22223 case RULE_OP_REJECT_CONTAINS
:
22224 NEXT_RULEPOS (rule_pos
);
22225 NEXT_RPTOI (rule
, rule_pos
, upos
);
22226 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22227 NEXT_RULEPOS (rule_pos
);
22228 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
22229 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
22232 case RULE_OP_REJECT_MEMORY
:
22233 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
22237 return (RULE_RC_SYNTAX_ERROR
);
22242 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);