2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
20 u32
is_power_of_2(u32 v
)
22 return (v
&& !(v
& (v
- 1)));
25 u32
rotl32 (const u32 a
, const u32 n
)
27 return ((a
<< n
) | (a
>> (32 - n
)));
30 u32
rotr32 (const u32 a
, const u32 n
)
32 return ((a
>> n
) | (a
<< (32 - n
)));
35 u64
rotl64 (const u64 a
, const u64 n
)
37 return ((a
<< n
) | (a
>> (64 - n
)));
40 u64
rotr64 (const u64 a
, const u64 n
)
42 return ((a
>> n
) | (a
<< (64 - n
)));
45 u32
byte_swap_32 (const u32 n
)
47 return (n
& 0xff000000) >> 24
48 | (n
& 0x00ff0000) >> 8
49 | (n
& 0x0000ff00) << 8
50 | (n
& 0x000000ff) << 24;
53 u64
byte_swap_64 (const u64 n
)
55 return (n
& 0xff00000000000000ULL
) >> 56
56 | (n
& 0x00ff000000000000ULL
) >> 40
57 | (n
& 0x0000ff0000000000ULL
) >> 24
58 | (n
& 0x000000ff00000000ULL
) >> 8
59 | (n
& 0x00000000ff000000ULL
) << 8
60 | (n
& 0x0000000000ff0000ULL
) << 24
61 | (n
& 0x000000000000ff00ULL
) << 40
62 | (n
& 0x00000000000000ffULL
) << 56;
66 * ciphers for use on cpu
73 * hashes for use on cpu
78 #include "cpu-sha256.c"
86 void log_final (FILE *fp
, const char *fmt
, va_list ap
)
92 for (int i
= 0; i
< last_len
; i
++)
100 char s
[4096] = { 0 };
102 int max_len
= (int) sizeof (s
);
104 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
106 if (len
> max_len
) len
= max_len
;
108 fwrite (s
, len
, 1, fp
);
115 void log_out_nn (FILE *fp
, const char *fmt
, ...)
117 if (SUPPRESS_OUTPUT
) return;
123 log_final (fp
, fmt
, ap
);
128 void log_info_nn (const char *fmt
, ...)
130 if (SUPPRESS_OUTPUT
) return;
136 log_final (stdout
, fmt
, ap
);
141 void log_error_nn (const char *fmt
, ...)
143 if (SUPPRESS_OUTPUT
) return;
149 log_final (stderr
, fmt
, ap
);
154 void log_out (FILE *fp
, const char *fmt
, ...)
156 if (SUPPRESS_OUTPUT
) return;
162 log_final (fp
, fmt
, ap
);
171 void log_info (const char *fmt
, ...)
173 if (SUPPRESS_OUTPUT
) return;
179 log_final (stdout
, fmt
, ap
);
183 fputc ('\n', stdout
);
188 void log_error (const char *fmt
, ...)
190 if (SUPPRESS_OUTPUT
) return;
192 fputc ('\n', stderr
);
193 fputc ('\n', stderr
);
199 log_final (stderr
, fmt
, ap
);
203 fputc ('\n', stderr
);
204 fputc ('\n', stderr
);
213 u8
int_to_base32 (const u8 c
)
215 static const u8 tbl
[0x20] =
217 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
218 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
224 u8
base32_to_int (const u8 c
)
226 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
227 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
232 u8
int_to_itoa32 (const u8 c
)
234 static const u8 tbl
[0x20] =
236 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
237 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
243 u8
itoa32_to_int (const u8 c
)
245 if ((c
>= '0') && (c
<= '9')) return c
- '0';
246 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
251 u8
int_to_itoa64 (const u8 c
)
253 static const u8 tbl
[0x40] =
255 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
256 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
257 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
258 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
264 u8
itoa64_to_int (const u8 c
)
266 static const u8 tbl
[0x100] =
268 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
269 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
270 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
271 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
272 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
273 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
274 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
275 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
276 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
277 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
278 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
279 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
280 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
281 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
282 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
283 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
289 u8
int_to_base64 (const u8 c
)
291 static const u8 tbl
[0x40] =
293 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
294 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
295 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
296 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
302 u8
base64_to_int (const u8 c
)
304 static const u8 tbl
[0x100] =
306 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
307 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
308 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
309 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
310 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
311 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
312 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
313 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
314 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
315 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
316 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
317 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
318 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
319 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
320 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
321 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
327 u8
int_to_bf64 (const u8 c
)
329 static const u8 tbl
[0x40] =
331 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
332 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
333 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
334 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
340 u8
bf64_to_int (const u8 c
)
342 static const u8 tbl
[0x100] =
344 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
345 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
346 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
347 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
348 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
349 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
350 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
351 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
352 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
353 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
354 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
355 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
356 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
357 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
358 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
359 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
365 u8
int_to_lotus64 (const u8 c
)
367 if (c
< 10) return '0' + c
;
368 else if (c
< 36) return 'A' + c
- 10;
369 else if (c
< 62) return 'a' + c
- 36;
370 else if (c
== 62) return '+';
371 else if (c
== 63) return '/';
376 u8
lotus64_to_int (const u8 c
)
378 if ((c
>= '0') && (c
<= '9')) return c
- '0';
379 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
380 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
381 else if (c
== '+') return 62;
382 else if (c
== '/') return 63;
388 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
390 const u8
*in_ptr
= in_buf
;
392 u8
*out_ptr
= out_buf
;
394 for (int i
= 0; i
< in_len
; i
+= 8)
396 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
397 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
398 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
399 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
400 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
401 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
402 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
403 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
405 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
406 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
407 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
408 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
409 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
415 for (int i
= 0; i
< in_len
; i
++)
417 if (in_buf
[i
] != '=') continue;
422 int out_len
= (in_len
* 5) / 8;
427 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
429 const u8
*in_ptr
= in_buf
;
431 u8
*out_ptr
= out_buf
;
433 for (int i
= 0; i
< in_len
; i
+= 5)
435 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
436 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
437 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
438 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
439 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
440 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
441 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
442 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
444 out_ptr
[0] = out_val0
& 0x7f;
445 out_ptr
[1] = out_val1
& 0x7f;
446 out_ptr
[2] = out_val2
& 0x7f;
447 out_ptr
[3] = out_val3
& 0x7f;
448 out_ptr
[4] = out_val4
& 0x7f;
449 out_ptr
[5] = out_val5
& 0x7f;
450 out_ptr
[6] = out_val6
& 0x7f;
451 out_ptr
[7] = out_val7
& 0x7f;
457 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
461 out_buf
[out_len
] = '=';
469 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
471 const u8
*in_ptr
= in_buf
;
473 u8
*out_ptr
= out_buf
;
475 for (int i
= 0; i
< in_len
; i
+= 4)
477 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
478 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
479 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
480 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
482 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
483 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
484 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
490 for (int i
= 0; i
< in_len
; i
++)
492 if (in_buf
[i
] != '=') continue;
497 int out_len
= (in_len
* 6) / 8;
502 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
504 const u8
*in_ptr
= in_buf
;
506 u8
*out_ptr
= out_buf
;
508 for (int i
= 0; i
< in_len
; i
+= 3)
510 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
511 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
512 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
513 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
515 out_ptr
[0] = out_val0
& 0x7f;
516 out_ptr
[1] = out_val1
& 0x7f;
517 out_ptr
[2] = out_val2
& 0x7f;
518 out_ptr
[3] = out_val3
& 0x7f;
524 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
528 out_buf
[out_len
] = '=';
536 int is_valid_hex_char (const u8 c
)
538 if ((c
>= '0') && (c
<= '9')) return 1;
539 if ((c
>= 'A') && (c
<= 'F')) return 1;
540 if ((c
>= 'a') && (c
<= 'f')) return 1;
545 u8
hex_convert (const u8 c
)
547 return (c
& 15) + (c
>> 6) * 9;
550 u8
hex_to_u8 (const u8 hex
[2])
554 v
|= (hex_convert (hex
[1]) << 0);
555 v
|= (hex_convert (hex
[0]) << 4);
560 u32
hex_to_u32 (const u8 hex
[8])
564 v
|= ((u32
) hex_convert (hex
[7])) << 0;
565 v
|= ((u32
) hex_convert (hex
[6])) << 4;
566 v
|= ((u32
) hex_convert (hex
[5])) << 8;
567 v
|= ((u32
) hex_convert (hex
[4])) << 12;
568 v
|= ((u32
) hex_convert (hex
[3])) << 16;
569 v
|= ((u32
) hex_convert (hex
[2])) << 20;
570 v
|= ((u32
) hex_convert (hex
[1])) << 24;
571 v
|= ((u32
) hex_convert (hex
[0])) << 28;
576 u64
hex_to_u64 (const u8 hex
[16])
580 v
|= ((u64
) hex_convert (hex
[15]) << 0);
581 v
|= ((u64
) hex_convert (hex
[14]) << 4);
582 v
|= ((u64
) hex_convert (hex
[13]) << 8);
583 v
|= ((u64
) hex_convert (hex
[12]) << 12);
584 v
|= ((u64
) hex_convert (hex
[11]) << 16);
585 v
|= ((u64
) hex_convert (hex
[10]) << 20);
586 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
587 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
588 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
589 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
590 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
591 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
592 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
593 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
594 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
595 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
600 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
602 hex
[0] = v
>> 28 & 15;
603 hex
[1] = v
>> 24 & 15;
604 hex
[2] = v
>> 20 & 15;
605 hex
[3] = v
>> 16 & 15;
606 hex
[4] = v
>> 12 & 15;
607 hex
[5] = v
>> 8 & 15;
608 hex
[6] = v
>> 4 & 15;
609 hex
[7] = v
>> 0 & 15;
613 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
614 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
615 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
616 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
617 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
618 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
619 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
620 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
627 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
631 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
640 for (int i
= 0; i
< 16; i
+= 4)
650 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
657 out
[i
+ 0] = _out
[0];
658 out
[i
+ 1] = _out
[1];
659 out
[i
+ 2] = _out
[2];
660 out
[i
+ 3] = _out
[3];
669 static void juniper_decrypt_hash (char *in
, char *out
)
673 u8 base64_buf
[100] = { 0 };
675 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
679 u32 juniper_iv
[4] = { 0 };
681 memcpy (juniper_iv
, base64_buf
, 12);
683 memcpy (out
, juniper_iv
, 12);
687 u32 juniper_key
[4] = { 0 };
689 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
690 juniper_key
[1] = byte_swap_32 (0x8df91059);
691 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
692 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
696 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
697 u32
*out_ptr
= (u32
*) (out
+ 12);
699 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
702 void phpass_decode (u8 digest
[16], u8 buf
[22])
706 l
= itoa64_to_int (buf
[ 0]) << 0;
707 l
|= itoa64_to_int (buf
[ 1]) << 6;
708 l
|= itoa64_to_int (buf
[ 2]) << 12;
709 l
|= itoa64_to_int (buf
[ 3]) << 18;
711 digest
[ 0] = (l
>> 0) & 0xff;
712 digest
[ 1] = (l
>> 8) & 0xff;
713 digest
[ 2] = (l
>> 16) & 0xff;
715 l
= itoa64_to_int (buf
[ 4]) << 0;
716 l
|= itoa64_to_int (buf
[ 5]) << 6;
717 l
|= itoa64_to_int (buf
[ 6]) << 12;
718 l
|= itoa64_to_int (buf
[ 7]) << 18;
720 digest
[ 3] = (l
>> 0) & 0xff;
721 digest
[ 4] = (l
>> 8) & 0xff;
722 digest
[ 5] = (l
>> 16) & 0xff;
724 l
= itoa64_to_int (buf
[ 8]) << 0;
725 l
|= itoa64_to_int (buf
[ 9]) << 6;
726 l
|= itoa64_to_int (buf
[10]) << 12;
727 l
|= itoa64_to_int (buf
[11]) << 18;
729 digest
[ 6] = (l
>> 0) & 0xff;
730 digest
[ 7] = (l
>> 8) & 0xff;
731 digest
[ 8] = (l
>> 16) & 0xff;
733 l
= itoa64_to_int (buf
[12]) << 0;
734 l
|= itoa64_to_int (buf
[13]) << 6;
735 l
|= itoa64_to_int (buf
[14]) << 12;
736 l
|= itoa64_to_int (buf
[15]) << 18;
738 digest
[ 9] = (l
>> 0) & 0xff;
739 digest
[10] = (l
>> 8) & 0xff;
740 digest
[11] = (l
>> 16) & 0xff;
742 l
= itoa64_to_int (buf
[16]) << 0;
743 l
|= itoa64_to_int (buf
[17]) << 6;
744 l
|= itoa64_to_int (buf
[18]) << 12;
745 l
|= itoa64_to_int (buf
[19]) << 18;
747 digest
[12] = (l
>> 0) & 0xff;
748 digest
[13] = (l
>> 8) & 0xff;
749 digest
[14] = (l
>> 16) & 0xff;
751 l
= itoa64_to_int (buf
[20]) << 0;
752 l
|= itoa64_to_int (buf
[21]) << 6;
754 digest
[15] = (l
>> 0) & 0xff;
757 void phpass_encode (u8 digest
[16], u8 buf
[22])
761 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
763 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
764 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
765 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
766 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
768 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
770 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
771 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
772 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
773 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
775 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
777 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
778 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
779 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
780 buf
[11] = int_to_itoa64 (l
& 0x3f);
782 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
784 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
785 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
786 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
787 buf
[15] = int_to_itoa64 (l
& 0x3f);
789 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
791 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
792 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
793 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
794 buf
[19] = int_to_itoa64 (l
& 0x3f);
796 l
= (digest
[15] << 0);
798 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
799 buf
[21] = int_to_itoa64 (l
& 0x3f);
802 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
806 l
= itoa64_to_int (buf
[ 0]) << 0;
807 l
|= itoa64_to_int (buf
[ 1]) << 6;
808 l
|= itoa64_to_int (buf
[ 2]) << 12;
809 l
|= itoa64_to_int (buf
[ 3]) << 18;
811 digest
[ 0] = (l
>> 16) & 0xff;
812 digest
[ 6] = (l
>> 8) & 0xff;
813 digest
[12] = (l
>> 0) & 0xff;
815 l
= itoa64_to_int (buf
[ 4]) << 0;
816 l
|= itoa64_to_int (buf
[ 5]) << 6;
817 l
|= itoa64_to_int (buf
[ 6]) << 12;
818 l
|= itoa64_to_int (buf
[ 7]) << 18;
820 digest
[ 1] = (l
>> 16) & 0xff;
821 digest
[ 7] = (l
>> 8) & 0xff;
822 digest
[13] = (l
>> 0) & 0xff;
824 l
= itoa64_to_int (buf
[ 8]) << 0;
825 l
|= itoa64_to_int (buf
[ 9]) << 6;
826 l
|= itoa64_to_int (buf
[10]) << 12;
827 l
|= itoa64_to_int (buf
[11]) << 18;
829 digest
[ 2] = (l
>> 16) & 0xff;
830 digest
[ 8] = (l
>> 8) & 0xff;
831 digest
[14] = (l
>> 0) & 0xff;
833 l
= itoa64_to_int (buf
[12]) << 0;
834 l
|= itoa64_to_int (buf
[13]) << 6;
835 l
|= itoa64_to_int (buf
[14]) << 12;
836 l
|= itoa64_to_int (buf
[15]) << 18;
838 digest
[ 3] = (l
>> 16) & 0xff;
839 digest
[ 9] = (l
>> 8) & 0xff;
840 digest
[15] = (l
>> 0) & 0xff;
842 l
= itoa64_to_int (buf
[16]) << 0;
843 l
|= itoa64_to_int (buf
[17]) << 6;
844 l
|= itoa64_to_int (buf
[18]) << 12;
845 l
|= itoa64_to_int (buf
[19]) << 18;
847 digest
[ 4] = (l
>> 16) & 0xff;
848 digest
[10] = (l
>> 8) & 0xff;
849 digest
[ 5] = (l
>> 0) & 0xff;
851 l
= itoa64_to_int (buf
[20]) << 0;
852 l
|= itoa64_to_int (buf
[21]) << 6;
854 digest
[11] = (l
>> 0) & 0xff;
857 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
861 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
863 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
864 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
865 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
866 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
868 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
870 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
871 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
872 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
873 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
875 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
877 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
879 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
880 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
882 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
884 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
886 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
887 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
889 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
891 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
893 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
894 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
896 l
= (digest
[11] << 0);
898 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
899 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
902 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
906 l
= itoa64_to_int (buf
[ 0]) << 0;
907 l
|= itoa64_to_int (buf
[ 1]) << 6;
908 l
|= itoa64_to_int (buf
[ 2]) << 12;
909 l
|= itoa64_to_int (buf
[ 3]) << 18;
911 digest
[ 0] = (l
>> 16) & 0xff;
912 digest
[21] = (l
>> 8) & 0xff;
913 digest
[42] = (l
>> 0) & 0xff;
915 l
= itoa64_to_int (buf
[ 4]) << 0;
916 l
|= itoa64_to_int (buf
[ 5]) << 6;
917 l
|= itoa64_to_int (buf
[ 6]) << 12;
918 l
|= itoa64_to_int (buf
[ 7]) << 18;
920 digest
[22] = (l
>> 16) & 0xff;
921 digest
[43] = (l
>> 8) & 0xff;
922 digest
[ 1] = (l
>> 0) & 0xff;
924 l
= itoa64_to_int (buf
[ 8]) << 0;
925 l
|= itoa64_to_int (buf
[ 9]) << 6;
926 l
|= itoa64_to_int (buf
[10]) << 12;
927 l
|= itoa64_to_int (buf
[11]) << 18;
929 digest
[44] = (l
>> 16) & 0xff;
930 digest
[ 2] = (l
>> 8) & 0xff;
931 digest
[23] = (l
>> 0) & 0xff;
933 l
= itoa64_to_int (buf
[12]) << 0;
934 l
|= itoa64_to_int (buf
[13]) << 6;
935 l
|= itoa64_to_int (buf
[14]) << 12;
936 l
|= itoa64_to_int (buf
[15]) << 18;
938 digest
[ 3] = (l
>> 16) & 0xff;
939 digest
[24] = (l
>> 8) & 0xff;
940 digest
[45] = (l
>> 0) & 0xff;
942 l
= itoa64_to_int (buf
[16]) << 0;
943 l
|= itoa64_to_int (buf
[17]) << 6;
944 l
|= itoa64_to_int (buf
[18]) << 12;
945 l
|= itoa64_to_int (buf
[19]) << 18;
947 digest
[25] = (l
>> 16) & 0xff;
948 digest
[46] = (l
>> 8) & 0xff;
949 digest
[ 4] = (l
>> 0) & 0xff;
951 l
= itoa64_to_int (buf
[20]) << 0;
952 l
|= itoa64_to_int (buf
[21]) << 6;
953 l
|= itoa64_to_int (buf
[22]) << 12;
954 l
|= itoa64_to_int (buf
[23]) << 18;
956 digest
[47] = (l
>> 16) & 0xff;
957 digest
[ 5] = (l
>> 8) & 0xff;
958 digest
[26] = (l
>> 0) & 0xff;
960 l
= itoa64_to_int (buf
[24]) << 0;
961 l
|= itoa64_to_int (buf
[25]) << 6;
962 l
|= itoa64_to_int (buf
[26]) << 12;
963 l
|= itoa64_to_int (buf
[27]) << 18;
965 digest
[ 6] = (l
>> 16) & 0xff;
966 digest
[27] = (l
>> 8) & 0xff;
967 digest
[48] = (l
>> 0) & 0xff;
969 l
= itoa64_to_int (buf
[28]) << 0;
970 l
|= itoa64_to_int (buf
[29]) << 6;
971 l
|= itoa64_to_int (buf
[30]) << 12;
972 l
|= itoa64_to_int (buf
[31]) << 18;
974 digest
[28] = (l
>> 16) & 0xff;
975 digest
[49] = (l
>> 8) & 0xff;
976 digest
[ 7] = (l
>> 0) & 0xff;
978 l
= itoa64_to_int (buf
[32]) << 0;
979 l
|= itoa64_to_int (buf
[33]) << 6;
980 l
|= itoa64_to_int (buf
[34]) << 12;
981 l
|= itoa64_to_int (buf
[35]) << 18;
983 digest
[50] = (l
>> 16) & 0xff;
984 digest
[ 8] = (l
>> 8) & 0xff;
985 digest
[29] = (l
>> 0) & 0xff;
987 l
= itoa64_to_int (buf
[36]) << 0;
988 l
|= itoa64_to_int (buf
[37]) << 6;
989 l
|= itoa64_to_int (buf
[38]) << 12;
990 l
|= itoa64_to_int (buf
[39]) << 18;
992 digest
[ 9] = (l
>> 16) & 0xff;
993 digest
[30] = (l
>> 8) & 0xff;
994 digest
[51] = (l
>> 0) & 0xff;
996 l
= itoa64_to_int (buf
[40]) << 0;
997 l
|= itoa64_to_int (buf
[41]) << 6;
998 l
|= itoa64_to_int (buf
[42]) << 12;
999 l
|= itoa64_to_int (buf
[43]) << 18;
1001 digest
[31] = (l
>> 16) & 0xff;
1002 digest
[52] = (l
>> 8) & 0xff;
1003 digest
[10] = (l
>> 0) & 0xff;
1005 l
= itoa64_to_int (buf
[44]) << 0;
1006 l
|= itoa64_to_int (buf
[45]) << 6;
1007 l
|= itoa64_to_int (buf
[46]) << 12;
1008 l
|= itoa64_to_int (buf
[47]) << 18;
1010 digest
[53] = (l
>> 16) & 0xff;
1011 digest
[11] = (l
>> 8) & 0xff;
1012 digest
[32] = (l
>> 0) & 0xff;
1014 l
= itoa64_to_int (buf
[48]) << 0;
1015 l
|= itoa64_to_int (buf
[49]) << 6;
1016 l
|= itoa64_to_int (buf
[50]) << 12;
1017 l
|= itoa64_to_int (buf
[51]) << 18;
1019 digest
[12] = (l
>> 16) & 0xff;
1020 digest
[33] = (l
>> 8) & 0xff;
1021 digest
[54] = (l
>> 0) & 0xff;
1023 l
= itoa64_to_int (buf
[52]) << 0;
1024 l
|= itoa64_to_int (buf
[53]) << 6;
1025 l
|= itoa64_to_int (buf
[54]) << 12;
1026 l
|= itoa64_to_int (buf
[55]) << 18;
1028 digest
[34] = (l
>> 16) & 0xff;
1029 digest
[55] = (l
>> 8) & 0xff;
1030 digest
[13] = (l
>> 0) & 0xff;
1032 l
= itoa64_to_int (buf
[56]) << 0;
1033 l
|= itoa64_to_int (buf
[57]) << 6;
1034 l
|= itoa64_to_int (buf
[58]) << 12;
1035 l
|= itoa64_to_int (buf
[59]) << 18;
1037 digest
[56] = (l
>> 16) & 0xff;
1038 digest
[14] = (l
>> 8) & 0xff;
1039 digest
[35] = (l
>> 0) & 0xff;
1041 l
= itoa64_to_int (buf
[60]) << 0;
1042 l
|= itoa64_to_int (buf
[61]) << 6;
1043 l
|= itoa64_to_int (buf
[62]) << 12;
1044 l
|= itoa64_to_int (buf
[63]) << 18;
1046 digest
[15] = (l
>> 16) & 0xff;
1047 digest
[36] = (l
>> 8) & 0xff;
1048 digest
[57] = (l
>> 0) & 0xff;
1050 l
= itoa64_to_int (buf
[64]) << 0;
1051 l
|= itoa64_to_int (buf
[65]) << 6;
1052 l
|= itoa64_to_int (buf
[66]) << 12;
1053 l
|= itoa64_to_int (buf
[67]) << 18;
1055 digest
[37] = (l
>> 16) & 0xff;
1056 digest
[58] = (l
>> 8) & 0xff;
1057 digest
[16] = (l
>> 0) & 0xff;
1059 l
= itoa64_to_int (buf
[68]) << 0;
1060 l
|= itoa64_to_int (buf
[69]) << 6;
1061 l
|= itoa64_to_int (buf
[70]) << 12;
1062 l
|= itoa64_to_int (buf
[71]) << 18;
1064 digest
[59] = (l
>> 16) & 0xff;
1065 digest
[17] = (l
>> 8) & 0xff;
1066 digest
[38] = (l
>> 0) & 0xff;
1068 l
= itoa64_to_int (buf
[72]) << 0;
1069 l
|= itoa64_to_int (buf
[73]) << 6;
1070 l
|= itoa64_to_int (buf
[74]) << 12;
1071 l
|= itoa64_to_int (buf
[75]) << 18;
1073 digest
[18] = (l
>> 16) & 0xff;
1074 digest
[39] = (l
>> 8) & 0xff;
1075 digest
[60] = (l
>> 0) & 0xff;
1077 l
= itoa64_to_int (buf
[76]) << 0;
1078 l
|= itoa64_to_int (buf
[77]) << 6;
1079 l
|= itoa64_to_int (buf
[78]) << 12;
1080 l
|= itoa64_to_int (buf
[79]) << 18;
1082 digest
[40] = (l
>> 16) & 0xff;
1083 digest
[61] = (l
>> 8) & 0xff;
1084 digest
[19] = (l
>> 0) & 0xff;
1086 l
= itoa64_to_int (buf
[80]) << 0;
1087 l
|= itoa64_to_int (buf
[81]) << 6;
1088 l
|= itoa64_to_int (buf
[82]) << 12;
1089 l
|= itoa64_to_int (buf
[83]) << 18;
1091 digest
[62] = (l
>> 16) & 0xff;
1092 digest
[20] = (l
>> 8) & 0xff;
1093 digest
[41] = (l
>> 0) & 0xff;
1095 l
= itoa64_to_int (buf
[84]) << 0;
1096 l
|= itoa64_to_int (buf
[85]) << 6;
1098 digest
[63] = (l
>> 0) & 0xff;
1101 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1105 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1107 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1108 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1109 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1110 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1112 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1114 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1115 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1116 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1117 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1119 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1121 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1123 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1124 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1126 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1128 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1130 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1131 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1133 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1135 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1137 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1138 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1140 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1142 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1144 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1145 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1147 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1149 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1151 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1152 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1154 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1156 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1158 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1159 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1161 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1163 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1165 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1166 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1168 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1170 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1172 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1173 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1175 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1177 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1179 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1180 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1182 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1184 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1186 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1187 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1189 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1191 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1193 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1194 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1196 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1198 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1200 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1201 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1203 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1205 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1207 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1208 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1210 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1212 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1214 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1215 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1217 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1219 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1221 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1222 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1224 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1226 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1228 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1229 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1231 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1233 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1235 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1236 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1238 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1240 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1242 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1243 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1245 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1247 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1249 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1250 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1252 l
= 0 | 0 | (digest
[63] << 0);
1254 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1255 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1258 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1262 l
= itoa64_to_int (buf
[ 0]) << 0;
1263 l
|= itoa64_to_int (buf
[ 1]) << 6;
1264 l
|= itoa64_to_int (buf
[ 2]) << 12;
1265 l
|= itoa64_to_int (buf
[ 3]) << 18;
1267 digest
[ 2] = (l
>> 0) & 0xff;
1268 digest
[ 1] = (l
>> 8) & 0xff;
1269 digest
[ 0] = (l
>> 16) & 0xff;
1271 l
= itoa64_to_int (buf
[ 4]) << 0;
1272 l
|= itoa64_to_int (buf
[ 5]) << 6;
1273 l
|= itoa64_to_int (buf
[ 6]) << 12;
1274 l
|= itoa64_to_int (buf
[ 7]) << 18;
1276 digest
[ 5] = (l
>> 0) & 0xff;
1277 digest
[ 4] = (l
>> 8) & 0xff;
1278 digest
[ 3] = (l
>> 16) & 0xff;
1280 l
= itoa64_to_int (buf
[ 8]) << 0;
1281 l
|= itoa64_to_int (buf
[ 9]) << 6;
1282 l
|= itoa64_to_int (buf
[10]) << 12;
1283 l
|= itoa64_to_int (buf
[11]) << 18;
1285 digest
[ 8] = (l
>> 0) & 0xff;
1286 digest
[ 7] = (l
>> 8) & 0xff;
1287 digest
[ 6] = (l
>> 16) & 0xff;
1289 l
= itoa64_to_int (buf
[12]) << 0;
1290 l
|= itoa64_to_int (buf
[13]) << 6;
1291 l
|= itoa64_to_int (buf
[14]) << 12;
1292 l
|= itoa64_to_int (buf
[15]) << 18;
1294 digest
[11] = (l
>> 0) & 0xff;
1295 digest
[10] = (l
>> 8) & 0xff;
1296 digest
[ 9] = (l
>> 16) & 0xff;
1298 l
= itoa64_to_int (buf
[16]) << 0;
1299 l
|= itoa64_to_int (buf
[17]) << 6;
1300 l
|= itoa64_to_int (buf
[18]) << 12;
1301 l
|= itoa64_to_int (buf
[19]) << 18;
1303 digest
[14] = (l
>> 0) & 0xff;
1304 digest
[13] = (l
>> 8) & 0xff;
1305 digest
[12] = (l
>> 16) & 0xff;
1307 l
= itoa64_to_int (buf
[20]) << 0;
1308 l
|= itoa64_to_int (buf
[21]) << 6;
1309 l
|= itoa64_to_int (buf
[22]) << 12;
1310 l
|= itoa64_to_int (buf
[23]) << 18;
1312 digest
[17] = (l
>> 0) & 0xff;
1313 digest
[16] = (l
>> 8) & 0xff;
1314 digest
[15] = (l
>> 16) & 0xff;
1316 l
= itoa64_to_int (buf
[24]) << 0;
1317 l
|= itoa64_to_int (buf
[25]) << 6;
1318 l
|= itoa64_to_int (buf
[26]) << 12;
1320 digest
[19] = (l
>> 8) & 0xff;
1321 digest
[18] = (l
>> 16) & 0xff;
1324 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1328 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1330 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1331 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1332 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1333 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1335 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1337 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1338 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1339 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1340 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1342 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1344 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1345 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1346 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1347 buf
[11] = int_to_itoa64 (l
& 0x3f);
1349 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1351 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1352 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1353 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1354 buf
[15] = int_to_itoa64 (l
& 0x3f);
1356 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1358 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1359 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1360 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1361 buf
[19] = int_to_itoa64 (l
& 0x3f);
1363 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1365 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1366 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1367 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1368 buf
[23] = int_to_itoa64 (l
& 0x3f);
1370 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1372 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1373 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1374 buf
[26] = int_to_itoa64 (l
& 0x3f);
1377 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1381 l
= itoa64_to_int (buf
[ 0]) << 0;
1382 l
|= itoa64_to_int (buf
[ 1]) << 6;
1383 l
|= itoa64_to_int (buf
[ 2]) << 12;
1384 l
|= itoa64_to_int (buf
[ 3]) << 18;
1386 digest
[ 2] = (l
>> 0) & 0xff;
1387 digest
[ 1] = (l
>> 8) & 0xff;
1388 digest
[ 0] = (l
>> 16) & 0xff;
1390 l
= itoa64_to_int (buf
[ 4]) << 0;
1391 l
|= itoa64_to_int (buf
[ 5]) << 6;
1392 l
|= itoa64_to_int (buf
[ 6]) << 12;
1393 l
|= itoa64_to_int (buf
[ 7]) << 18;
1395 digest
[ 5] = (l
>> 0) & 0xff;
1396 digest
[ 4] = (l
>> 8) & 0xff;
1397 digest
[ 3] = (l
>> 16) & 0xff;
1399 l
= itoa64_to_int (buf
[ 8]) << 0;
1400 l
|= itoa64_to_int (buf
[ 9]) << 6;
1401 l
|= itoa64_to_int (buf
[10]) << 12;
1402 l
|= itoa64_to_int (buf
[11]) << 18;
1404 digest
[ 8] = (l
>> 0) & 0xff;
1405 digest
[ 7] = (l
>> 8) & 0xff;
1406 digest
[ 6] = (l
>> 16) & 0xff;
1408 l
= itoa64_to_int (buf
[12]) << 0;
1409 l
|= itoa64_to_int (buf
[13]) << 6;
1410 l
|= itoa64_to_int (buf
[14]) << 12;
1411 l
|= itoa64_to_int (buf
[15]) << 18;
1413 digest
[11] = (l
>> 0) & 0xff;
1414 digest
[10] = (l
>> 8) & 0xff;
1415 digest
[ 9] = (l
>> 16) & 0xff;
1417 l
= itoa64_to_int (buf
[16]) << 0;
1418 l
|= itoa64_to_int (buf
[17]) << 6;
1419 l
|= itoa64_to_int (buf
[18]) << 12;
1420 l
|= itoa64_to_int (buf
[19]) << 18;
1422 digest
[14] = (l
>> 0) & 0xff;
1423 digest
[13] = (l
>> 8) & 0xff;
1424 digest
[12] = (l
>> 16) & 0xff;
1426 l
= itoa64_to_int (buf
[20]) << 0;
1427 l
|= itoa64_to_int (buf
[21]) << 6;
1428 l
|= itoa64_to_int (buf
[22]) << 12;
1429 l
|= itoa64_to_int (buf
[23]) << 18;
1431 digest
[17] = (l
>> 0) & 0xff;
1432 digest
[16] = (l
>> 8) & 0xff;
1433 digest
[15] = (l
>> 16) & 0xff;
1435 l
= itoa64_to_int (buf
[24]) << 0;
1436 l
|= itoa64_to_int (buf
[25]) << 6;
1437 l
|= itoa64_to_int (buf
[26]) << 12;
1438 l
|= itoa64_to_int (buf
[27]) << 18;
1440 digest
[20] = (l
>> 0) & 0xff;
1441 digest
[19] = (l
>> 8) & 0xff;
1442 digest
[18] = (l
>> 16) & 0xff;
1444 l
= itoa64_to_int (buf
[28]) << 0;
1445 l
|= itoa64_to_int (buf
[29]) << 6;
1446 l
|= itoa64_to_int (buf
[30]) << 12;
1447 l
|= itoa64_to_int (buf
[31]) << 18;
1449 digest
[23] = (l
>> 0) & 0xff;
1450 digest
[22] = (l
>> 8) & 0xff;
1451 digest
[21] = (l
>> 16) & 0xff;
1453 l
= itoa64_to_int (buf
[32]) << 0;
1454 l
|= itoa64_to_int (buf
[33]) << 6;
1455 l
|= itoa64_to_int (buf
[34]) << 12;
1456 l
|= itoa64_to_int (buf
[35]) << 18;
1458 digest
[26] = (l
>> 0) & 0xff;
1459 digest
[25] = (l
>> 8) & 0xff;
1460 digest
[24] = (l
>> 16) & 0xff;
1462 l
= itoa64_to_int (buf
[36]) << 0;
1463 l
|= itoa64_to_int (buf
[37]) << 6;
1464 l
|= itoa64_to_int (buf
[38]) << 12;
1465 l
|= itoa64_to_int (buf
[39]) << 18;
1467 digest
[29] = (l
>> 0) & 0xff;
1468 digest
[28] = (l
>> 8) & 0xff;
1469 digest
[27] = (l
>> 16) & 0xff;
1471 l
= itoa64_to_int (buf
[40]) << 0;
1472 l
|= itoa64_to_int (buf
[41]) << 6;
1473 l
|= itoa64_to_int (buf
[42]) << 12;
1475 //digest[32] = (l >> 0) & 0xff;
1476 digest
[31] = (l
>> 8) & 0xff;
1477 digest
[30] = (l
>> 16) & 0xff;
1480 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1484 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1486 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1487 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1488 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1489 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1491 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1493 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1494 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1495 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1496 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1498 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1500 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1501 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1502 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1503 buf
[11] = int_to_itoa64 (l
& 0x3f);
1505 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1507 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1508 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1509 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1510 buf
[15] = int_to_itoa64 (l
& 0x3f);
1512 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1514 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1515 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1516 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1517 buf
[19] = int_to_itoa64 (l
& 0x3f);
1519 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1521 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1522 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1523 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1524 buf
[23] = int_to_itoa64 (l
& 0x3f);
1526 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1528 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1529 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1530 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1531 buf
[27] = int_to_itoa64 (l
& 0x3f);
1533 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1535 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1536 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1537 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1538 buf
[31] = int_to_itoa64 (l
& 0x3f);
1540 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1542 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1543 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1544 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1545 buf
[35] = int_to_itoa64 (l
& 0x3f);
1547 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1549 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1550 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1551 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1552 buf
[39] = int_to_itoa64 (l
& 0x3f);
1554 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1556 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1557 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1558 buf
[42] = int_to_itoa64 (l
& 0x3f);
1561 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1565 l
= itoa64_to_int (buf
[ 0]) << 0;
1566 l
|= itoa64_to_int (buf
[ 1]) << 6;
1567 l
|= itoa64_to_int (buf
[ 2]) << 12;
1568 l
|= itoa64_to_int (buf
[ 3]) << 18;
1570 digest
[ 2] = (l
>> 0) & 0xff;
1571 digest
[ 1] = (l
>> 8) & 0xff;
1572 digest
[ 0] = (l
>> 16) & 0xff;
1574 l
= itoa64_to_int (buf
[ 4]) << 0;
1575 l
|= itoa64_to_int (buf
[ 5]) << 6;
1576 l
|= itoa64_to_int (buf
[ 6]) << 12;
1577 l
|= itoa64_to_int (buf
[ 7]) << 18;
1579 digest
[ 5] = (l
>> 0) & 0xff;
1580 digest
[ 4] = (l
>> 8) & 0xff;
1581 digest
[ 3] = (l
>> 16) & 0xff;
1583 l
= itoa64_to_int (buf
[ 8]) << 0;
1584 l
|= itoa64_to_int (buf
[ 9]) << 6;
1585 l
|= itoa64_to_int (buf
[10]) << 12;
1586 l
|= itoa64_to_int (buf
[11]) << 18;
1588 digest
[ 8] = (l
>> 0) & 0xff;
1589 digest
[ 7] = (l
>> 8) & 0xff;
1590 digest
[ 6] = (l
>> 16) & 0xff;
1592 l
= itoa64_to_int (buf
[12]) << 0;
1593 l
|= itoa64_to_int (buf
[13]) << 6;
1594 l
|= itoa64_to_int (buf
[14]) << 12;
1595 l
|= itoa64_to_int (buf
[15]) << 18;
1597 digest
[11] = (l
>> 0) & 0xff;
1598 digest
[10] = (l
>> 8) & 0xff;
1599 digest
[ 9] = (l
>> 16) & 0xff;
1601 l
= itoa64_to_int (buf
[16]) << 0;
1602 l
|= itoa64_to_int (buf
[17]) << 6;
1603 l
|= itoa64_to_int (buf
[18]) << 12;
1604 l
|= itoa64_to_int (buf
[19]) << 18;
1606 digest
[14] = (l
>> 0) & 0xff;
1607 digest
[13] = (l
>> 8) & 0xff;
1608 digest
[12] = (l
>> 16) & 0xff;
1610 l
= itoa64_to_int (buf
[20]) << 0;
1611 l
|= itoa64_to_int (buf
[21]) << 6;
1612 l
|= itoa64_to_int (buf
[22]) << 12;
1613 l
|= itoa64_to_int (buf
[23]) << 18;
1615 digest
[17] = (l
>> 0) & 0xff;
1616 digest
[16] = (l
>> 8) & 0xff;
1617 digest
[15] = (l
>> 16) & 0xff;
1619 l
= itoa64_to_int (buf
[24]) << 0;
1620 l
|= itoa64_to_int (buf
[25]) << 6;
1621 l
|= itoa64_to_int (buf
[26]) << 12;
1622 l
|= itoa64_to_int (buf
[27]) << 18;
1624 digest
[20] = (l
>> 0) & 0xff;
1625 digest
[19] = (l
>> 8) & 0xff;
1626 digest
[18] = (l
>> 16) & 0xff;
1628 l
= itoa64_to_int (buf
[28]) << 0;
1629 l
|= itoa64_to_int (buf
[29]) << 6;
1630 l
|= itoa64_to_int (buf
[30]) << 12;
1631 l
|= itoa64_to_int (buf
[31]) << 18;
1633 digest
[23] = (l
>> 0) & 0xff;
1634 digest
[22] = (l
>> 8) & 0xff;
1635 digest
[21] = (l
>> 16) & 0xff;
1637 l
= itoa64_to_int (buf
[32]) << 0;
1638 l
|= itoa64_to_int (buf
[33]) << 6;
1639 l
|= itoa64_to_int (buf
[34]) << 12;
1640 l
|= itoa64_to_int (buf
[35]) << 18;
1642 digest
[26] = (l
>> 0) & 0xff;
1643 digest
[25] = (l
>> 8) & 0xff;
1644 digest
[24] = (l
>> 16) & 0xff;
1646 l
= itoa64_to_int (buf
[36]) << 0;
1647 l
|= itoa64_to_int (buf
[37]) << 6;
1648 l
|= itoa64_to_int (buf
[38]) << 12;
1649 l
|= itoa64_to_int (buf
[39]) << 18;
1651 digest
[29] = (l
>> 0) & 0xff;
1652 digest
[28] = (l
>> 8) & 0xff;
1653 digest
[27] = (l
>> 16) & 0xff;
1655 l
= itoa64_to_int (buf
[40]) << 0;
1656 l
|= itoa64_to_int (buf
[41]) << 6;
1657 l
|= itoa64_to_int (buf
[42]) << 12;
1658 l
|= itoa64_to_int (buf
[43]) << 18;
1660 digest
[32] = (l
>> 0) & 0xff;
1661 digest
[31] = (l
>> 8) & 0xff;
1662 digest
[30] = (l
>> 16) & 0xff;
1664 l
= itoa64_to_int (buf
[44]) << 0;
1665 l
|= itoa64_to_int (buf
[45]) << 6;
1666 l
|= itoa64_to_int (buf
[46]) << 12;
1667 l
|= itoa64_to_int (buf
[47]) << 18;
1669 digest
[35] = (l
>> 0) & 0xff;
1670 digest
[34] = (l
>> 8) & 0xff;
1671 digest
[33] = (l
>> 16) & 0xff;
1673 l
= itoa64_to_int (buf
[48]) << 0;
1674 l
|= itoa64_to_int (buf
[49]) << 6;
1675 l
|= itoa64_to_int (buf
[50]) << 12;
1676 l
|= itoa64_to_int (buf
[51]) << 18;
1678 digest
[38] = (l
>> 0) & 0xff;
1679 digest
[37] = (l
>> 8) & 0xff;
1680 digest
[36] = (l
>> 16) & 0xff;
1682 l
= itoa64_to_int (buf
[52]) << 0;
1683 l
|= itoa64_to_int (buf
[53]) << 6;
1684 l
|= itoa64_to_int (buf
[54]) << 12;
1685 l
|= itoa64_to_int (buf
[55]) << 18;
1687 digest
[41] = (l
>> 0) & 0xff;
1688 digest
[40] = (l
>> 8) & 0xff;
1689 digest
[39] = (l
>> 16) & 0xff;
1691 l
= itoa64_to_int (buf
[56]) << 0;
1692 l
|= itoa64_to_int (buf
[57]) << 6;
1693 l
|= itoa64_to_int (buf
[58]) << 12;
1694 l
|= itoa64_to_int (buf
[59]) << 18;
1696 digest
[44] = (l
>> 0) & 0xff;
1697 digest
[43] = (l
>> 8) & 0xff;
1698 digest
[42] = (l
>> 16) & 0xff;
1700 l
= itoa64_to_int (buf
[60]) << 0;
1701 l
|= itoa64_to_int (buf
[61]) << 6;
1702 l
|= itoa64_to_int (buf
[62]) << 12;
1703 l
|= itoa64_to_int (buf
[63]) << 18;
1705 digest
[47] = (l
>> 0) & 0xff;
1706 digest
[46] = (l
>> 8) & 0xff;
1707 digest
[45] = (l
>> 16) & 0xff;
1709 l
= itoa64_to_int (buf
[64]) << 0;
1710 l
|= itoa64_to_int (buf
[65]) << 6;
1711 l
|= itoa64_to_int (buf
[66]) << 12;
1712 l
|= itoa64_to_int (buf
[67]) << 18;
1714 digest
[50] = (l
>> 0) & 0xff;
1715 digest
[49] = (l
>> 8) & 0xff;
1716 digest
[48] = (l
>> 16) & 0xff;
1718 l
= itoa64_to_int (buf
[68]) << 0;
1719 l
|= itoa64_to_int (buf
[69]) << 6;
1720 l
|= itoa64_to_int (buf
[70]) << 12;
1721 l
|= itoa64_to_int (buf
[71]) << 18;
1723 digest
[53] = (l
>> 0) & 0xff;
1724 digest
[52] = (l
>> 8) & 0xff;
1725 digest
[51] = (l
>> 16) & 0xff;
1727 l
= itoa64_to_int (buf
[72]) << 0;
1728 l
|= itoa64_to_int (buf
[73]) << 6;
1729 l
|= itoa64_to_int (buf
[74]) << 12;
1730 l
|= itoa64_to_int (buf
[75]) << 18;
1732 digest
[56] = (l
>> 0) & 0xff;
1733 digest
[55] = (l
>> 8) & 0xff;
1734 digest
[54] = (l
>> 16) & 0xff;
1736 l
= itoa64_to_int (buf
[76]) << 0;
1737 l
|= itoa64_to_int (buf
[77]) << 6;
1738 l
|= itoa64_to_int (buf
[78]) << 12;
1739 l
|= itoa64_to_int (buf
[79]) << 18;
1741 digest
[59] = (l
>> 0) & 0xff;
1742 digest
[58] = (l
>> 8) & 0xff;
1743 digest
[57] = (l
>> 16) & 0xff;
1745 l
= itoa64_to_int (buf
[80]) << 0;
1746 l
|= itoa64_to_int (buf
[81]) << 6;
1747 l
|= itoa64_to_int (buf
[82]) << 12;
1748 l
|= itoa64_to_int (buf
[83]) << 18;
1750 digest
[62] = (l
>> 0) & 0xff;
1751 digest
[61] = (l
>> 8) & 0xff;
1752 digest
[60] = (l
>> 16) & 0xff;
1754 l
= itoa64_to_int (buf
[84]) << 0;
1755 l
|= itoa64_to_int (buf
[85]) << 6;
1757 digest
[63] = (l
>> 16) & 0xff;
1760 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1764 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1766 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1767 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1768 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1769 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1771 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1773 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1774 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1775 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1776 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1778 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1780 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1781 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1782 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1783 buf
[11] = int_to_itoa64 (l
& 0x3f);
1785 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1787 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1788 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1789 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1790 buf
[15] = int_to_itoa64 (l
& 0x3f);
1792 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1794 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1795 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1796 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1797 buf
[19] = int_to_itoa64 (l
& 0x3f);
1799 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1801 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1802 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1803 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1804 buf
[23] = int_to_itoa64 (l
& 0x3f);
1806 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1808 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1809 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1810 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1811 buf
[27] = int_to_itoa64 (l
& 0x3f);
1813 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1815 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1816 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1817 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1818 buf
[31] = int_to_itoa64 (l
& 0x3f);
1820 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1822 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1823 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1824 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1825 buf
[35] = int_to_itoa64 (l
& 0x3f);
1827 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1829 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1830 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1831 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1832 buf
[39] = int_to_itoa64 (l
& 0x3f);
1834 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1836 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1837 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1838 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1839 buf
[43] = int_to_itoa64 (l
& 0x3f);
1841 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1843 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1844 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1845 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1846 buf
[47] = int_to_itoa64 (l
& 0x3f);
1848 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1850 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1851 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1852 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1853 buf
[51] = int_to_itoa64 (l
& 0x3f);
1855 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1857 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1858 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1859 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1860 buf
[55] = int_to_itoa64 (l
& 0x3f);
1862 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1864 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1865 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1866 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1867 buf
[59] = int_to_itoa64 (l
& 0x3f);
1869 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1871 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1872 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1873 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1874 buf
[63] = int_to_itoa64 (l
& 0x3f);
1876 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1878 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1879 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1880 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1881 buf
[67] = int_to_itoa64 (l
& 0x3f);
1883 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1885 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1886 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1887 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1888 buf
[71] = int_to_itoa64 (l
& 0x3f);
1890 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1892 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1893 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1894 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1895 buf
[75] = int_to_itoa64 (l
& 0x3f);
1897 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1899 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1900 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1901 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1902 buf
[79] = int_to_itoa64 (l
& 0x3f);
1904 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1906 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1907 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1908 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1909 buf
[83] = int_to_itoa64 (l
& 0x3f);
1911 l
= 0 | 0 | (digest
[63] << 16);
1913 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1914 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1917 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1921 l
= itoa64_to_int (buf
[ 0]) << 0;
1922 l
|= itoa64_to_int (buf
[ 1]) << 6;
1923 l
|= itoa64_to_int (buf
[ 2]) << 12;
1924 l
|= itoa64_to_int (buf
[ 3]) << 18;
1926 digest
[ 0] = (l
>> 16) & 0xff;
1927 digest
[10] = (l
>> 8) & 0xff;
1928 digest
[20] = (l
>> 0) & 0xff;
1930 l
= itoa64_to_int (buf
[ 4]) << 0;
1931 l
|= itoa64_to_int (buf
[ 5]) << 6;
1932 l
|= itoa64_to_int (buf
[ 6]) << 12;
1933 l
|= itoa64_to_int (buf
[ 7]) << 18;
1935 digest
[21] = (l
>> 16) & 0xff;
1936 digest
[ 1] = (l
>> 8) & 0xff;
1937 digest
[11] = (l
>> 0) & 0xff;
1939 l
= itoa64_to_int (buf
[ 8]) << 0;
1940 l
|= itoa64_to_int (buf
[ 9]) << 6;
1941 l
|= itoa64_to_int (buf
[10]) << 12;
1942 l
|= itoa64_to_int (buf
[11]) << 18;
1944 digest
[12] = (l
>> 16) & 0xff;
1945 digest
[22] = (l
>> 8) & 0xff;
1946 digest
[ 2] = (l
>> 0) & 0xff;
1948 l
= itoa64_to_int (buf
[12]) << 0;
1949 l
|= itoa64_to_int (buf
[13]) << 6;
1950 l
|= itoa64_to_int (buf
[14]) << 12;
1951 l
|= itoa64_to_int (buf
[15]) << 18;
1953 digest
[ 3] = (l
>> 16) & 0xff;
1954 digest
[13] = (l
>> 8) & 0xff;
1955 digest
[23] = (l
>> 0) & 0xff;
1957 l
= itoa64_to_int (buf
[16]) << 0;
1958 l
|= itoa64_to_int (buf
[17]) << 6;
1959 l
|= itoa64_to_int (buf
[18]) << 12;
1960 l
|= itoa64_to_int (buf
[19]) << 18;
1962 digest
[24] = (l
>> 16) & 0xff;
1963 digest
[ 4] = (l
>> 8) & 0xff;
1964 digest
[14] = (l
>> 0) & 0xff;
1966 l
= itoa64_to_int (buf
[20]) << 0;
1967 l
|= itoa64_to_int (buf
[21]) << 6;
1968 l
|= itoa64_to_int (buf
[22]) << 12;
1969 l
|= itoa64_to_int (buf
[23]) << 18;
1971 digest
[15] = (l
>> 16) & 0xff;
1972 digest
[25] = (l
>> 8) & 0xff;
1973 digest
[ 5] = (l
>> 0) & 0xff;
1975 l
= itoa64_to_int (buf
[24]) << 0;
1976 l
|= itoa64_to_int (buf
[25]) << 6;
1977 l
|= itoa64_to_int (buf
[26]) << 12;
1978 l
|= itoa64_to_int (buf
[27]) << 18;
1980 digest
[ 6] = (l
>> 16) & 0xff;
1981 digest
[16] = (l
>> 8) & 0xff;
1982 digest
[26] = (l
>> 0) & 0xff;
1984 l
= itoa64_to_int (buf
[28]) << 0;
1985 l
|= itoa64_to_int (buf
[29]) << 6;
1986 l
|= itoa64_to_int (buf
[30]) << 12;
1987 l
|= itoa64_to_int (buf
[31]) << 18;
1989 digest
[27] = (l
>> 16) & 0xff;
1990 digest
[ 7] = (l
>> 8) & 0xff;
1991 digest
[17] = (l
>> 0) & 0xff;
1993 l
= itoa64_to_int (buf
[32]) << 0;
1994 l
|= itoa64_to_int (buf
[33]) << 6;
1995 l
|= itoa64_to_int (buf
[34]) << 12;
1996 l
|= itoa64_to_int (buf
[35]) << 18;
1998 digest
[18] = (l
>> 16) & 0xff;
1999 digest
[28] = (l
>> 8) & 0xff;
2000 digest
[ 8] = (l
>> 0) & 0xff;
2002 l
= itoa64_to_int (buf
[36]) << 0;
2003 l
|= itoa64_to_int (buf
[37]) << 6;
2004 l
|= itoa64_to_int (buf
[38]) << 12;
2005 l
|= itoa64_to_int (buf
[39]) << 18;
2007 digest
[ 9] = (l
>> 16) & 0xff;
2008 digest
[19] = (l
>> 8) & 0xff;
2009 digest
[29] = (l
>> 0) & 0xff;
2011 l
= itoa64_to_int (buf
[40]) << 0;
2012 l
|= itoa64_to_int (buf
[41]) << 6;
2013 l
|= itoa64_to_int (buf
[42]) << 12;
2015 digest
[31] = (l
>> 8) & 0xff;
2016 digest
[30] = (l
>> 0) & 0xff;
2019 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2023 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2025 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2026 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2027 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2028 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2030 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2032 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2033 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2034 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2035 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2037 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2039 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2041 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2042 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2044 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2046 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2048 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2049 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2051 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2053 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2055 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2056 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2058 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2060 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2062 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2063 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2065 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2067 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2069 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2070 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2072 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2074 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2076 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2077 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2079 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2081 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2083 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2084 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2086 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2088 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2090 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2091 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2093 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2095 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2096 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2097 buf
[42] = int_to_itoa64 (l
& 0x3f);
2100 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2104 l
= itoa64_to_int (buf
[ 0]) << 0;
2105 l
|= itoa64_to_int (buf
[ 1]) << 6;
2106 l
|= itoa64_to_int (buf
[ 2]) << 12;
2107 l
|= itoa64_to_int (buf
[ 3]) << 18;
2109 digest
[ 0] = (l
>> 0) & 0xff;
2110 digest
[ 1] = (l
>> 8) & 0xff;
2111 digest
[ 2] = (l
>> 16) & 0xff;
2113 l
= itoa64_to_int (buf
[ 4]) << 0;
2114 l
|= itoa64_to_int (buf
[ 5]) << 6;
2115 l
|= itoa64_to_int (buf
[ 6]) << 12;
2116 l
|= itoa64_to_int (buf
[ 7]) << 18;
2118 digest
[ 3] = (l
>> 0) & 0xff;
2119 digest
[ 4] = (l
>> 8) & 0xff;
2120 digest
[ 5] = (l
>> 16) & 0xff;
2122 l
= itoa64_to_int (buf
[ 8]) << 0;
2123 l
|= itoa64_to_int (buf
[ 9]) << 6;
2124 l
|= itoa64_to_int (buf
[10]) << 12;
2125 l
|= itoa64_to_int (buf
[11]) << 18;
2127 digest
[ 6] = (l
>> 0) & 0xff;
2128 digest
[ 7] = (l
>> 8) & 0xff;
2129 digest
[ 8] = (l
>> 16) & 0xff;
2131 l
= itoa64_to_int (buf
[12]) << 0;
2132 l
|= itoa64_to_int (buf
[13]) << 6;
2133 l
|= itoa64_to_int (buf
[14]) << 12;
2134 l
|= itoa64_to_int (buf
[15]) << 18;
2136 digest
[ 9] = (l
>> 0) & 0xff;
2137 digest
[10] = (l
>> 8) & 0xff;
2138 digest
[11] = (l
>> 16) & 0xff;
2140 l
= itoa64_to_int (buf
[16]) << 0;
2141 l
|= itoa64_to_int (buf
[17]) << 6;
2142 l
|= itoa64_to_int (buf
[18]) << 12;
2143 l
|= itoa64_to_int (buf
[19]) << 18;
2145 digest
[12] = (l
>> 0) & 0xff;
2146 digest
[13] = (l
>> 8) & 0xff;
2147 digest
[14] = (l
>> 16) & 0xff;
2149 l
= itoa64_to_int (buf
[20]) << 0;
2150 l
|= itoa64_to_int (buf
[21]) << 6;
2151 l
|= itoa64_to_int (buf
[22]) << 12;
2152 l
|= itoa64_to_int (buf
[23]) << 18;
2154 digest
[15] = (l
>> 0) & 0xff;
2155 digest
[16] = (l
>> 8) & 0xff;
2156 digest
[17] = (l
>> 16) & 0xff;
2158 l
= itoa64_to_int (buf
[24]) << 0;
2159 l
|= itoa64_to_int (buf
[25]) << 6;
2160 l
|= itoa64_to_int (buf
[26]) << 12;
2161 l
|= itoa64_to_int (buf
[27]) << 18;
2163 digest
[18] = (l
>> 0) & 0xff;
2164 digest
[19] = (l
>> 8) & 0xff;
2165 digest
[20] = (l
>> 16) & 0xff;
2167 l
= itoa64_to_int (buf
[28]) << 0;
2168 l
|= itoa64_to_int (buf
[29]) << 6;
2169 l
|= itoa64_to_int (buf
[30]) << 12;
2170 l
|= itoa64_to_int (buf
[31]) << 18;
2172 digest
[21] = (l
>> 0) & 0xff;
2173 digest
[22] = (l
>> 8) & 0xff;
2174 digest
[23] = (l
>> 16) & 0xff;
2176 l
= itoa64_to_int (buf
[32]) << 0;
2177 l
|= itoa64_to_int (buf
[33]) << 6;
2178 l
|= itoa64_to_int (buf
[34]) << 12;
2179 l
|= itoa64_to_int (buf
[35]) << 18;
2181 digest
[24] = (l
>> 0) & 0xff;
2182 digest
[25] = (l
>> 8) & 0xff;
2183 digest
[26] = (l
>> 16) & 0xff;
2185 l
= itoa64_to_int (buf
[36]) << 0;
2186 l
|= itoa64_to_int (buf
[37]) << 6;
2187 l
|= itoa64_to_int (buf
[38]) << 12;
2188 l
|= itoa64_to_int (buf
[39]) << 18;
2190 digest
[27] = (l
>> 0) & 0xff;
2191 digest
[28] = (l
>> 8) & 0xff;
2192 digest
[29] = (l
>> 16) & 0xff;
2194 l
= itoa64_to_int (buf
[40]) << 0;
2195 l
|= itoa64_to_int (buf
[41]) << 6;
2196 l
|= itoa64_to_int (buf
[42]) << 12;
2197 l
|= itoa64_to_int (buf
[43]) << 18;
2199 digest
[30] = (l
>> 0) & 0xff;
2200 digest
[31] = (l
>> 8) & 0xff;
2201 digest
[32] = (l
>> 16) & 0xff;
2236 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2240 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2242 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2243 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2244 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2245 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2247 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2249 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2250 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2251 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2252 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2254 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2256 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2257 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2258 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2259 buf
[11] = int_to_itoa64 (l
& 0x3f);
2261 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2263 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2264 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2265 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2266 buf
[15] = int_to_itoa64 (l
& 0x3f);
2268 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2270 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2271 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2272 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2273 buf
[19] = int_to_itoa64 (l
& 0x3f);
2275 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2277 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2278 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2279 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2280 buf
[23] = int_to_itoa64 (l
& 0x3f);
2282 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2284 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2285 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2286 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2287 buf
[27] = int_to_itoa64 (l
& 0x3f);
2289 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2291 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2292 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2293 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2294 buf
[31] = int_to_itoa64 (l
& 0x3f);
2296 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2298 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2299 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2300 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2301 buf
[35] = int_to_itoa64 (l
& 0x3f);
2303 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2305 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2306 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2307 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2308 buf
[39] = int_to_itoa64 (l
& 0x3f);
2310 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2312 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2313 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2314 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2315 //buf[43] = int_to_itoa64 (l & 0x3f);
2323 static struct termio savemodes
;
2324 static int havemodes
= 0;
2328 struct termio modmodes
;
2330 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2334 modmodes
= savemodes
;
2335 modmodes
.c_lflag
&= ~ICANON
;
2336 modmodes
.c_cc
[VMIN
] = 1;
2337 modmodes
.c_cc
[VTIME
] = 0;
2339 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2348 FD_SET (fileno (stdin
), &rfds
);
2355 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2357 if (retval
== 0) return 0;
2358 if (retval
== -1) return -1;
2365 if (!havemodes
) return 0;
2367 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2372 static struct termios savemodes
;
2373 static int havemodes
= 0;
2377 struct termios modmodes
;
2379 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2383 modmodes
= savemodes
;
2384 modmodes
.c_lflag
&= ~ICANON
;
2385 modmodes
.c_cc
[VMIN
] = 1;
2386 modmodes
.c_cc
[VTIME
] = 0;
2388 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2397 FD_SET (fileno (stdin
), &rfds
);
2404 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2406 if (retval
== 0) return 0;
2407 if (retval
== -1) return -1;
2414 if (!havemodes
) return 0;
2416 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2421 static DWORD saveMode
= 0;
2425 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2427 GetConsoleMode (stdinHandle
, &saveMode
);
2428 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2435 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2437 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2439 if (rc
== WAIT_TIMEOUT
) return 0;
2440 if (rc
== WAIT_ABANDONED
) return -1;
2441 if (rc
== WAIT_FAILED
) return -1;
2443 // The whole ReadConsoleInput () part is a workaround.
2444 // For some unknown reason, maybe a mingw bug, a random signal
2445 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2446 // Then it wants to read with getche () a keyboard input
2447 // which has never been made.
2449 INPUT_RECORD buf
[100];
2453 memset (buf
, 0, sizeof (buf
));
2455 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2457 FlushConsoleInputBuffer (stdinHandle
);
2459 for (uint i
= 0; i
< num
; i
++)
2461 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2463 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2465 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2467 return KeyEvent
.uChar
.AsciiChar
;
2475 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2477 SetConsoleMode (stdinHandle
, saveMode
);
2487 #define MSG_ENOMEM "Insufficient memory available"
2489 void *mycalloc (size_t nmemb
, size_t size
)
2491 void *p
= calloc (nmemb
, size
);
2495 log_error ("ERROR: %s", MSG_ENOMEM
);
2503 void *mymalloc (size_t size
)
2505 void *p
= malloc (size
);
2509 log_error ("ERROR: %s", MSG_ENOMEM
);
2514 memset (p
, 0, size
);
2519 void myfree (void *ptr
)
2521 if (ptr
== NULL
) return;
2526 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2528 void *p
= realloc (ptr
, oldsz
+ add
);
2532 log_error ("ERROR: %s", MSG_ENOMEM
);
2537 memset ((char *) p
+ oldsz
, 0, add
);
2542 char *mystrdup (const char *s
)
2544 const size_t len
= strlen (s
);
2546 char *b
= (char *) mymalloc (len
+ 1);
2553 FILE *logfile_open (char *logfile
)
2555 FILE *fp
= fopen (logfile
, "ab");
2565 void logfile_close (FILE *fp
)
2567 if (fp
== stdout
) return;
2572 void logfile_append (const char *fmt
, ...)
2574 if (data
.logfile_disable
== 1) return;
2576 FILE *fp
= logfile_open (data
.logfile
);
2582 vfprintf (fp
, fmt
, ap
);
2593 int logfile_generate_id ()
2595 const int n
= rand ();
2604 char *logfile_generate_topid ()
2606 const int id
= logfile_generate_id ();
2608 char *topid
= (char *) mymalloc (1 + 16 + 1);
2610 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2615 char *logfile_generate_subid ()
2617 const int id
= logfile_generate_id ();
2619 char *subid
= (char *) mymalloc (1 + 16 + 1);
2621 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2631 void lock_file (FILE *fp
)
2635 memset (&lock
, 0, sizeof (struct flock
));
2637 lock
.l_type
= F_WRLCK
;
2638 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2642 log_error ("ERROR: failed acquiring write lock: %s", strerror (errno
));
2649 void unlock_file (FILE *fp
)
2653 memset (&lock
, 0, sizeof (struct flock
));
2655 lock
.l_type
= F_UNLCK
;
2656 fcntl(fileno(fp
), F_SETLK
, &lock
);
2663 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2665 FlushFileBuffers (h
);
2674 #if defined(_WIN) && defined(HAVE_NVAPI)
2675 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2679 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nv
, nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2683 log_info ("WARN: No NvAPI adapters found");
2690 #endif // _WIN && HAVE_NVAPI
2692 #if defined(LINUX) && defined(HAVE_NVML)
2693 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2697 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2699 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nv
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2701 // can be used to determine if the device by index matches the cuda device by index
2702 // char name[100]; memset (name, 0, sizeof (name));
2703 // hm_NVML_nvmlDeviceGetName (data.hm_nv, nvGPUHandle[i], name, sizeof (name) - 1);
2710 log_info ("WARN: No NVML adapters found");
2717 #endif // LINUX && HAVE_NVML
2720 int get_adapters_num_amd (void *adl
, int *iNumberAdapters
)
2722 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2724 if (iNumberAdapters
== 0)
2726 log_info ("WARN: No ADL adapters found.");
2735 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2737 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2738 ADLODParameters lpOdParameters;
2740 lpOdParameters.iSize = sizeof (ADLODParameters);
2741 size_t plevels_size = 0;
2743 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2745 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2746 __func__, iAdapterIndex,
2747 lpOdParameters.iNumberOfPerformanceLevels,
2748 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2749 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2751 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2753 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2755 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2757 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2759 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2760 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2761 __func__, iAdapterIndex, j,
2762 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2764 myfree (lpOdPerformanceLevels);
2770 LPAdapterInfo
hm_get_adapter_info_amd (void *adl
, int iNumberAdapters
)
2772 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2774 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2776 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2778 return lpAdapterInfo
;
2783 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2786 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2790 for (uint i = 0; i < num_adl_adapters; i++)
2792 int opencl_bus_num = hm_device[i].busid;
2793 int opencl_dev_num = hm_device[i].devid;
2795 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2803 if (idx >= DEVICES_MAX) return -1;
2808 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2810 for (uint i = 0; i < opencl_num_devices; i++)
2812 cl_device_topology_amd device_topology;
2814 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2816 hm_device[i].busid = device_topology.pcie.bus;
2817 hm_device[i].devid = device_topology.pcie.device;
2822 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2824 // basically bubble sort
2826 for (int i
= 0; i
< num_adl_adapters
; i
++)
2828 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2830 // get info of adapter [x]
2832 u32 adapter_index_x
= valid_adl_device_list
[j
];
2833 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2835 u32 bus_num_x
= info_x
.iBusNumber
;
2836 u32 dev_num_x
= info_x
.iDeviceNumber
;
2838 // get info of adapter [y]
2840 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2841 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2843 u32 bus_num_y
= info_y
.iBusNumber
;
2844 u32 dev_num_y
= info_y
.iDeviceNumber
;
2848 if (bus_num_y
< bus_num_x
)
2852 else if (bus_num_y
== bus_num_x
)
2854 if (dev_num_y
< dev_num_x
)
2862 u32 temp
= valid_adl_device_list
[j
+ 1];
2864 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2865 valid_adl_device_list
[j
+ 0] = temp
;
2871 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2873 *num_adl_adapters
= 0;
2875 u32
*adl_adapters
= NULL
;
2877 int *bus_numbers
= NULL
;
2878 int *device_numbers
= NULL
;
2880 for (int i
= 0; i
< iNumberAdapters
; i
++)
2882 AdapterInfo info
= lpAdapterInfo
[i
];
2884 if (strlen (info
.strUDID
) < 1) continue;
2887 if (info
.iVendorID
!= 1002) continue;
2889 if (info
.iVendorID
!= 0x1002) continue;
2892 if (info
.iBusNumber
< 0) continue;
2893 if (info
.iDeviceNumber
< 0) continue;
2897 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2899 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2906 if (found
) continue;
2908 // add it to the list
2910 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2912 adl_adapters
[*num_adl_adapters
] = i
;
2914 // rest is just bookkeeping
2916 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2917 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2919 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2920 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2922 (*num_adl_adapters
)++;
2925 myfree (bus_numbers
);
2926 myfree (device_numbers
);
2928 // sort the list by increasing bus id, device id number
2930 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2932 return adl_adapters
;
2935 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2937 // loop through all valid devices
2939 for (int i
= 0; i
< num_adl_adapters
; i
++)
2941 u32 adapter_index
= valid_adl_device_list
[i
];
2945 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2947 // unfortunately this doesn't work since bus id and dev id are not unique
2948 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2949 // if (opencl_device_index == -1) continue;
2951 int opencl_device_index
= i
;
2953 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2955 // get fanspeed info
2957 if (hm_device
[opencl_device_index
].od_version
== 5)
2959 ADLFanSpeedInfo FanSpeedInfo
;
2961 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2963 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2965 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2967 // check read and write capability in fanspeedinfo
2969 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2970 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2972 hm_device
[opencl_device_index
].fan_supported
= 1;
2976 hm_device
[opencl_device_index
].fan_supported
= 0;
2979 else // od_version == 6
2981 ADLOD6FanSpeedInfo faninfo
;
2983 memset (&faninfo
, 0, sizeof (faninfo
));
2985 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2987 // check read capability in fanspeedinfo
2989 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2991 hm_device
[opencl_device_index
].fan_supported
= 1;
2995 hm_device
[opencl_device_index
].fan_supported
= 0;
3003 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3005 for (int i
= 0; i
< num_adl_adapters
; i
++)
3007 u32 adapter_index
= valid_adl_device_list
[i
];
3011 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3013 // get overdrive version
3015 int od_supported
= 0;
3019 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3021 // store the overdrive version in hm_device
3023 // unfortunately this doesn't work since bus id and dev id are not unique
3024 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3025 // if (opencl_device_index == -1) continue;
3027 int opencl_device_index
= i
;
3029 hm_device
[opencl_device_index
].od_version
= od_version
;
3035 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3037 for (int i
= 0; i
< num_adl_adapters
; i
++)
3039 u32 adapter_index
= valid_adl_device_list
[i
];
3043 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3045 // store the iAdapterIndex in hm_device
3047 // unfortunately this doesn't work since bus id and dev id are not unique
3048 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3049 // if (opencl_device_index == -1) continue;
3051 int opencl_device_index
= i
;
3053 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3056 return num_adl_adapters
;
3060 int hm_get_threshold_slowdown_with_device_id (const uint device_id
)
3062 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3065 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3069 if (data
.hm_device
[device_id
].od_version
== 5)
3073 else if (data
.hm_device
[device_id
].od_version
== 6)
3075 int CurrentValue
= 0;
3076 int DefaultValue
= 0;
3078 if (hm_ADL_Overdrive6_TargetTemperatureData_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &CurrentValue
, &DefaultValue
) != ADL_OK
) return -1;
3080 // the return value has never been tested since hm_ADL_Overdrive6_TargetTemperatureData_Get() never worked on any system. expect problems.
3082 return DefaultValue
;
3088 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3089 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3091 #if defined(LINUX) && defined(HAVE_NVML)
3094 hm_NVML_nvmlDeviceGetTemperatureThreshold (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_THRESHOLD_SLOWDOWN
, (unsigned int *) &target
);
3099 #if defined(WIN) && defined(HAVE_NVAPI)
3101 #endif // WIN && HAVE_NVAPI
3103 #endif // HAVE_NVML || HAVE_NVAPI
3108 int hm_get_temperature_with_device_id (const uint device_id
)
3110 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3113 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3117 if (data
.hm_device
[device_id
].od_version
== 5)
3119 ADLTemperature Temperature
;
3121 Temperature
.iSize
= sizeof (ADLTemperature
);
3123 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3125 return Temperature
.iTemperature
/ 1000;
3127 else if (data
.hm_device
[device_id
].od_version
== 6)
3129 int Temperature
= 0;
3131 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3133 return Temperature
/ 1000;
3139 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3140 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3142 #if defined(LINUX) && defined(HAVE_NVML)
3143 int temperature
= 0;
3145 hm_NVML_nvmlDeviceGetTemperature (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
);
3150 #if defined(WIN) && defined(HAVE_NVAPI)
3151 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3153 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3154 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3155 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3156 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3158 if (hm_NvAPI_GPU_GetThermalSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3160 return pThermalSettings
.sensor
[0].currentTemp
;
3161 #endif // WIN && HAVE_NVAPI
3163 #endif // HAVE_NVML || HAVE_NVAPI
3168 int hm_get_fanspeed_with_device_id (const uint device_id
)
3170 // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
3171 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3173 if (data
.hm_device
[device_id
].fan_supported
== 1)
3176 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3180 if (data
.hm_device
[device_id
].od_version
== 5)
3182 ADLFanSpeedValue lpFanSpeedValue
;
3184 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3186 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3187 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3188 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3190 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3192 return lpFanSpeedValue
.iFanSpeed
;
3194 else // od_version == 6
3196 ADLOD6FanSpeedInfo faninfo
;
3198 memset (&faninfo
, 0, sizeof (faninfo
));
3200 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3202 return faninfo
.iFanSpeedPercent
;
3208 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3209 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3211 #if defined(LINUX) && defined(HAVE_NVML)
3214 hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (uint
*) &speed
);
3219 #if defined(WIN) && defined(HAVE_NVAPI)
3220 NV_GPU_COOLER_SETTINGS pCoolerSettings
;
3222 pCoolerSettings
.Version
= GPU_COOLER_SETTINGS_VER
| sizeof (NV_GPU_COOLER_SETTINGS
);
3224 hm_NvAPI_GPU_GetCoolerSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pCoolerSettings
);
3226 return pCoolerSettings
.Cooler
[0].CurrentLevel
;
3229 #endif // HAVE_NVML || HAVE_NVAPI
3235 int hm_get_maxbuslanes_with_device_id (const uint device_id
)
3237 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3240 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3244 ADLPMActivity PMActivity
;
3246 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3248 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3250 return PMActivity
.iMaximumBusLanes
;
3255 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3256 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3258 #if defined(LINUX) && defined(HAVE_NVML)
3262 #if defined(WIN) && defined(HAVE_NVAPI)
3266 #endif // HAVE_NVML || HAVE_NVAPI
3271 int hm_get_currentbuslanes_with_device_id (const uint device_id
)
3273 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3276 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3280 ADLPMActivity PMActivity
;
3282 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3284 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3286 return PMActivity
.iCurrentBusLanes
;
3291 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3292 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3294 #if defined(LINUX) && defined(HAVE_NVML)
3298 #if defined(WIN) && defined(HAVE_NVAPI)
3302 #endif // HAVE_NVML || HAVE_NVAPI
3307 int hm_get_utilization_with_device_id (const uint device_id
)
3309 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3312 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3316 ADLPMActivity PMActivity
;
3318 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3320 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3322 return PMActivity
.iActivityPercent
;
3327 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3328 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3330 #if defined(LINUX) && defined(HAVE_NVML)
3331 nvmlUtilization_t utilization
;
3333 hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3335 return utilization
.gpu
;
3338 #if defined(WIN) && defined(HAVE_NVAPI)
3339 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3341 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3343 if (hm_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3345 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3348 #endif // HAVE_NVML || HAVE_NVAPI
3353 int hm_get_memoryspeed_with_device_id (const uint device_id
)
3355 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3358 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3362 ADLPMActivity PMActivity
;
3364 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3366 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3368 return PMActivity
.iMemoryClock
/ 100;
3373 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3374 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3376 #if defined(LINUX) && defined(HAVE_NVML)
3379 hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_CLOCK_MEM
, &clock
);
3384 #if defined(WIN) && defined(HAVE_NVAPI)
3385 NV_GPU_CLOCK_FREQUENCIES pClkFreqs
= { 0 };
3387 pClkFreqs
.version
= NV_GPU_CLOCK_FREQUENCIES_VER
;
3388 pClkFreqs
.ClockType
= NV_GPU_CLOCK_FREQUENCIES_CURRENT_FREQ
;
3390 if (hm_NvAPI_GPU_GetAllClockFrequencies (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pClkFreqs
) != NVAPI_OK
) return -1;
3392 return pClkFreqs
.domain
[NVAPI_GPU_PUBLIC_CLOCK_MEMORY
].frequency
/ 1000;
3395 #endif // HAVE_NVML || HAVE_NVAPI
3400 int hm_get_corespeed_with_device_id (const uint device_id
)
3402 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3405 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3409 ADLPMActivity PMActivity
;
3411 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3413 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3415 return PMActivity
.iEngineClock
/ 100;
3420 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3421 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3423 #if defined(LINUX) && defined(HAVE_NVML)
3426 hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_CLOCK_SM
, &clock
);
3431 #if defined(WIN) && defined(HAVE_NVAPI)
3432 NV_GPU_CLOCK_FREQUENCIES pClkFreqs
= { 0 };
3434 pClkFreqs
.version
= NV_GPU_CLOCK_FREQUENCIES_VER
;
3435 pClkFreqs
.ClockType
= NV_GPU_CLOCK_FREQUENCIES_CURRENT_FREQ
;
3437 if (hm_NvAPI_GPU_GetAllClockFrequencies (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pClkFreqs
) != NVAPI_OK
) return -1;
3439 return pClkFreqs
.domain
[NVAPI_GPU_PUBLIC_CLOCK_GRAPHICS
].frequency
/ 1000;
3442 #endif // HAVE_NVML || HAVE_NVAPI
3448 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3450 if (data
.hm_device
[device_id
].fan_supported
== 1)
3454 if (data
.hm_device
[device_id
].od_version
== 5)
3456 ADLFanSpeedValue lpFanSpeedValue
;
3458 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3460 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3461 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3462 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3463 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3465 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3469 else // od_version == 6
3471 ADLOD6FanSpeedValue fan_speed_value
;
3473 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3475 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3476 fan_speed_value
.iFanSpeed
= fanspeed
;
3478 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3489 // helper function for status display
3491 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3493 #define VALUE_NOT_AVAILABLE "N/A"
3497 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3501 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3504 #endif // HAVE_HWMON
3510 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3512 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3514 if (css_cnt
> SP_PW_MAX
)
3516 log_error ("ERROR: mask length is too long");
3521 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3523 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3525 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3526 uint cs_len
= css
[css_pos
].cs_len
;
3528 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3530 uint c
= cs_buf
[cs_pos
] & 0xff;
3537 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3539 cs_t
*cs
= &css
[css_cnt
];
3541 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3543 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3547 for (i
= 0; i
< cs
->cs_len
; i
++)
3549 const uint u
= cs
->cs_buf
[i
];
3554 for (i
= 0; i
< in_len
; i
++)
3556 uint u
= in_buf
[i
] & 0xff;
3558 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3560 if (css_uniq
[u
] == 1) continue;
3564 cs
->cs_buf
[cs
->cs_len
] = u
;
3572 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3576 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3578 uint p0
= in_buf
[in_pos
] & 0xff;
3580 if (interpret
== 1 && p0
== '?')
3584 if (in_pos
== in_len
) break;
3586 uint p1
= in_buf
[in_pos
] & 0xff;
3590 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3592 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3594 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3596 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3598 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3600 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3602 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3603 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3605 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3606 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3608 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3609 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3611 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3612 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3614 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3616 default: log_error ("Syntax error: %s", in_buf
);
3622 if (data
.hex_charset
)
3626 if (in_pos
== in_len
)
3628 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3633 uint p1
= in_buf
[in_pos
] & 0xff;
3635 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3637 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3644 chr
= hex_convert (p1
) << 0;
3645 chr
|= hex_convert (p0
) << 4;
3647 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3653 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3659 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3663 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3665 sum
*= css
[css_pos
].cs_len
;
3671 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3673 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3678 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3680 char p0
= mask_buf
[mask_pos
];
3686 if (mask_pos
== mask_len
) break;
3688 char p1
= mask_buf
[mask_pos
];
3694 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3696 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3698 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3700 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3702 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3704 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3706 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3707 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3709 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3710 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3712 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3713 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3715 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3716 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3718 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3720 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3726 if (data
.hex_charset
)
3730 // if there is no 2nd hex character, show an error:
3732 if (mask_pos
== mask_len
)
3734 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3739 char p1
= mask_buf
[mask_pos
];
3741 // if they are not valid hex character, show an error:
3743 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3745 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3752 chr
|= hex_convert (p1
) << 0;
3753 chr
|= hex_convert (p0
) << 4;
3755 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3761 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3768 log_error ("ERROR: invalid mask length (0)");
3778 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3780 for (int i
= 0; i
< css_cnt
; i
++)
3782 uint len
= css
[i
].cs_len
;
3783 u64 next
= val
/ len
;
3784 uint pos
= val
% len
;
3785 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3790 void mp_cut_at (char *mask
, uint max
)
3794 uint mask_len
= strlen (mask
);
3796 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3798 if (mask
[i
] == '?') i
++;
3804 void mp_setup_sys (cs_t
*mp_sys
)
3808 uint donec
[CHARSIZ
] = { 0 };
3810 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3811 mp_sys
[0].cs_buf
[pos
++] = chr
;
3812 mp_sys
[0].cs_len
= pos
; }
3814 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3815 mp_sys
[1].cs_buf
[pos
++] = chr
;
3816 mp_sys
[1].cs_len
= pos
; }
3818 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3819 mp_sys
[2].cs_buf
[pos
++] = chr
;
3820 mp_sys
[2].cs_len
= pos
; }
3822 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3823 mp_sys
[3].cs_buf
[pos
++] = chr
;
3824 mp_sys
[3].cs_len
= pos
; }
3826 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3827 mp_sys
[4].cs_len
= pos
; }
3829 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3830 mp_sys
[5].cs_len
= pos
; }
3833 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3835 FILE *fp
= fopen (buf
, "rb");
3837 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3839 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3843 char mp_file
[1024] = { 0 };
3845 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3849 len
= in_superchop (mp_file
);
3853 log_info ("WARNING: charset file corrupted");
3855 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3859 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3864 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3866 mp_usr
[index
].cs_len
= 0;
3868 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3871 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3873 char *new_mask_buf
= (char *) mymalloc (256);
3879 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3881 if (css_pos
== len
) break;
3883 char p0
= mask_buf
[mask_pos
];
3885 new_mask_buf
[mask_pos
] = p0
;
3891 if (mask_pos
== mask_len
) break;
3893 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3897 if (data
.hex_charset
)
3901 if (mask_pos
== mask_len
)
3903 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3908 char p1
= mask_buf
[mask_pos
];
3910 // if they are not valid hex character, show an error:
3912 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3914 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3919 new_mask_buf
[mask_pos
] = p1
;
3924 if (css_pos
== len
) return (new_mask_buf
);
3926 myfree (new_mask_buf
);
3935 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3941 for (i
= start
; i
< stop
; i
++)
3943 sum
*= root_css_buf
[i
].cs_len
;
3949 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3953 cs_t
*cs
= &root_css_buf
[start
];
3957 for (i
= start
; i
< stop
; i
++)
3959 const u64 m
= v
% cs
->cs_len
;
3960 const u64 d
= v
/ cs
->cs_len
;
3964 const uint k
= cs
->cs_buf
[m
];
3966 pw_buf
[i
- start
] = (char) k
;
3968 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3972 int sp_comp_val (const void *p1
, const void *p2
)
3974 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3975 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3977 return b2
->val
- b1
->val
;
3980 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
)
3987 * Initialize hcstats
3990 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3992 u64
*root_stats_ptr
= root_stats_buf
;
3994 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3996 for (i
= 0; i
< SP_PW_MAX
; i
++)
3998 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
4000 root_stats_ptr
+= CHARSIZ
;
4003 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
4005 u64
*markov_stats_ptr
= markov_stats_buf
;
4007 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4009 for (i
= 0; i
< SP_PW_MAX
; i
++)
4011 for (j
= 0; j
< CHARSIZ
; j
++)
4013 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
4015 markov_stats_ptr
+= CHARSIZ
;
4025 char hcstat_tmp
[256] = { 0 };
4027 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
4029 hcstat
= hcstat_tmp
;
4032 FILE *fd
= fopen (hcstat
, "rb");
4036 log_error ("%s: %s", hcstat
, strerror (errno
));
4041 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
4043 log_error ("%s: Could not load data", hcstat
);
4050 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
4052 log_error ("%s: Could not load data", hcstat
);
4062 * Markov modifier of hcstat_table on user request
4067 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
4068 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
4073 /* Add all stats to first position */
4075 for (i
= 1; i
< SP_PW_MAX
; i
++)
4077 u64
*out
= root_stats_buf_by_pos
[0];
4078 u64
*in
= root_stats_buf_by_pos
[i
];
4080 for (j
= 0; j
< CHARSIZ
; j
++)
4086 for (i
= 1; i
< SP_PW_MAX
; i
++)
4088 u64
*out
= markov_stats_buf_by_key
[0][0];
4089 u64
*in
= markov_stats_buf_by_key
[i
][0];
4091 for (j
= 0; j
< CHARSIZ
; j
++)
4093 for (k
= 0; k
< CHARSIZ
; k
++)
4100 /* copy them to all pw_positions */
4102 for (i
= 1; i
< SP_PW_MAX
; i
++)
4104 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
4107 for (i
= 1; i
< SP_PW_MAX
; i
++)
4109 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
4117 hcstat_table_t
*root_table_ptr
= root_table_buf
;
4119 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
4121 for (i
= 0; i
< SP_PW_MAX
; i
++)
4123 root_table_buf_by_pos
[i
] = root_table_ptr
;
4125 root_table_ptr
+= CHARSIZ
;
4128 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
4130 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4132 for (i
= 0; i
< SP_PW_MAX
; i
++)
4134 for (j
= 0; j
< CHARSIZ
; j
++)
4136 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
4138 markov_table_ptr
+= CHARSIZ
;
4143 * Convert hcstat to tables
4146 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
4148 uint key
= i
% CHARSIZ
;
4150 root_table_buf
[i
].key
= key
;
4151 root_table_buf
[i
].val
= root_stats_buf
[i
];
4154 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
4156 uint key
= i
% CHARSIZ
;
4158 markov_table_buf
[i
].key
= key
;
4159 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
4162 myfree (root_stats_buf
);
4163 myfree (markov_stats_buf
);
4169 for (i
= 0; i
< SP_PW_MAX
; i
++)
4171 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4174 for (i
= 0; i
< SP_PW_MAX
; i
++)
4176 for (j
= 0; j
< CHARSIZ
; j
++)
4178 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4183 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
])
4186 * Convert tables to css
4189 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
4191 uint pw_pos
= i
/ CHARSIZ
;
4193 cs_t
*cs
= &root_css_buf
[pw_pos
];
4195 if (cs
->cs_len
== threshold
) continue;
4197 uint key
= root_table_buf
[i
].key
;
4199 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
4201 cs
->cs_buf
[cs
->cs_len
] = key
;
4207 * Convert table to css
4210 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4212 uint c
= i
/ CHARSIZ
;
4214 cs_t
*cs
= &markov_css_buf
[c
];
4216 if (cs
->cs_len
== threshold
) continue;
4218 uint pw_pos
= c
/ CHARSIZ
;
4220 uint key
= markov_table_buf
[i
].key
;
4222 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4224 cs
->cs_buf
[cs
->cs_len
] = key
;
4230 for (uint i = 0; i < 8; i++)
4232 for (uint j = 0x20; j < 0x80; j++)
4234 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4236 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4238 for (uint k = 0; k < 10; k++)
4240 printf (" %u\n", ptr->cs_buf[k]);
4247 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4249 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4251 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4261 for (uint j
= 1; j
< CHARSIZ
; j
++)
4271 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4273 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4275 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4277 out
+= CHARSIZ
* CHARSIZ
;
4278 in
+= CHARSIZ
* CHARSIZ
;
4280 for (uint j
= 0; j
< CHARSIZ
; j
++)
4287 for (uint k
= 1; k
< CHARSIZ
; k
++)
4299 * mixed shared functions
4302 void dump_hex (const u8
*s
, const int sz
)
4304 for (int i
= 0; i
< sz
; i
++)
4306 log_info_nn ("%02x ", s
[i
]);
4312 void usage_mini_print (const char *progname
)
4314 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4317 void usage_big_print (const char *progname
)
4319 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4322 char *get_exec_path ()
4324 int exec_path_len
= 1024;
4326 char *exec_path
= (char *) mymalloc (exec_path_len
);
4330 char tmp
[32] = { 0 };
4332 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4334 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4338 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4342 uint size
= exec_path_len
;
4344 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4346 log_error("! executable path buffer too small\n");
4351 const int len
= strlen (exec_path
);
4354 #error Your Operating System is not supported or detected
4362 char *get_install_dir (const char *progname
)
4364 char *install_dir
= mystrdup (progname
);
4365 char *last_slash
= NULL
;
4367 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4371 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4377 install_dir
[0] = '.';
4381 return (install_dir
);
4384 char *get_profile_dir (const char *homedir
)
4386 #define DOT_HASHCAT ".hashcat"
4388 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4390 char *profile_dir
= (char *) mymalloc (len
+ 1);
4392 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4397 char *get_session_dir (const char *profile_dir
)
4399 #define SESSIONS_FOLDER "sessions"
4401 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4403 char *session_dir
= (char *) mymalloc (len
+ 1);
4405 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4410 uint
count_lines (FILE *fd
)
4414 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4420 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4422 if (nread
< 1) continue;
4426 for (i
= 0; i
< nread
; i
++)
4428 if (prev
== '\n') cnt
++;
4439 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4443 FILE *fd
= fopen (filename
, "rb");
4447 log_error ("%s: %s", filename
, strerror (errno
));
4452 #define MAX_KEY_SIZE (1024 * 1024)
4454 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4456 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4462 for (int fpos
= 0; fpos
< nread
; fpos
++)
4464 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4466 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4467 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4468 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4469 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4471 if (kpos
>= 64) kpos
= 0;
4478 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4482 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4483 if (CPU_ISSET(core
, cpu_set
)) break;
4485 thread_affinity_policy_data_t policy
= { core
};
4487 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4489 if (data
.quiet
== 0)
4491 if (rc
!= KERN_SUCCESS
)
4493 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4501 void set_cpu_affinity (char *cpu_affinity
)
4504 DWORD_PTR aff_mask
= 0;
4512 char *devices
= strdup (cpu_affinity
);
4514 char *next
= strtok (devices
, ",");
4518 uint cpu_id
= atoi (next
);
4533 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4539 aff_mask
|= 1 << (cpu_id
- 1);
4541 CPU_SET ((cpu_id
- 1), &cpuset
);
4544 } while ((next
= strtok (NULL
, ",")) != NULL
);
4550 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4551 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4553 pthread_t thread
= pthread_self ();
4554 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4558 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4560 char *element
, *end
;
4562 end
= (char *) base
+ nmemb
* size
;
4564 for (element
= (char *) base
; element
< end
; element
+= size
)
4565 if (!compar (element
, key
))
4571 int sort_by_u32 (const void *v1
, const void *v2
)
4573 const u32
*s1
= (const u32
*) v1
;
4574 const u32
*s2
= (const u32
*) v2
;
4579 int sort_by_salt (const void *v1
, const void *v2
)
4581 const salt_t
*s1
= (const salt_t
*) v1
;
4582 const salt_t
*s2
= (const salt_t
*) v2
;
4584 const int res1
= s1
->salt_len
- s2
->salt_len
;
4586 if (res1
!= 0) return (res1
);
4588 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4590 if (res2
!= 0) return (res2
);
4598 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4599 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4606 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4607 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4613 int sort_by_salt_buf (const void *v1
, const void *v2
)
4615 const pot_t
*p1
= (const pot_t
*) v1
;
4616 const pot_t
*p2
= (const pot_t
*) v2
;
4618 const hash_t
*h1
= &p1
->hash
;
4619 const hash_t
*h2
= &p2
->hash
;
4621 const salt_t
*s1
= h1
->salt
;
4622 const salt_t
*s2
= h2
->salt
;
4628 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4629 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4635 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4637 const hash_t
*h1
= (const hash_t
*) v1
;
4638 const hash_t
*h2
= (const hash_t
*) v2
;
4640 const salt_t
*s1
= h1
->salt
;
4641 const salt_t
*s2
= h2
->salt
;
4643 // testphase: this should work
4648 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4649 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4652 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4653 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4654 if (s1->salt_len > s2->salt_len) return ( 1);
4655 if (s1->salt_len < s2->salt_len) return (-1);
4657 uint n = s1->salt_len;
4661 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4662 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4669 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4671 const hash_t
*h1
= (const hash_t
*) v1
;
4672 const hash_t
*h2
= (const hash_t
*) v2
;
4674 const salt_t
*s1
= h1
->salt
;
4675 const salt_t
*s2
= h2
->salt
;
4677 // 16 - 2 (since last 2 uints contain the digest)
4682 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4683 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4689 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4691 const hash_t
*h1
= (const hash_t
*) v1
;
4692 const hash_t
*h2
= (const hash_t
*) v2
;
4694 const void *d1
= h1
->digest
;
4695 const void *d2
= h2
->digest
;
4697 return data
.sort_by_digest (d1
, d2
);
4700 int sort_by_hash (const void *v1
, const void *v2
)
4702 const hash_t
*h1
= (const hash_t
*) v1
;
4703 const hash_t
*h2
= (const hash_t
*) v2
;
4707 const salt_t
*s1
= h1
->salt
;
4708 const salt_t
*s2
= h2
->salt
;
4710 int res
= sort_by_salt (s1
, s2
);
4712 if (res
!= 0) return (res
);
4715 const void *d1
= h1
->digest
;
4716 const void *d2
= h2
->digest
;
4718 return data
.sort_by_digest (d1
, d2
);
4721 int sort_by_pot (const void *v1
, const void *v2
)
4723 const pot_t
*p1
= (const pot_t
*) v1
;
4724 const pot_t
*p2
= (const pot_t
*) v2
;
4726 const hash_t
*h1
= &p1
->hash
;
4727 const hash_t
*h2
= &p2
->hash
;
4729 return sort_by_hash (h1
, h2
);
4732 int sort_by_mtime (const void *p1
, const void *p2
)
4734 const char **f1
= (const char **) p1
;
4735 const char **f2
= (const char **) p2
;
4737 struct stat s1
; stat (*f1
, &s1
);
4738 struct stat s2
; stat (*f2
, &s2
);
4740 return s2
.st_mtime
- s1
.st_mtime
;
4743 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4745 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4746 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4748 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4751 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4753 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4754 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4756 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4759 int sort_by_stringptr (const void *p1
, const void *p2
)
4761 const char **s1
= (const char **) p1
;
4762 const char **s2
= (const char **) p2
;
4764 return strcmp (*s1
, *s2
);
4767 int sort_by_dictstat (const void *s1
, const void *s2
)
4769 dictstat_t
*d1
= (dictstat_t
*) s1
;
4770 dictstat_t
*d2
= (dictstat_t
*) s2
;
4773 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4775 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4778 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4781 int sort_by_bitmap (const void *p1
, const void *p2
)
4783 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4784 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4786 return b1
->collisions
- b2
->collisions
;
4789 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4791 const u32
*d1
= (const u32
*) v1
;
4792 const u32
*d2
= (const u32
*) v2
;
4798 if (d1
[n
] > d2
[n
]) return ( 1);
4799 if (d1
[n
] < d2
[n
]) return (-1);
4805 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4807 const u32
*d1
= (const u32
*) v1
;
4808 const u32
*d2
= (const u32
*) v2
;
4814 if (d1
[n
] > d2
[n
]) return ( 1);
4815 if (d1
[n
] < d2
[n
]) return (-1);
4821 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4823 const u32
*d1
= (const u32
*) v1
;
4824 const u32
*d2
= (const u32
*) v2
;
4830 if (d1
[n
] > d2
[n
]) return ( 1);
4831 if (d1
[n
] < d2
[n
]) return (-1);
4837 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4839 const u32
*d1
= (const u32
*) v1
;
4840 const u32
*d2
= (const u32
*) v2
;
4846 if (d1
[n
] > d2
[n
]) return ( 1);
4847 if (d1
[n
] < d2
[n
]) return (-1);
4853 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4855 const u32
*d1
= (const u32
*) v1
;
4856 const u32
*d2
= (const u32
*) v2
;
4862 if (d1
[n
] > d2
[n
]) return ( 1);
4863 if (d1
[n
] < d2
[n
]) return (-1);
4869 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4871 const u32
*d1
= (const u32
*) v1
;
4872 const u32
*d2
= (const u32
*) v2
;
4878 if (d1
[n
] > d2
[n
]) return ( 1);
4879 if (d1
[n
] < d2
[n
]) return (-1);
4885 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4887 const u32
*d1
= (const u32
*) v1
;
4888 const u32
*d2
= (const u32
*) v2
;
4894 if (d1
[n
] > d2
[n
]) return ( 1);
4895 if (d1
[n
] < d2
[n
]) return (-1);
4901 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4903 const u32
*d1
= (const u32
*) v1
;
4904 const u32
*d2
= (const u32
*) v2
;
4910 if (d1
[n
] > d2
[n
]) return ( 1);
4911 if (d1
[n
] < d2
[n
]) return (-1);
4917 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4919 const u64
*d1
= (const u64
*) v1
;
4920 const u64
*d2
= (const u64
*) v2
;
4926 if (d1
[n
] > d2
[n
]) return ( 1);
4927 if (d1
[n
] < d2
[n
]) return (-1);
4933 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4935 const u64
*d1
= (const u64
*) v1
;
4936 const u64
*d2
= (const u64
*) v2
;
4942 if (d1
[n
] > d2
[n
]) return ( 1);
4943 if (d1
[n
] < d2
[n
]) return (-1);
4949 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4951 const u64
*d1
= (const u64
*) v1
;
4952 const u64
*d2
= (const u64
*) v2
;
4958 if (d1
[n
] > d2
[n
]) return ( 1);
4959 if (d1
[n
] < d2
[n
]) return (-1);
4965 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4967 const u32
*d1
= (const u32
*) v1
;
4968 const u32
*d2
= (const u32
*) v2
;
4970 const uint dgst_pos0
= data
.dgst_pos0
;
4971 const uint dgst_pos1
= data
.dgst_pos1
;
4972 const uint dgst_pos2
= data
.dgst_pos2
;
4973 const uint dgst_pos3
= data
.dgst_pos3
;
4975 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4976 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4977 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4978 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4979 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4980 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4981 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4982 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4987 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4989 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4990 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4992 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4994 if (res1
!= 0) return (res1
);
4999 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
5001 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
5002 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
5004 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
5006 if (res1
!= 0) return (res1
);
5008 const int res2
= t1
->attack_mode
5011 if (res2
!= 0) return (res2
);
5013 const int res3
= t1
->hash_type
5016 if (res3
!= 0) return (res3
);
5021 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
)
5023 uint outfile_autohex
= data
.outfile_autohex
;
5025 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
5027 FILE *debug_fp
= NULL
;
5029 if (debug_file
!= NULL
)
5031 debug_fp
= fopen (debug_file
, "ab");
5033 lock_file (debug_fp
);
5040 if (debug_fp
== NULL
)
5042 log_info ("WARNING: Could not open debug-file for writing");
5046 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
5048 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
5050 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
5053 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
5055 if (debug_mode
== 4)
5057 fputc (':', debug_fp
);
5059 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
5062 fputc ('\n', debug_fp
);
5064 if (debug_file
!= NULL
) fclose (debug_fp
);
5068 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
5070 int needs_hexify
= 0;
5072 if (outfile_autohex
== 1)
5074 for (uint i
= 0; i
< plain_len
; i
++)
5076 if (plain_ptr
[i
] < 0x20)
5083 if (plain_ptr
[i
] > 0x7f)
5092 if (needs_hexify
== 1)
5094 fprintf (fp
, "$HEX[");
5096 for (uint i
= 0; i
< plain_len
; i
++)
5098 fprintf (fp
, "%02x", plain_ptr
[i
]);
5105 fwrite (plain_ptr
, plain_len
, 1, fp
);
5109 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
)
5111 uint outfile_format
= data
.outfile_format
;
5113 char separator
= data
.separator
;
5115 if (outfile_format
& OUTFILE_FMT_HASH
)
5117 fprintf (out_fp
, "%s", out_buf
);
5119 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5121 fputc (separator
, out_fp
);
5124 else if (data
.username
)
5126 if (username
!= NULL
)
5128 for (uint i
= 0; i
< user_len
; i
++)
5130 fprintf (out_fp
, "%c", username
[i
]);
5133 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5135 fputc (separator
, out_fp
);
5140 if (outfile_format
& OUTFILE_FMT_PLAIN
)
5142 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
5144 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5146 fputc (separator
, out_fp
);
5150 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
5152 for (uint i
= 0; i
< plain_len
; i
++)
5154 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
5157 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
5159 fputc (separator
, out_fp
);
5163 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
5166 __mingw_fprintf (out_fp
, "%llu", crackpos
);
5171 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
5173 fprintf (out_fp
, "%llu", crackpos
);
5178 fputc ('\n', out_fp
);
5181 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
)
5185 pot_key
.hash
.salt
= hashes_buf
->salt
;
5186 pot_key
.hash
.digest
= hashes_buf
->digest
;
5188 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5194 input_buf
[input_len
] = 0;
5197 unsigned char *username
= NULL
;
5202 user_t
*user
= hashes_buf
->hash_info
->user
;
5206 username
= (unsigned char *) (user
->user_name
);
5208 user_len
= user
->user_len
;
5212 // do output the line
5213 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5217 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5218 #define LM_MASKED_PLAIN "[notfound]"
5220 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
)
5226 pot_left_key
.hash
.salt
= hash_left
->salt
;
5227 pot_left_key
.hash
.digest
= hash_left
->digest
;
5229 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5233 uint weak_hash_found
= 0;
5235 pot_t pot_right_key
;
5237 pot_right_key
.hash
.salt
= hash_right
->salt
;
5238 pot_right_key
.hash
.digest
= hash_right
->digest
;
5240 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5242 if (pot_right_ptr
== NULL
)
5244 // special case, if "weak hash"
5246 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5248 weak_hash_found
= 1;
5250 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5252 // in theory this is not needed, but we are paranoia:
5254 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5255 pot_right_ptr
->plain_len
= 0;
5259 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5261 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
5266 // at least one half was found:
5270 input_buf
[input_len
] = 0;
5274 unsigned char *username
= NULL
;
5279 user_t
*user
= hash_left
->hash_info
->user
;
5283 username
= (unsigned char *) (user
->user_name
);
5285 user_len
= user
->user_len
;
5289 // mask the part which was not found
5291 uint left_part_masked
= 0;
5292 uint right_part_masked
= 0;
5294 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5296 if (pot_left_ptr
== NULL
)
5298 left_part_masked
= 1;
5300 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5302 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5304 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5305 pot_left_ptr
->plain_len
= mask_plain_len
;
5308 if (pot_right_ptr
== NULL
)
5310 right_part_masked
= 1;
5312 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5314 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5316 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5317 pot_right_ptr
->plain_len
= mask_plain_len
;
5320 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5324 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5326 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5328 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5330 // do output the line
5332 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5334 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5336 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5337 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5340 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
)
5344 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5346 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5348 if (pot_ptr
== NULL
)
5352 input_buf
[input_len
] = 0;
5354 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5358 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
)
5364 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5366 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5370 pot_t pot_right_key
;
5372 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5374 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5376 uint weak_hash_found
= 0;
5378 if (pot_right_ptr
== NULL
)
5380 // special case, if "weak hash"
5382 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5384 weak_hash_found
= 1;
5386 // we just need that pot_right_ptr is not a NULL pointer
5388 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5392 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5394 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5399 // ... at least one part was not cracked
5403 input_buf
[input_len
] = 0;
5405 // only show the hash part which is still not cracked
5407 uint user_len
= input_len
- 32;
5409 char *hash_output
= (char *) mymalloc (33);
5411 memcpy (hash_output
, input_buf
, input_len
);
5413 if (pot_left_ptr
!= NULL
)
5415 // only show right part (because left part was already found)
5417 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5419 hash_output
[user_len
+ 16] = 0;
5422 if (pot_right_ptr
!= NULL
)
5424 // only show left part (because right part was already found)
5426 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5428 hash_output
[user_len
+ 16] = 0;
5431 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5433 myfree (hash_output
);
5435 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5438 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5440 uint opencl_platforms_filter
= 0;
5442 if (opencl_platforms
)
5444 char *platforms
= strdup (opencl_platforms
);
5446 char *next
= strtok (platforms
, ",");
5450 int platform
= atoi (next
);
5452 if (platform
< 1 || platform
> 32)
5454 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5459 opencl_platforms_filter
|= 1 << (platform
- 1);
5461 } while ((next
= strtok (NULL
, ",")) != NULL
);
5467 opencl_platforms_filter
= -1;
5470 return opencl_platforms_filter
;
5473 u32
setup_devices_filter (char *opencl_devices
)
5475 u32 devices_filter
= 0;
5479 char *devices
= strdup (opencl_devices
);
5481 char *next
= strtok (devices
, ",");
5485 int device_id
= atoi (next
);
5487 if (device_id
< 1 || device_id
> 32)
5489 log_error ("ERROR: invalid device_id %u specified", device_id
);
5494 devices_filter
|= 1 << (device_id
- 1);
5496 } while ((next
= strtok (NULL
, ",")) != NULL
);
5502 devices_filter
= -1;
5505 return devices_filter
;
5508 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5510 cl_device_type device_types_filter
= 0;
5512 if (opencl_device_types
)
5514 char *device_types
= strdup (opencl_device_types
);
5516 char *next
= strtok (device_types
, ",");
5520 int device_type
= atoi (next
);
5522 if (device_type
< 1 || device_type
> 3)
5524 log_error ("ERROR: invalid device_type %u specified", device_type
);
5529 device_types_filter
|= 1 << device_type
;
5531 } while ((next
= strtok (NULL
, ",")) != NULL
);
5533 free (device_types
);
5537 // Do not use CPU by default, this often reduces GPU performance because
5538 // the CPU is too busy to handle GPU synchronization
5540 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5543 return device_types_filter
;
5546 u32
get_random_num (const u32 min
, const u32 max
)
5548 if (min
== max
) return (min
);
5550 return ((rand () % (max
- min
)) + min
);
5553 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5555 u32 quotient
= dividend
/ divisor
;
5557 if (dividend
% divisor
) quotient
++;
5562 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5564 u64 quotient
= dividend
/ divisor
;
5566 if (dividend
% divisor
) quotient
++;
5571 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5573 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5574 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5576 if (tm
->tm_year
- 70)
5578 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5579 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5581 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5583 else if (tm
->tm_yday
)
5585 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5586 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5588 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5590 else if (tm
->tm_hour
)
5592 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5593 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5595 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5597 else if (tm
->tm_min
)
5599 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5600 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5602 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5606 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5608 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5612 void format_speed_display (float val
, char *buf
, size_t len
)
5623 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5634 /* generate output */
5638 snprintf (buf
, len
- 1, "%.0f ", val
);
5642 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5646 void lowercase (u8
*buf
, int len
)
5648 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5651 void uppercase (u8
*buf
, int len
)
5653 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5656 int fgetl (FILE *fp
, char *line_buf
)
5662 const int c
= fgetc (fp
);
5664 if (c
== EOF
) break;
5666 line_buf
[line_len
] = (char) c
;
5670 if (line_len
== HCBUFSIZ
) line_len
--;
5672 if (c
== '\n') break;
5675 if (line_len
== 0) return 0;
5677 if (line_buf
[line_len
- 1] == '\n')
5681 line_buf
[line_len
] = 0;
5684 if (line_len
== 0) return 0;
5686 if (line_buf
[line_len
- 1] == '\r')
5690 line_buf
[line_len
] = 0;
5696 int in_superchop (char *buf
)
5698 int len
= strlen (buf
);
5702 if (buf
[len
- 1] == '\n')
5709 if (buf
[len
- 1] == '\r')
5724 char **scan_directory (const char *path
)
5726 char *tmp_path
= mystrdup (path
);
5728 size_t tmp_path_len
= strlen (tmp_path
);
5730 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5732 tmp_path
[tmp_path_len
- 1] = 0;
5734 tmp_path_len
= strlen (tmp_path
);
5737 char **files
= NULL
;
5743 if ((d
= opendir (tmp_path
)) != NULL
)
5749 memset (&e
, 0, sizeof (e
));
5750 struct dirent
*de
= NULL
;
5752 if (readdir_r (d
, &e
, &de
) != 0)
5754 log_error ("ERROR: readdir_r() failed");
5759 if (de
== NULL
) break;
5763 while ((de
= readdir (d
)) != NULL
)
5766 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5768 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5770 char *path_file
= (char *) mymalloc (path_size
+ 1);
5772 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5774 path_file
[path_size
] = 0;
5778 if ((d_test
= opendir (path_file
)) != NULL
)
5786 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5790 files
[num_files
- 1] = path_file
;
5796 else if (errno
== ENOTDIR
)
5798 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5802 files
[num_files
- 1] = mystrdup (path
);
5805 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5809 files
[num_files
- 1] = NULL
;
5816 int count_dictionaries (char **dictionary_files
)
5818 if (dictionary_files
== NULL
) return 0;
5822 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5830 char *stroptitype (const uint opti_type
)
5834 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5835 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5836 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5837 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5838 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5839 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5840 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5841 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5842 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5843 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5844 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5845 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5846 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5847 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5848 case OPTI_TYPE_SLOW_HASH_SIMD
: return ((char *) OPTI_STR_SLOW_HASH_SIMD
); break;
5849 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5850 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5851 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5852 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5858 char *strparser (const uint parser_status
)
5860 switch (parser_status
)
5862 case PARSER_OK
: return ((char *) PA_000
); break;
5863 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5864 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5865 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5866 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5867 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5868 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5869 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5870 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5871 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5872 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5873 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5874 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5875 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5876 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5877 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5878 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5881 return ((char *) PA_255
);
5884 char *strhashtype (const uint hash_mode
)
5888 case 0: return ((char *) HT_00000
); break;
5889 case 10: return ((char *) HT_00010
); break;
5890 case 11: return ((char *) HT_00011
); break;
5891 case 12: return ((char *) HT_00012
); break;
5892 case 20: return ((char *) HT_00020
); break;
5893 case 21: return ((char *) HT_00021
); break;
5894 case 22: return ((char *) HT_00022
); break;
5895 case 23: return ((char *) HT_00023
); break;
5896 case 30: return ((char *) HT_00030
); break;
5897 case 40: return ((char *) HT_00040
); break;
5898 case 50: return ((char *) HT_00050
); break;
5899 case 60: return ((char *) HT_00060
); break;
5900 case 100: return ((char *) HT_00100
); break;
5901 case 101: return ((char *) HT_00101
); break;
5902 case 110: return ((char *) HT_00110
); break;
5903 case 111: return ((char *) HT_00111
); break;
5904 case 112: return ((char *) HT_00112
); break;
5905 case 120: return ((char *) HT_00120
); break;
5906 case 121: return ((char *) HT_00121
); break;
5907 case 122: return ((char *) HT_00122
); break;
5908 case 124: return ((char *) HT_00124
); break;
5909 case 125: return ((char *) HT_00125
); break;
5910 case 130: return ((char *) HT_00130
); break;
5911 case 131: return ((char *) HT_00131
); break;
5912 case 132: return ((char *) HT_00132
); break;
5913 case 133: return ((char *) HT_00133
); break;
5914 case 140: return ((char *) HT_00140
); break;
5915 case 141: return ((char *) HT_00141
); break;
5916 case 150: return ((char *) HT_00150
); break;
5917 case 160: return ((char *) HT_00160
); break;
5918 case 190: return ((char *) HT_00190
); break;
5919 case 200: return ((char *) HT_00200
); break;
5920 case 300: return ((char *) HT_00300
); break;
5921 case 400: return ((char *) HT_00400
); break;
5922 case 500: return ((char *) HT_00500
); break;
5923 case 501: return ((char *) HT_00501
); break;
5924 case 900: return ((char *) HT_00900
); break;
5925 case 910: return ((char *) HT_00910
); break;
5926 case 1000: return ((char *) HT_01000
); break;
5927 case 1100: return ((char *) HT_01100
); break;
5928 case 1400: return ((char *) HT_01400
); break;
5929 case 1410: return ((char *) HT_01410
); break;
5930 case 1420: return ((char *) HT_01420
); break;
5931 case 1421: return ((char *) HT_01421
); break;
5932 case 1430: return ((char *) HT_01430
); break;
5933 case 1440: return ((char *) HT_01440
); break;
5934 case 1441: return ((char *) HT_01441
); break;
5935 case 1450: return ((char *) HT_01450
); break;
5936 case 1460: return ((char *) HT_01460
); break;
5937 case 1500: return ((char *) HT_01500
); break;
5938 case 1600: return ((char *) HT_01600
); break;
5939 case 1700: return ((char *) HT_01700
); break;
5940 case 1710: return ((char *) HT_01710
); break;
5941 case 1711: return ((char *) HT_01711
); break;
5942 case 1720: return ((char *) HT_01720
); break;
5943 case 1722: return ((char *) HT_01722
); break;
5944 case 1730: return ((char *) HT_01730
); break;
5945 case 1731: return ((char *) HT_01731
); break;
5946 case 1740: return ((char *) HT_01740
); break;
5947 case 1750: return ((char *) HT_01750
); break;
5948 case 1760: return ((char *) HT_01760
); break;
5949 case 1800: return ((char *) HT_01800
); break;
5950 case 2100: return ((char *) HT_02100
); break;
5951 case 2400: return ((char *) HT_02400
); break;
5952 case 2410: return ((char *) HT_02410
); break;
5953 case 2500: return ((char *) HT_02500
); break;
5954 case 2600: return ((char *) HT_02600
); break;
5955 case 2611: return ((char *) HT_02611
); break;
5956 case 2612: return ((char *) HT_02612
); break;
5957 case 2711: return ((char *) HT_02711
); break;
5958 case 2811: return ((char *) HT_02811
); break;
5959 case 3000: return ((char *) HT_03000
); break;
5960 case 3100: return ((char *) HT_03100
); break;
5961 case 3200: return ((char *) HT_03200
); break;
5962 case 3710: return ((char *) HT_03710
); break;
5963 case 3711: return ((char *) HT_03711
); break;
5964 case 3800: return ((char *) HT_03800
); break;
5965 case 4300: return ((char *) HT_04300
); break;
5966 case 4400: return ((char *) HT_04400
); break;
5967 case 4500: return ((char *) HT_04500
); break;
5968 case 4700: return ((char *) HT_04700
); break;
5969 case 4800: return ((char *) HT_04800
); break;
5970 case 4900: return ((char *) HT_04900
); break;
5971 case 5000: return ((char *) HT_05000
); break;
5972 case 5100: return ((char *) HT_05100
); break;
5973 case 5200: return ((char *) HT_05200
); break;
5974 case 5300: return ((char *) HT_05300
); break;
5975 case 5400: return ((char *) HT_05400
); break;
5976 case 5500: return ((char *) HT_05500
); break;
5977 case 5600: return ((char *) HT_05600
); break;
5978 case 5700: return ((char *) HT_05700
); break;
5979 case 5800: return ((char *) HT_05800
); break;
5980 case 6000: return ((char *) HT_06000
); break;
5981 case 6100: return ((char *) HT_06100
); break;
5982 case 6211: return ((char *) HT_06211
); break;
5983 case 6212: return ((char *) HT_06212
); break;
5984 case 6213: return ((char *) HT_06213
); break;
5985 case 6221: return ((char *) HT_06221
); break;
5986 case 6222: return ((char *) HT_06222
); break;
5987 case 6223: return ((char *) HT_06223
); break;
5988 case 6231: return ((char *) HT_06231
); break;
5989 case 6232: return ((char *) HT_06232
); break;
5990 case 6233: return ((char *) HT_06233
); break;
5991 case 6241: return ((char *) HT_06241
); break;
5992 case 6242: return ((char *) HT_06242
); break;
5993 case 6243: return ((char *) HT_06243
); break;
5994 case 6300: return ((char *) HT_06300
); break;
5995 case 6400: return ((char *) HT_06400
); break;
5996 case 6500: return ((char *) HT_06500
); break;
5997 case 6600: return ((char *) HT_06600
); break;
5998 case 6700: return ((char *) HT_06700
); break;
5999 case 6800: return ((char *) HT_06800
); break;
6000 case 6900: return ((char *) HT_06900
); break;
6001 case 7100: return ((char *) HT_07100
); break;
6002 case 7200: return ((char *) HT_07200
); break;
6003 case 7300: return ((char *) HT_07300
); break;
6004 case 7400: return ((char *) HT_07400
); break;
6005 case 7500: return ((char *) HT_07500
); break;
6006 case 7600: return ((char *) HT_07600
); break;
6007 case 7700: return ((char *) HT_07700
); break;
6008 case 7800: return ((char *) HT_07800
); break;
6009 case 7900: return ((char *) HT_07900
); break;
6010 case 8000: return ((char *) HT_08000
); break;
6011 case 8100: return ((char *) HT_08100
); break;
6012 case 8200: return ((char *) HT_08200
); break;
6013 case 8300: return ((char *) HT_08300
); break;
6014 case 8400: return ((char *) HT_08400
); break;
6015 case 8500: return ((char *) HT_08500
); break;
6016 case 8600: return ((char *) HT_08600
); break;
6017 case 8700: return ((char *) HT_08700
); break;
6018 case 8800: return ((char *) HT_08800
); break;
6019 case 8900: return ((char *) HT_08900
); break;
6020 case 9000: return ((char *) HT_09000
); break;
6021 case 9100: return ((char *) HT_09100
); break;
6022 case 9200: return ((char *) HT_09200
); break;
6023 case 9300: return ((char *) HT_09300
); break;
6024 case 9400: return ((char *) HT_09400
); break;
6025 case 9500: return ((char *) HT_09500
); break;
6026 case 9600: return ((char *) HT_09600
); break;
6027 case 9700: return ((char *) HT_09700
); break;
6028 case 9710: return ((char *) HT_09710
); break;
6029 case 9720: return ((char *) HT_09720
); break;
6030 case 9800: return ((char *) HT_09800
); break;
6031 case 9810: return ((char *) HT_09810
); break;
6032 case 9820: return ((char *) HT_09820
); break;
6033 case 9900: return ((char *) HT_09900
); break;
6034 case 10000: return ((char *) HT_10000
); break;
6035 case 10100: return ((char *) HT_10100
); break;
6036 case 10200: return ((char *) HT_10200
); break;
6037 case 10300: return ((char *) HT_10300
); break;
6038 case 10400: return ((char *) HT_10400
); break;
6039 case 10410: return ((char *) HT_10410
); break;
6040 case 10420: return ((char *) HT_10420
); break;
6041 case 10500: return ((char *) HT_10500
); break;
6042 case 10600: return ((char *) HT_10600
); break;
6043 case 10700: return ((char *) HT_10700
); break;
6044 case 10800: return ((char *) HT_10800
); break;
6045 case 10900: return ((char *) HT_10900
); break;
6046 case 11000: return ((char *) HT_11000
); break;
6047 case 11100: return ((char *) HT_11100
); break;
6048 case 11200: return ((char *) HT_11200
); break;
6049 case 11300: return ((char *) HT_11300
); break;
6050 case 11400: return ((char *) HT_11400
); break;
6051 case 11500: return ((char *) HT_11500
); break;
6052 case 11600: return ((char *) HT_11600
); break;
6053 case 11700: return ((char *) HT_11700
); break;
6054 case 11800: return ((char *) HT_11800
); break;
6055 case 11900: return ((char *) HT_11900
); break;
6056 case 12000: return ((char *) HT_12000
); break;
6057 case 12100: return ((char *) HT_12100
); break;
6058 case 12200: return ((char *) HT_12200
); break;
6059 case 12300: return ((char *) HT_12300
); break;
6060 case 12400: return ((char *) HT_12400
); break;
6061 case 12500: return ((char *) HT_12500
); break;
6062 case 12600: return ((char *) HT_12600
); break;
6063 case 12700: return ((char *) HT_12700
); break;
6064 case 12800: return ((char *) HT_12800
); break;
6065 case 12900: return ((char *) HT_12900
); break;
6066 case 13000: return ((char *) HT_13000
); break;
6067 case 13100: return ((char *) HT_13100
); break;
6068 case 13200: return ((char *) HT_13200
); break;
6069 case 13300: return ((char *) HT_13300
); break;
6070 case 13400: return ((char *) HT_13400
); break;
6071 case 13500: return ((char *) HT_13500
); break;
6072 case 13600: return ((char *) HT_13600
); break;
6073 case 13711: return ((char *) HT_13711
); break;
6074 case 13712: return ((char *) HT_13712
); break;
6075 case 13713: return ((char *) HT_13713
); break;
6076 case 13721: return ((char *) HT_13721
); break;
6077 case 13722: return ((char *) HT_13722
); break;
6078 case 13723: return ((char *) HT_13723
); break;
6079 case 13731: return ((char *) HT_13731
); break;
6080 case 13732: return ((char *) HT_13732
); break;
6081 case 13733: return ((char *) HT_13733
); break;
6082 case 13741: return ((char *) HT_13741
); break;
6083 case 13742: return ((char *) HT_13742
); break;
6084 case 13743: return ((char *) HT_13743
); break;
6085 case 13751: return ((char *) HT_13751
); break;
6086 case 13752: return ((char *) HT_13752
); break;
6087 case 13753: return ((char *) HT_13753
); break;
6088 case 13761: return ((char *) HT_13761
); break;
6089 case 13762: return ((char *) HT_13762
); break;
6090 case 13763: return ((char *) HT_13763
); break;
6093 return ((char *) "Unknown");
6096 char *strstatus (const uint devices_status
)
6098 switch (devices_status
)
6100 case STATUS_INIT
: return ((char *) ST_0000
); break;
6101 case STATUS_STARTING
: return ((char *) ST_0001
); break;
6102 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
6103 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
6104 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
6105 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
6106 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
6107 case STATUS_QUIT
: return ((char *) ST_0007
); break;
6108 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
6109 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
6110 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
6113 return ((char *) "Unknown");
6116 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
6118 uint hash_type
= data
.hash_type
;
6119 uint hash_mode
= data
.hash_mode
;
6120 uint salt_type
= data
.salt_type
;
6121 uint opts_type
= data
.opts_type
;
6122 uint opti_type
= data
.opti_type
;
6123 uint dgst_size
= data
.dgst_size
;
6125 char *hashfile
= data
.hashfile
;
6129 uint digest_buf
[64] = { 0 };
6131 u64
*digest_buf64
= (u64
*) digest_buf
;
6133 char *digests_buf_ptr
= (char *) data
.digests_buf
;
6135 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
6137 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6143 case HASH_TYPE_DESCRYPT
:
6144 FP (digest_buf
[1], digest_buf
[0], tt
);
6147 case HASH_TYPE_DESRACF
:
6148 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6149 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6151 FP (digest_buf
[1], digest_buf
[0], tt
);
6155 FP (digest_buf
[1], digest_buf
[0], tt
);
6158 case HASH_TYPE_NETNTLM
:
6159 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6160 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6161 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
6162 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
6164 FP (digest_buf
[1], digest_buf
[0], tt
);
6165 FP (digest_buf
[3], digest_buf
[2], tt
);
6168 case HASH_TYPE_BSDICRYPT
:
6169 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
6170 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
6172 FP (digest_buf
[1], digest_buf
[0], tt
);
6177 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
6182 digest_buf
[0] += MD4M_A
;
6183 digest_buf
[1] += MD4M_B
;
6184 digest_buf
[2] += MD4M_C
;
6185 digest_buf
[3] += MD4M_D
;
6189 digest_buf
[0] += MD5M_A
;
6190 digest_buf
[1] += MD5M_B
;
6191 digest_buf
[2] += MD5M_C
;
6192 digest_buf
[3] += MD5M_D
;
6195 case HASH_TYPE_SHA1
:
6196 digest_buf
[0] += SHA1M_A
;
6197 digest_buf
[1] += SHA1M_B
;
6198 digest_buf
[2] += SHA1M_C
;
6199 digest_buf
[3] += SHA1M_D
;
6200 digest_buf
[4] += SHA1M_E
;
6203 case HASH_TYPE_SHA256
:
6204 digest_buf
[0] += SHA256M_A
;
6205 digest_buf
[1] += SHA256M_B
;
6206 digest_buf
[2] += SHA256M_C
;
6207 digest_buf
[3] += SHA256M_D
;
6208 digest_buf
[4] += SHA256M_E
;
6209 digest_buf
[5] += SHA256M_F
;
6210 digest_buf
[6] += SHA256M_G
;
6211 digest_buf
[7] += SHA256M_H
;
6214 case HASH_TYPE_SHA384
:
6215 digest_buf64
[0] += SHA384M_A
;
6216 digest_buf64
[1] += SHA384M_B
;
6217 digest_buf64
[2] += SHA384M_C
;
6218 digest_buf64
[3] += SHA384M_D
;
6219 digest_buf64
[4] += SHA384M_E
;
6220 digest_buf64
[5] += SHA384M_F
;
6221 digest_buf64
[6] += 0;
6222 digest_buf64
[7] += 0;
6225 case HASH_TYPE_SHA512
:
6226 digest_buf64
[0] += SHA512M_A
;
6227 digest_buf64
[1] += SHA512M_B
;
6228 digest_buf64
[2] += SHA512M_C
;
6229 digest_buf64
[3] += SHA512M_D
;
6230 digest_buf64
[4] += SHA512M_E
;
6231 digest_buf64
[5] += SHA512M_F
;
6232 digest_buf64
[6] += SHA512M_G
;
6233 digest_buf64
[7] += SHA512M_H
;
6238 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6240 if (dgst_size
== DGST_SIZE_4_2
)
6242 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6244 else if (dgst_size
== DGST_SIZE_4_4
)
6246 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6248 else if (dgst_size
== DGST_SIZE_4_5
)
6250 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6252 else if (dgst_size
== DGST_SIZE_4_6
)
6254 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6256 else if (dgst_size
== DGST_SIZE_4_8
)
6258 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6260 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6262 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6264 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6266 else if (hash_type
== HASH_TYPE_SHA384
)
6268 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6270 else if (hash_type
== HASH_TYPE_SHA512
)
6272 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6274 else if (hash_type
== HASH_TYPE_GOST
)
6276 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6279 else if (dgst_size
== DGST_SIZE_4_64
)
6281 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6283 else if (dgst_size
== DGST_SIZE_8_25
)
6285 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6289 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6290 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6291 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6297 memset (&salt
, 0, sizeof (salt_t
));
6299 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6301 char *ptr
= (char *) salt
.salt_buf
;
6303 uint len
= salt
.salt_len
;
6305 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6311 case HASH_TYPE_NETNTLM
:
6313 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6314 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6316 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6322 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6324 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6332 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6334 uint max
= salt
.salt_len
/ 4;
6338 for (uint i
= 0; i
< max
; i
++)
6340 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6344 if (opts_type
& OPTS_TYPE_ST_HEX
)
6346 char tmp
[64] = { 0 };
6348 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6350 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6355 memcpy (ptr
, tmp
, len
);
6358 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6360 memset (ptr
+ len
, 0, memset_size
);
6362 salt
.salt_len
= len
;
6366 // some modes require special encoding
6369 uint out_buf_plain
[256] = { 0 };
6370 uint out_buf_salt
[256] = { 0 };
6372 char tmp_buf
[1024] = { 0 };
6374 char *ptr_plain
= (char *) out_buf_plain
;
6375 char *ptr_salt
= (char *) out_buf_salt
;
6377 if (hash_mode
== 22)
6379 char username
[30] = { 0 };
6381 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6383 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6385 u16
*ptr
= (u16
*) digest_buf
;
6387 tmp_buf
[ 0] = sig
[0];
6388 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6389 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6390 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6391 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6392 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6393 tmp_buf
[ 6] = sig
[1];
6394 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6395 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6396 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6397 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6398 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6399 tmp_buf
[12] = sig
[2];
6400 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6401 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6402 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6403 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6404 tmp_buf
[17] = sig
[3];
6405 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6406 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6407 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6408 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6409 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6410 tmp_buf
[23] = sig
[4];
6411 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6412 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6413 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6414 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6415 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6416 tmp_buf
[29] = sig
[5];
6418 snprintf (out_buf
, len
-1, "%s:%s",
6422 else if (hash_mode
== 23)
6424 // do not show the skyper part in output
6426 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6428 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6430 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6437 else if (hash_mode
== 101)
6439 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6441 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6442 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6443 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6444 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6445 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6447 memcpy (tmp_buf
, digest_buf
, 20);
6449 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6451 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6453 else if (hash_mode
== 111)
6455 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6457 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6458 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6459 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6460 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6461 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6463 memcpy (tmp_buf
, digest_buf
, 20);
6464 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6466 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6468 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6470 else if ((hash_mode
== 122) || (hash_mode
== 125))
6472 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6473 (char *) salt
.salt_buf
,
6480 else if (hash_mode
== 124)
6482 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6483 (char *) salt
.salt_buf
,
6490 else if (hash_mode
== 131)
6492 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6493 (char *) salt
.salt_buf
,
6501 else if (hash_mode
== 132)
6503 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6504 (char *) salt
.salt_buf
,
6511 else if (hash_mode
== 133)
6513 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6515 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6516 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6517 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6518 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6519 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6521 memcpy (tmp_buf
, digest_buf
, 20);
6523 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6525 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6527 else if (hash_mode
== 141)
6529 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6531 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6533 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6535 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6537 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6538 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6539 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6540 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6541 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6543 memcpy (tmp_buf
, digest_buf
, 20);
6545 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6549 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6551 else if (hash_mode
== 400)
6553 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6555 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6556 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6557 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6558 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6560 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6562 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6564 else if (hash_mode
== 500)
6566 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6568 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6569 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6570 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6571 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6573 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6575 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6577 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6581 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6584 else if (hash_mode
== 501)
6586 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6588 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6589 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6591 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6593 else if (hash_mode
== 1421)
6595 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6597 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6613 else if (hash_mode
== 1441)
6615 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6617 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6619 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6621 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6623 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6624 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6625 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6626 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6627 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6628 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6629 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6630 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6632 memcpy (tmp_buf
, digest_buf
, 32);
6634 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6638 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6640 else if (hash_mode
== 1500)
6642 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6643 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6644 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6645 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6646 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6648 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6650 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6652 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6653 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6655 memcpy (tmp_buf
, digest_buf
, 8);
6657 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6659 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6663 else if (hash_mode
== 1600)
6665 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6667 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6668 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6669 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6670 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6672 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6674 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6676 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6680 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6683 else if (hash_mode
== 1711)
6685 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6687 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6688 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6689 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6690 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6691 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6692 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6693 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6694 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6696 memcpy (tmp_buf
, digest_buf
, 64);
6697 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6699 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6701 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6703 else if (hash_mode
== 1722)
6705 uint
*ptr
= digest_buf
;
6707 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6708 (unsigned char *) salt
.salt_buf
,
6718 else if (hash_mode
== 1731)
6720 uint
*ptr
= digest_buf
;
6722 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6723 (unsigned char *) salt
.salt_buf
,
6733 else if (hash_mode
== 1800)
6737 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6738 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6739 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6740 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6741 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6742 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6743 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6744 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6746 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6748 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6750 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6754 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6757 else if (hash_mode
== 2100)
6761 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6763 salt
.salt_iter
+ 1);
6765 uint signature_len
= strlen (out_buf
);
6767 pos
+= signature_len
;
6768 len
-= signature_len
;
6770 char *salt_ptr
= (char *) salt
.salt_buf
;
6772 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6774 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6775 byte_swap_32 (digest_buf
[0]),
6776 byte_swap_32 (digest_buf
[1]),
6777 byte_swap_32 (digest_buf
[2]),
6778 byte_swap_32 (digest_buf
[3]));
6780 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6782 memcpy (tmp_buf
, digest_buf
, 16);
6784 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6786 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6787 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6788 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6789 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6791 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6792 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6793 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6794 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6796 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6797 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6798 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6799 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6801 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6802 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6803 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6804 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6806 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6807 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6808 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6809 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6813 else if (hash_mode
== 2500)
6815 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6817 wpa_t
*wpa
= &wpas
[salt_pos
];
6819 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6820 (char *) salt
.salt_buf
,
6834 else if (hash_mode
== 4400)
6836 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6837 byte_swap_32 (digest_buf
[0]),
6838 byte_swap_32 (digest_buf
[1]),
6839 byte_swap_32 (digest_buf
[2]),
6840 byte_swap_32 (digest_buf
[3]));
6842 else if (hash_mode
== 4700)
6844 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6845 byte_swap_32 (digest_buf
[0]),
6846 byte_swap_32 (digest_buf
[1]),
6847 byte_swap_32 (digest_buf
[2]),
6848 byte_swap_32 (digest_buf
[3]),
6849 byte_swap_32 (digest_buf
[4]));
6851 else if (hash_mode
== 4800)
6853 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6855 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6860 byte_swap_32 (salt
.salt_buf
[0]),
6861 byte_swap_32 (salt
.salt_buf
[1]),
6862 byte_swap_32 (salt
.salt_buf
[2]),
6863 byte_swap_32 (salt
.salt_buf
[3]),
6866 else if (hash_mode
== 4900)
6868 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6869 byte_swap_32 (digest_buf
[0]),
6870 byte_swap_32 (digest_buf
[1]),
6871 byte_swap_32 (digest_buf
[2]),
6872 byte_swap_32 (digest_buf
[3]),
6873 byte_swap_32 (digest_buf
[4]));
6875 else if (hash_mode
== 5100)
6877 snprintf (out_buf
, len
-1, "%08x%08x",
6881 else if (hash_mode
== 5200)
6883 snprintf (out_buf
, len
-1, "%s", hashfile
);
6885 else if (hash_mode
== 5300)
6887 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6889 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6891 int buf_len
= len
-1;
6895 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6897 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6899 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6901 snprintf (out_buf
, buf_len
, ":");
6907 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6915 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6917 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6919 if ((i
== 0) || (i
== 5))
6921 snprintf (out_buf
, buf_len
, ":");
6927 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6935 for (uint i
= 0; i
< 4; i
++)
6939 snprintf (out_buf
, buf_len
, ":");
6945 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6951 else if (hash_mode
== 5400)
6953 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6955 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6957 int buf_len
= len
-1;
6961 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6963 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6965 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6967 snprintf (out_buf
, buf_len
, ":");
6973 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6981 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6983 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6985 if ((i
== 0) || (i
== 5))
6987 snprintf (out_buf
, buf_len
, ":");
6993 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
7001 for (uint i
= 0; i
< 5; i
++)
7005 snprintf (out_buf
, buf_len
, ":");
7011 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
7017 else if (hash_mode
== 5500)
7019 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7021 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7023 char user_buf
[64] = { 0 };
7024 char domain_buf
[64] = { 0 };
7025 char srvchall_buf
[1024] = { 0 };
7026 char clichall_buf
[1024] = { 0 };
7028 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7030 char *ptr
= (char *) netntlm
->userdomain_buf
;
7032 user_buf
[i
] = ptr
[j
];
7035 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7037 char *ptr
= (char *) netntlm
->userdomain_buf
;
7039 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7042 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7044 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7046 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7049 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7051 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7053 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7056 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
7064 byte_swap_32 (salt
.salt_buf_pc
[0]),
7065 byte_swap_32 (salt
.salt_buf_pc
[1]),
7068 else if (hash_mode
== 5600)
7070 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7072 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7074 char user_buf
[64] = { 0 };
7075 char domain_buf
[64] = { 0 };
7076 char srvchall_buf
[1024] = { 0 };
7077 char clichall_buf
[1024] = { 0 };
7079 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7081 char *ptr
= (char *) netntlm
->userdomain_buf
;
7083 user_buf
[i
] = ptr
[j
];
7086 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7088 char *ptr
= (char *) netntlm
->userdomain_buf
;
7090 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7093 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7095 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7097 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7100 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7102 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7104 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7107 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
7117 else if (hash_mode
== 5700)
7119 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7121 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7122 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7123 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7124 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7125 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7126 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7127 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7128 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7130 memcpy (tmp_buf
, digest_buf
, 32);
7132 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
7136 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
7138 else if (hash_mode
== 5800)
7140 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7141 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7142 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7143 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7144 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7146 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
7153 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
7155 snprintf (out_buf
, len
-1, "%s", hashfile
);
7157 else if (hash_mode
== 6300)
7159 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7161 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7162 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7163 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7164 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7166 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7168 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7170 else if (hash_mode
== 6400)
7172 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7174 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7176 else if (hash_mode
== 6500)
7178 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7180 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7182 else if (hash_mode
== 6600)
7184 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
7186 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
7188 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7189 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7191 uint buf_len
= len
- 1;
7193 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
7196 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
7198 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
7203 else if (hash_mode
== 6700)
7205 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7207 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7209 else if (hash_mode
== 6800)
7211 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
7213 else if (hash_mode
== 7100)
7215 uint
*ptr
= digest_buf
;
7217 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7219 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7221 uint esalt
[8] = { 0 };
7223 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7224 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7225 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7226 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7227 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7228 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7229 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7230 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7232 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",
7233 SIGNATURE_SHA512OSX
,
7235 esalt
[ 0], esalt
[ 1],
7236 esalt
[ 2], esalt
[ 3],
7237 esalt
[ 4], esalt
[ 5],
7238 esalt
[ 6], esalt
[ 7],
7246 ptr
[15], ptr
[14]);
7248 else if (hash_mode
== 7200)
7250 uint
*ptr
= digest_buf
;
7252 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7254 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7258 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7260 len_used
= strlen (out_buf
);
7262 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7264 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7266 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7269 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",
7277 ptr
[15], ptr
[14]);
7279 else if (hash_mode
== 7300)
7281 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7283 rakp_t
*rakp
= &rakps
[salt_pos
];
7285 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7287 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7290 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7297 else if (hash_mode
== 7400)
7299 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7301 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7302 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7303 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7304 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7305 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7306 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7307 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7308 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7310 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7312 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7314 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7318 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7321 else if (hash_mode
== 7500)
7323 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7325 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7327 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7328 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7330 char data
[128] = { 0 };
7332 char *ptr_data
= data
;
7334 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7336 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7339 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7341 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7346 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7348 (char *) krb5pa
->user
,
7349 (char *) krb5pa
->realm
,
7350 (char *) krb5pa
->salt
,
7353 else if (hash_mode
== 7700)
7355 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7356 (char *) salt
.salt_buf
,
7360 else if (hash_mode
== 7800)
7362 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7363 (char *) salt
.salt_buf
,
7370 else if (hash_mode
== 7900)
7372 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7376 char *tmp
= (char *) salt
.salt_buf_pc
;
7378 ptr_plain
[42] = tmp
[0];
7384 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7386 else if (hash_mode
== 8000)
7388 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7389 (unsigned char *) salt
.salt_buf
,
7399 else if (hash_mode
== 8100)
7401 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7402 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7404 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7405 (unsigned char *) salt
.salt_buf
,
7412 else if (hash_mode
== 8200)
7414 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7416 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7418 char data_buf
[4096] = { 0 };
7420 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7422 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7425 data_buf
[cloudkey
->data_len
* 2] = 0;
7427 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7428 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7429 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7430 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7431 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7432 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7433 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7434 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7436 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7437 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7438 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7439 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7441 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7457 else if (hash_mode
== 8300)
7459 char digest_buf_c
[34] = { 0 };
7461 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7462 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7463 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7464 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7465 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7467 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7469 digest_buf_c
[32] = 0;
7473 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7475 char domain_buf_c
[33] = { 0 };
7477 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7479 for (uint i
= 0; i
< salt_pc_len
; i
++)
7481 const char next
= domain_buf_c
[i
];
7483 domain_buf_c
[i
] = '.';
7488 domain_buf_c
[salt_pc_len
] = 0;
7492 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7494 else if (hash_mode
== 8500)
7496 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7498 else if (hash_mode
== 2612)
7500 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7502 (char *) salt
.salt_buf
,
7508 else if (hash_mode
== 3711)
7510 char *salt_ptr
= (char *) salt
.salt_buf
;
7512 salt_ptr
[salt
.salt_len
- 1] = 0;
7514 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7515 SIGNATURE_MEDIAWIKI_B
,
7522 else if (hash_mode
== 8800)
7524 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7526 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7528 char tmp
[3073] = { 0 };
7530 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7532 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7537 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7538 SIGNATURE_ANDROIDFDE
,
7539 byte_swap_32 (salt
.salt_buf
[0]),
7540 byte_swap_32 (salt
.salt_buf
[1]),
7541 byte_swap_32 (salt
.salt_buf
[2]),
7542 byte_swap_32 (salt
.salt_buf
[3]),
7543 byte_swap_32 (digest_buf
[0]),
7544 byte_swap_32 (digest_buf
[1]),
7545 byte_swap_32 (digest_buf
[2]),
7546 byte_swap_32 (digest_buf
[3]),
7549 else if (hash_mode
== 8900)
7551 uint N
= salt
.scrypt_N
;
7552 uint r
= salt
.scrypt_r
;
7553 uint p
= salt
.scrypt_p
;
7555 char base64_salt
[32] = { 0 };
7557 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7559 memset (tmp_buf
, 0, 46);
7561 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7562 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7563 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7564 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7565 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7566 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7567 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7568 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7569 digest_buf
[8] = 0; // needed for base64_encode ()
7571 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7573 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7581 else if (hash_mode
== 9000)
7583 snprintf (out_buf
, len
-1, "%s", hashfile
);
7585 else if (hash_mode
== 9200)
7589 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7591 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7593 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7597 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7598 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7599 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7600 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7601 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7602 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7603 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7604 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7605 digest_buf
[8] = 0; // needed for base64_encode ()
7607 char tmp_buf
[64] = { 0 };
7609 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7610 tmp_buf
[43] = 0; // cut it here
7614 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7616 else if (hash_mode
== 9300)
7618 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7619 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7620 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7621 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7622 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7623 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7624 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7625 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7626 digest_buf
[8] = 0; // needed for base64_encode ()
7628 char tmp_buf
[64] = { 0 };
7630 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7631 tmp_buf
[43] = 0; // cut it here
7633 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7635 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7637 else if (hash_mode
== 9400)
7639 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7641 office2007_t
*office2007
= &office2007s
[salt_pos
];
7643 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7644 SIGNATURE_OFFICE2007
,
7647 office2007
->keySize
,
7653 office2007
->encryptedVerifier
[0],
7654 office2007
->encryptedVerifier
[1],
7655 office2007
->encryptedVerifier
[2],
7656 office2007
->encryptedVerifier
[3],
7657 office2007
->encryptedVerifierHash
[0],
7658 office2007
->encryptedVerifierHash
[1],
7659 office2007
->encryptedVerifierHash
[2],
7660 office2007
->encryptedVerifierHash
[3],
7661 office2007
->encryptedVerifierHash
[4]);
7663 else if (hash_mode
== 9500)
7665 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7667 office2010_t
*office2010
= &office2010s
[salt_pos
];
7669 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x%08x%08x", SIGNATURE_OFFICE2010
, 2010, 100000, 128, 16,
7675 office2010
->encryptedVerifier
[0],
7676 office2010
->encryptedVerifier
[1],
7677 office2010
->encryptedVerifier
[2],
7678 office2010
->encryptedVerifier
[3],
7679 office2010
->encryptedVerifierHash
[0],
7680 office2010
->encryptedVerifierHash
[1],
7681 office2010
->encryptedVerifierHash
[2],
7682 office2010
->encryptedVerifierHash
[3],
7683 office2010
->encryptedVerifierHash
[4],
7684 office2010
->encryptedVerifierHash
[5],
7685 office2010
->encryptedVerifierHash
[6],
7686 office2010
->encryptedVerifierHash
[7]);
7688 else if (hash_mode
== 9600)
7690 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7692 office2013_t
*office2013
= &office2013s
[salt_pos
];
7694 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,
7700 office2013
->encryptedVerifier
[0],
7701 office2013
->encryptedVerifier
[1],
7702 office2013
->encryptedVerifier
[2],
7703 office2013
->encryptedVerifier
[3],
7704 office2013
->encryptedVerifierHash
[0],
7705 office2013
->encryptedVerifierHash
[1],
7706 office2013
->encryptedVerifierHash
[2],
7707 office2013
->encryptedVerifierHash
[3],
7708 office2013
->encryptedVerifierHash
[4],
7709 office2013
->encryptedVerifierHash
[5],
7710 office2013
->encryptedVerifierHash
[6],
7711 office2013
->encryptedVerifierHash
[7]);
7713 else if (hash_mode
== 9700)
7715 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7717 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7719 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7720 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7721 byte_swap_32 (salt
.salt_buf
[0]),
7722 byte_swap_32 (salt
.salt_buf
[1]),
7723 byte_swap_32 (salt
.salt_buf
[2]),
7724 byte_swap_32 (salt
.salt_buf
[3]),
7725 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7726 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7727 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7728 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7729 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7730 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7731 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7732 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7734 else if (hash_mode
== 9710)
7736 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7738 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7740 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7741 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7742 byte_swap_32 (salt
.salt_buf
[0]),
7743 byte_swap_32 (salt
.salt_buf
[1]),
7744 byte_swap_32 (salt
.salt_buf
[2]),
7745 byte_swap_32 (salt
.salt_buf
[3]),
7746 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7747 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7748 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7749 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7750 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7751 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7752 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7753 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7755 else if (hash_mode
== 9720)
7757 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7759 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7761 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7763 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7764 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7765 byte_swap_32 (salt
.salt_buf
[0]),
7766 byte_swap_32 (salt
.salt_buf
[1]),
7767 byte_swap_32 (salt
.salt_buf
[2]),
7768 byte_swap_32 (salt
.salt_buf
[3]),
7769 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7770 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7771 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7772 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7773 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7774 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7775 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7776 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7783 else if (hash_mode
== 9800)
7785 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7787 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7789 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7790 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7795 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7796 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7797 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7798 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7799 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7800 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7801 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7802 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7803 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7805 else if (hash_mode
== 9810)
7807 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7809 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7811 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7812 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7817 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7818 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7819 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7820 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7821 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7822 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7823 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7824 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7825 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7827 else if (hash_mode
== 9820)
7829 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7831 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7833 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7835 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7836 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7841 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7842 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7843 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7844 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7845 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7846 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7847 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7848 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7849 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7856 else if (hash_mode
== 10000)
7860 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7862 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7864 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7868 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7869 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7870 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7871 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7872 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7873 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7874 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7875 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7876 digest_buf
[8] = 0; // needed for base64_encode ()
7878 char tmp_buf
[64] = { 0 };
7880 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7884 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7886 else if (hash_mode
== 10100)
7888 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7893 byte_swap_32 (salt
.salt_buf
[0]),
7894 byte_swap_32 (salt
.salt_buf
[1]),
7895 byte_swap_32 (salt
.salt_buf
[2]),
7896 byte_swap_32 (salt
.salt_buf
[3]));
7898 else if (hash_mode
== 10200)
7900 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7902 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7906 char challenge
[100] = { 0 };
7908 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7912 char tmp_buf
[100] = { 0 };
7914 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7915 (char *) cram_md5
->user
,
7921 char response
[100] = { 0 };
7923 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7925 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7927 else if (hash_mode
== 10300)
7929 char tmp_buf
[100] = { 0 };
7931 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7932 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7934 uint tmp_len
= 20 + salt
.salt_len
;
7938 char base64_encoded
[100] = { 0 };
7940 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7942 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7944 else if (hash_mode
== 10400)
7946 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7948 pdf_t
*pdf
= &pdfs
[salt_pos
];
7950 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",
7958 byte_swap_32 (pdf
->id_buf
[0]),
7959 byte_swap_32 (pdf
->id_buf
[1]),
7960 byte_swap_32 (pdf
->id_buf
[2]),
7961 byte_swap_32 (pdf
->id_buf
[3]),
7963 byte_swap_32 (pdf
->u_buf
[0]),
7964 byte_swap_32 (pdf
->u_buf
[1]),
7965 byte_swap_32 (pdf
->u_buf
[2]),
7966 byte_swap_32 (pdf
->u_buf
[3]),
7967 byte_swap_32 (pdf
->u_buf
[4]),
7968 byte_swap_32 (pdf
->u_buf
[5]),
7969 byte_swap_32 (pdf
->u_buf
[6]),
7970 byte_swap_32 (pdf
->u_buf
[7]),
7972 byte_swap_32 (pdf
->o_buf
[0]),
7973 byte_swap_32 (pdf
->o_buf
[1]),
7974 byte_swap_32 (pdf
->o_buf
[2]),
7975 byte_swap_32 (pdf
->o_buf
[3]),
7976 byte_swap_32 (pdf
->o_buf
[4]),
7977 byte_swap_32 (pdf
->o_buf
[5]),
7978 byte_swap_32 (pdf
->o_buf
[6]),
7979 byte_swap_32 (pdf
->o_buf
[7])
7982 else if (hash_mode
== 10410)
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
== 10420)
8022 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8024 pdf_t
*pdf
= &pdfs
[salt_pos
];
8026 u8
*rc4key
= (u8
*) pdf
->rc4key
;
8028 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",
8036 byte_swap_32 (pdf
->id_buf
[0]),
8037 byte_swap_32 (pdf
->id_buf
[1]),
8038 byte_swap_32 (pdf
->id_buf
[2]),
8039 byte_swap_32 (pdf
->id_buf
[3]),
8041 byte_swap_32 (pdf
->u_buf
[0]),
8042 byte_swap_32 (pdf
->u_buf
[1]),
8043 byte_swap_32 (pdf
->u_buf
[2]),
8044 byte_swap_32 (pdf
->u_buf
[3]),
8045 byte_swap_32 (pdf
->u_buf
[4]),
8046 byte_swap_32 (pdf
->u_buf
[5]),
8047 byte_swap_32 (pdf
->u_buf
[6]),
8048 byte_swap_32 (pdf
->u_buf
[7]),
8050 byte_swap_32 (pdf
->o_buf
[0]),
8051 byte_swap_32 (pdf
->o_buf
[1]),
8052 byte_swap_32 (pdf
->o_buf
[2]),
8053 byte_swap_32 (pdf
->o_buf
[3]),
8054 byte_swap_32 (pdf
->o_buf
[4]),
8055 byte_swap_32 (pdf
->o_buf
[5]),
8056 byte_swap_32 (pdf
->o_buf
[6]),
8057 byte_swap_32 (pdf
->o_buf
[7]),
8065 else if (hash_mode
== 10500)
8067 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8069 pdf_t
*pdf
= &pdfs
[salt_pos
];
8071 if (pdf
->id_len
== 32)
8073 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",
8081 byte_swap_32 (pdf
->id_buf
[0]),
8082 byte_swap_32 (pdf
->id_buf
[1]),
8083 byte_swap_32 (pdf
->id_buf
[2]),
8084 byte_swap_32 (pdf
->id_buf
[3]),
8085 byte_swap_32 (pdf
->id_buf
[4]),
8086 byte_swap_32 (pdf
->id_buf
[5]),
8087 byte_swap_32 (pdf
->id_buf
[6]),
8088 byte_swap_32 (pdf
->id_buf
[7]),
8090 byte_swap_32 (pdf
->u_buf
[0]),
8091 byte_swap_32 (pdf
->u_buf
[1]),
8092 byte_swap_32 (pdf
->u_buf
[2]),
8093 byte_swap_32 (pdf
->u_buf
[3]),
8094 byte_swap_32 (pdf
->u_buf
[4]),
8095 byte_swap_32 (pdf
->u_buf
[5]),
8096 byte_swap_32 (pdf
->u_buf
[6]),
8097 byte_swap_32 (pdf
->u_buf
[7]),
8099 byte_swap_32 (pdf
->o_buf
[0]),
8100 byte_swap_32 (pdf
->o_buf
[1]),
8101 byte_swap_32 (pdf
->o_buf
[2]),
8102 byte_swap_32 (pdf
->o_buf
[3]),
8103 byte_swap_32 (pdf
->o_buf
[4]),
8104 byte_swap_32 (pdf
->o_buf
[5]),
8105 byte_swap_32 (pdf
->o_buf
[6]),
8106 byte_swap_32 (pdf
->o_buf
[7])
8111 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",
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]),
8124 byte_swap_32 (pdf
->u_buf
[0]),
8125 byte_swap_32 (pdf
->u_buf
[1]),
8126 byte_swap_32 (pdf
->u_buf
[2]),
8127 byte_swap_32 (pdf
->u_buf
[3]),
8128 byte_swap_32 (pdf
->u_buf
[4]),
8129 byte_swap_32 (pdf
->u_buf
[5]),
8130 byte_swap_32 (pdf
->u_buf
[6]),
8131 byte_swap_32 (pdf
->u_buf
[7]),
8133 byte_swap_32 (pdf
->o_buf
[0]),
8134 byte_swap_32 (pdf
->o_buf
[1]),
8135 byte_swap_32 (pdf
->o_buf
[2]),
8136 byte_swap_32 (pdf
->o_buf
[3]),
8137 byte_swap_32 (pdf
->o_buf
[4]),
8138 byte_swap_32 (pdf
->o_buf
[5]),
8139 byte_swap_32 (pdf
->o_buf
[6]),
8140 byte_swap_32 (pdf
->o_buf
[7])
8144 else if (hash_mode
== 10600)
8146 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8148 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8149 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8151 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8153 else if (hash_mode
== 10700)
8155 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8157 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8158 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8160 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8162 else if (hash_mode
== 10900)
8164 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8166 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8167 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8169 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8171 else if (hash_mode
== 11100)
8173 u32 salt_challenge
= salt
.salt_buf
[0];
8175 salt_challenge
= byte_swap_32 (salt_challenge
);
8177 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
8179 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
8180 SIGNATURE_POSTGRESQL_AUTH
,
8188 else if (hash_mode
== 11200)
8190 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
8191 SIGNATURE_MYSQL_AUTH
,
8192 (unsigned char *) salt
.salt_buf
,
8199 else if (hash_mode
== 11300)
8201 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
8203 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
8205 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
8206 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
8207 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
8209 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
8210 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
8211 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
8213 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
8215 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
8217 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
8220 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
8222 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
8224 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8227 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8229 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8231 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8234 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8235 SIGNATURE_BITCOIN_WALLET
,
8239 (unsigned char *) salt
.salt_buf
,
8247 free (cry_master_buf
);
8249 free (public_key_buf
);
8251 else if (hash_mode
== 11400)
8253 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8255 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8256 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8258 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8260 else if (hash_mode
== 11600)
8262 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8264 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8266 const uint data_len
= seven_zip
->data_len
;
8268 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8270 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8272 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8274 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8277 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8278 SIGNATURE_SEVEN_ZIP
,
8282 (char *) seven_zip
->salt_buf
,
8284 seven_zip
->iv_buf
[0],
8285 seven_zip
->iv_buf
[1],
8286 seven_zip
->iv_buf
[2],
8287 seven_zip
->iv_buf
[3],
8289 seven_zip
->data_len
,
8290 seven_zip
->unpack_size
,
8295 else if (hash_mode
== 11700)
8297 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8307 else if (hash_mode
== 11800)
8309 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8327 else if (hash_mode
== 11900)
8329 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8331 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8332 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8334 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8336 else if (hash_mode
== 12000)
8338 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8340 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8341 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8343 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8345 else if (hash_mode
== 12100)
8347 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8349 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8350 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8352 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8354 else if (hash_mode
== 12200)
8356 uint
*ptr_digest
= digest_buf
;
8357 uint
*ptr_salt
= salt
.salt_buf
;
8359 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8366 else if (hash_mode
== 12300)
8368 uint
*ptr_digest
= digest_buf
;
8369 uint
*ptr_salt
= salt
.salt_buf
;
8371 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",
8372 ptr_digest
[ 0], ptr_digest
[ 1],
8373 ptr_digest
[ 2], ptr_digest
[ 3],
8374 ptr_digest
[ 4], ptr_digest
[ 5],
8375 ptr_digest
[ 6], ptr_digest
[ 7],
8376 ptr_digest
[ 8], ptr_digest
[ 9],
8377 ptr_digest
[10], ptr_digest
[11],
8378 ptr_digest
[12], ptr_digest
[13],
8379 ptr_digest
[14], ptr_digest
[15],
8385 else if (hash_mode
== 12400)
8387 // encode iteration count
8389 char salt_iter
[5] = { 0 };
8391 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8392 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8393 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8394 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8399 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8400 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8401 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8402 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8407 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8409 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8410 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8412 memcpy (tmp_buf
, digest_buf
, 8);
8414 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8418 // fill the resulting buffer
8420 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8422 else if (hash_mode
== 12500)
8424 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8426 byte_swap_32 (salt
.salt_buf
[0]),
8427 byte_swap_32 (salt
.salt_buf
[1]),
8433 else if (hash_mode
== 12600)
8435 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8436 digest_buf
[0] + salt
.salt_buf_pc
[0],
8437 digest_buf
[1] + salt
.salt_buf_pc
[1],
8438 digest_buf
[2] + salt
.salt_buf_pc
[2],
8439 digest_buf
[3] + salt
.salt_buf_pc
[3],
8440 digest_buf
[4] + salt
.salt_buf_pc
[4],
8441 digest_buf
[5] + salt
.salt_buf_pc
[5],
8442 digest_buf
[6] + salt
.salt_buf_pc
[6],
8443 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8445 else if (hash_mode
== 12700)
8447 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8449 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8450 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8452 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8454 else if (hash_mode
== 12800)
8456 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8458 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",
8471 byte_swap_32 (digest_buf
[0]),
8472 byte_swap_32 (digest_buf
[1]),
8473 byte_swap_32 (digest_buf
[2]),
8474 byte_swap_32 (digest_buf
[3]),
8475 byte_swap_32 (digest_buf
[4]),
8476 byte_swap_32 (digest_buf
[5]),
8477 byte_swap_32 (digest_buf
[6]),
8478 byte_swap_32 (digest_buf
[7])
8481 else if (hash_mode
== 12900)
8483 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",
8492 byte_swap_32 (digest_buf
[0]),
8493 byte_swap_32 (digest_buf
[1]),
8494 byte_swap_32 (digest_buf
[2]),
8495 byte_swap_32 (digest_buf
[3]),
8496 byte_swap_32 (digest_buf
[4]),
8497 byte_swap_32 (digest_buf
[5]),
8498 byte_swap_32 (digest_buf
[6]),
8499 byte_swap_32 (digest_buf
[7]),
8506 else if (hash_mode
== 13000)
8508 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8510 rar5_t
*rar5
= &rar5s
[salt_pos
];
8512 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8522 byte_swap_32 (digest_buf
[0]),
8523 byte_swap_32 (digest_buf
[1])
8526 else if (hash_mode
== 13100)
8528 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8530 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8532 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8533 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8535 char data
[2560 * 4 * 2] = { 0 };
8537 char *ptr_data
= data
;
8539 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8540 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8545 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8546 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8548 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8550 (char *) krb5tgs
->account_info
,
8554 else if (hash_mode
== 13200)
8556 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8570 else if (hash_mode
== 13300)
8572 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8573 SIGNATURE_AXCRYPT_SHA1
,
8579 else if (hash_mode
== 13400)
8581 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8583 keepass_t
*keepass
= &keepasss
[salt_pos
];
8585 u32 version
= (u32
) keepass
->version
;
8586 u32 rounds
= salt
.salt_iter
;
8587 u32 algorithm
= (u32
) keepass
->algorithm
;
8588 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8590 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8591 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8592 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8593 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8594 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8596 /* specific to version 1 */
8600 /* specific to version 2 */
8601 u32 expected_bytes_len
;
8602 u32
*ptr_expected_bytes
;
8604 u32 final_random_seed_len
;
8605 u32 transf_random_seed_len
;
8607 u32 contents_hash_len
;
8609 transf_random_seed_len
= 8;
8611 contents_hash_len
= 8;
8612 final_random_seed_len
= 8;
8615 final_random_seed_len
= 4;
8617 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8623 char *ptr_data
= out_buf
;
8625 ptr_data
+= strlen(out_buf
);
8630 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8631 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8636 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8637 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8642 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8643 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8650 contents_len
= (u32
) keepass
->contents_len
;
8651 ptr_contents
= (u32
*) keepass
->contents
;
8653 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8654 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8666 char ptr_contents_len
[10] = { 0 };
8668 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8670 sprintf (ptr_data
, "%d", contents_len
);
8672 ptr_data
+= strlen(ptr_contents_len
);
8677 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8678 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8680 else if (version
== 2)
8682 expected_bytes_len
= 8;
8683 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8685 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8686 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8691 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8692 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8706 sprintf (ptr_data
, "%d", keyfile_len
);
8713 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8714 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8717 else if (hash_mode
== 13500)
8719 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8721 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8723 const u32 salt_len
= (pstoken
->salt_len
> 512) ? 512 : pstoken
->salt_len
;
8725 char pstoken_tmp
[1024 + 1] = { 0 };
8727 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8729 const u8
*ptr
= (const u8
*) pstoken
->salt_buf
;
8731 sprintf (pstoken_tmp
+ j
, "%02x", ptr
[i
]);
8734 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8742 else if (hash_mode
== 13600)
8744 zip2_t
*zip2s
= (zip2_t
*) data
.esalts_buf
;
8746 zip2_t
*zip2
= &zip2s
[salt_pos
];
8748 const u32 salt_len
= zip2
->salt_len
;
8750 char salt_tmp
[32 + 1] = { 0 };
8752 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8754 const u8
*ptr
= (const u8
*) zip2
->salt_buf
;
8756 sprintf (salt_tmp
+ j
, "%02x", ptr
[i
]);
8759 const u32 data_len
= zip2
->data_len
;
8761 char data_tmp
[8192 + 1] = { 0 };
8763 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8765 const u8
*ptr
= (const u8
*) zip2
->data_buf
;
8767 sprintf (data_tmp
+ j
, "%02x", ptr
[i
]);
8770 const u32 auth_len
= zip2
->auth_len
;
8772 char auth_tmp
[20 + 1] = { 0 };
8774 for (uint i
= 0, j
= 0; i
< auth_len
; i
+= 1, j
+= 2)
8776 const u8
*ptr
= (const u8
*) zip2
->auth_buf
;
8778 sprintf (auth_tmp
+ j
, "%02x", ptr
[i
]);
8781 snprintf (out_buf
, 255, "%s*%u*%u*%u*%s*%x*%u*%s*%s*%s",
8782 SIGNATURE_ZIP2_START
,
8788 zip2
->compress_length
,
8791 SIGNATURE_ZIP2_STOP
);
8793 else if ((hash_mode
>= 13700) && (hash_mode
<= 13799))
8795 snprintf (out_buf
, len
-1, "%s", hashfile
);
8799 if (hash_type
== HASH_TYPE_MD4
)
8801 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8807 else if (hash_type
== HASH_TYPE_MD5
)
8809 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8815 else if (hash_type
== HASH_TYPE_SHA1
)
8817 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8824 else if (hash_type
== HASH_TYPE_SHA256
)
8826 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8836 else if (hash_type
== HASH_TYPE_SHA384
)
8838 uint
*ptr
= digest_buf
;
8840 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8848 else if (hash_type
== HASH_TYPE_SHA512
)
8850 uint
*ptr
= digest_buf
;
8852 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8862 else if (hash_type
== HASH_TYPE_LM
)
8864 snprintf (out_buf
, len
-1, "%08x%08x",
8868 else if (hash_type
== HASH_TYPE_ORACLEH
)
8870 snprintf (out_buf
, len
-1, "%08X%08X",
8874 else if (hash_type
== HASH_TYPE_BCRYPT
)
8876 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8877 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8879 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8881 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8883 else if (hash_type
== HASH_TYPE_KECCAK
)
8885 uint
*ptr
= digest_buf
;
8887 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",
8915 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8917 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8919 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8926 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8928 digest_buf
[ 0] = digest_buf
[ 0];
8929 digest_buf
[ 1] = digest_buf
[ 1];
8930 digest_buf
[ 2] = digest_buf
[ 2];
8931 digest_buf
[ 3] = digest_buf
[ 3];
8932 digest_buf
[ 4] = digest_buf
[ 4];
8933 digest_buf
[ 5] = digest_buf
[ 5];
8934 digest_buf
[ 6] = digest_buf
[ 6];
8935 digest_buf
[ 7] = digest_buf
[ 7];
8936 digest_buf
[ 8] = digest_buf
[ 8];
8937 digest_buf
[ 9] = digest_buf
[ 9];
8938 digest_buf
[10] = digest_buf
[10];
8939 digest_buf
[11] = digest_buf
[11];
8940 digest_buf
[12] = digest_buf
[12];
8941 digest_buf
[13] = digest_buf
[13];
8942 digest_buf
[14] = digest_buf
[14];
8943 digest_buf
[15] = digest_buf
[15];
8945 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8963 else if (hash_type
== HASH_TYPE_GOST
)
8965 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8975 else if (hash_type
== HASH_TYPE_MYSQL
)
8977 snprintf (out_buf
, len
-1, "%08x%08x",
8981 else if (hash_type
== HASH_TYPE_LOTUS5
)
8983 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8989 else if (hash_type
== HASH_TYPE_LOTUS6
)
8991 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8992 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8993 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8994 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8996 char buf
[16] = { 0 };
8998 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8999 memcpy (buf
+ 5, digest_buf
, 9);
9003 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
9005 tmp_buf
[18] = salt
.salt_buf_pc
[7];
9008 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
9010 else if (hash_type
== HASH_TYPE_LOTUS8
)
9012 char buf
[52] = { 0 };
9016 memcpy (buf
+ 0, salt
.salt_buf
, 16);
9022 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
9026 buf
[26] = salt
.salt_buf_pc
[0];
9027 buf
[27] = salt
.salt_buf_pc
[1];
9031 memcpy (buf
+ 28, digest_buf
, 8);
9033 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
9037 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
9039 else if (hash_type
== HASH_TYPE_CRC32
)
9041 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
9045 if (salt_type
== SALT_TYPE_INTERN
)
9047 size_t pos
= strlen (out_buf
);
9049 out_buf
[pos
] = data
.separator
;
9051 char *ptr
= (char *) salt
.salt_buf
;
9053 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
9055 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
9059 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
9061 memset (hccap
, 0, sizeof (hccap_t
));
9063 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
9065 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
9067 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
9068 wpa_t
*wpa
= &wpas
[salt_pos
];
9070 hccap
->keyver
= wpa
->keyver
;
9072 hccap
->eapol_size
= wpa
->eapol_size
;
9074 if (wpa
->keyver
!= 1)
9076 uint eapol_tmp
[64] = { 0 };
9078 for (uint i
= 0; i
< 64; i
++)
9080 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9083 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
9087 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
9090 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
9091 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
9092 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
9093 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
9095 char *digests_buf_ptr
= (char *) data
.digests_buf
;
9097 uint dgst_size
= data
.dgst_size
;
9099 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
9101 if (wpa
->keyver
!= 1)
9103 uint digest_tmp
[4] = { 0 };
9105 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
9106 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
9107 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
9108 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
9110 memcpy (hccap
->keymic
, digest_tmp
, 16);
9114 memcpy (hccap
->keymic
, digest_ptr
, 16);
9118 void SuspendThreads ()
9120 if (data
.devices_status
== STATUS_RUNNING
)
9122 hc_timer_set (&data
.timer_paused
);
9124 data
.devices_status
= STATUS_PAUSED
;
9126 log_info ("Paused");
9130 void ResumeThreads ()
9132 if (data
.devices_status
== STATUS_PAUSED
)
9136 hc_timer_get (data
.timer_paused
, ms_paused
);
9138 data
.ms_paused
+= ms_paused
;
9140 data
.devices_status
= STATUS_RUNNING
;
9142 log_info ("Resumed");
9148 if (data
.devices_status
!= STATUS_RUNNING
) return;
9150 data
.devices_status
= STATUS_BYPASS
;
9152 log_info ("Next dictionary / mask in queue selected, bypassing current one");
9155 void stop_at_checkpoint ()
9157 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9159 if (data
.devices_status
!= STATUS_RUNNING
) return;
9162 // this feature only makes sense if --restore-disable was not specified
9164 if (data
.restore_disable
== 1)
9166 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
9171 // check if monitoring of Restore Point updates should be enabled or disabled
9173 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9175 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
9177 // save the current restore point value
9179 data
.checkpoint_cur_words
= get_lowest_words_done ();
9181 log_info ("Checkpoint enabled: will quit at next Restore Point update");
9185 data
.devices_status
= STATUS_RUNNING
;
9187 // reset the global value for checkpoint checks
9189 data
.checkpoint_cur_words
= 0;
9191 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
9197 if (data
.devices_status
== STATUS_INIT
) return;
9198 if (data
.devices_status
== STATUS_STARTING
) return;
9200 data
.devices_status
= STATUS_ABORTED
;
9205 if (data
.devices_status
== STATUS_INIT
) return;
9206 if (data
.devices_status
== STATUS_STARTING
) return;
9208 data
.devices_status
= STATUS_QUIT
;
9211 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
9213 FILE *fp
= fopen (kernel_file
, "rb");
9219 memset (&st
, 0, sizeof (st
));
9221 stat (kernel_file
, &st
);
9223 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
9225 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
9227 if (num_read
!= (size_t) st
.st_size
)
9229 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9236 buf
[st
.st_size
] = 0;
9238 for (int i
= 0; i
< num_devices
; i
++)
9240 kernel_lengths
[i
] = (size_t) st
.st_size
;
9242 kernel_sources
[i
] = buf
;
9247 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9255 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
9257 if (binary_size
> 0)
9259 FILE *fp
= fopen (dst
, "wb");
9262 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
9273 restore_data_t
*init_restore (int argc
, char **argv
)
9275 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
9277 if (data
.restore_disable
== 0)
9279 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
9283 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
9287 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
9296 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9298 int pidbin_len
= -1;
9301 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9303 FILE *fd
= fopen (pidbin
, "rb");
9307 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9309 pidbin
[pidbin_len
] = 0;
9313 char *argv0_r
= strrchr (argv
[0], '/');
9315 char *pidbin_r
= strrchr (pidbin
, '/');
9317 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9319 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9321 if (strcmp (argv0_r
, pidbin_r
) == 0)
9323 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
9330 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9332 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9334 int pidbin2_len
= -1;
9336 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9337 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9339 pidbin
[pidbin_len
] = 0;
9340 pidbin2
[pidbin2_len
] = 0;
9344 if (strcmp (pidbin
, pidbin2
) == 0)
9346 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9359 if (rd
->version_bin
< RESTORE_MIN
)
9361 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9368 memset (rd
, 0, sizeof (restore_data_t
));
9370 rd
->version_bin
= VERSION_BIN
;
9373 rd
->pid
= getpid ();
9375 rd
->pid
= GetCurrentProcessId ();
9378 if (getcwd (rd
->cwd
, 255) == NULL
)
9391 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9393 FILE *fp
= fopen (eff_restore_file
, "rb");
9397 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
9402 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9404 log_error ("ERROR: cannot read %s", eff_restore_file
);
9409 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9411 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9413 for (uint i
= 0; i
< rd
->argc
; i
++)
9415 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9417 log_error ("ERROR: cannot read %s", eff_restore_file
);
9422 size_t len
= strlen (buf
);
9424 if (len
) buf
[len
- 1] = 0;
9426 rd
->argv
[i
] = mystrdup (buf
);
9433 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9435 if (chdir (rd
->cwd
))
9437 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9438 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9439 " https://github.com/philsmd/analyze_hc_restore\n"
9440 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9446 u64
get_lowest_words_done ()
9450 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9452 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9454 if (device_param
->skipped
) continue;
9456 const u64 words_done
= device_param
->words_done
;
9458 if (words_done
< words_cur
) words_cur
= words_done
;
9461 // It's possible that a device's workload isn't finished right after a restore-case.
9462 // In that case, this function would return 0 and overwrite the real restore point
9463 // There's also data.words_cur which is set to rd->words_cur but it changes while
9464 // the attack is running therefore we should stick to rd->words_cur.
9465 // Note that -s influences rd->words_cur we should keep a close look on that.
9467 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9472 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9474 u64 words_cur
= get_lowest_words_done ();
9476 rd
->words_cur
= words_cur
;
9478 FILE *fp
= fopen (new_restore_file
, "wb");
9482 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9487 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9489 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9494 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9496 for (uint i
= 0; i
< rd
->argc
; i
++)
9498 fprintf (fp
, "%s", rd
->argv
[i
]);
9504 fsync (fileno (fp
));
9509 void cycle_restore ()
9511 const char *eff_restore_file
= data
.eff_restore_file
;
9512 const char *new_restore_file
= data
.new_restore_file
;
9514 restore_data_t
*rd
= data
.rd
;
9516 write_restore (new_restore_file
, rd
);
9520 memset (&st
, 0, sizeof(st
));
9522 if (stat (eff_restore_file
, &st
) == 0)
9524 if (unlink (eff_restore_file
))
9526 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9530 if (rename (new_restore_file
, eff_restore_file
))
9532 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9536 void check_checkpoint ()
9538 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9540 u64 words_cur
= get_lowest_words_done ();
9542 if (words_cur
!= data
.checkpoint_cur_words
)
9552 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9556 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9558 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9560 myfree (alias
->device_name
);
9561 myfree (alias
->alias_name
);
9564 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9566 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9568 myfree (entry
->device_name
);
9571 myfree (tuning_db
->alias_buf
);
9572 myfree (tuning_db
->entry_buf
);
9577 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9579 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9581 int num_lines
= count_lines (fp
);
9583 // a bit over-allocated
9585 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9586 tuning_db
->alias_cnt
= 0;
9588 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9589 tuning_db
->entry_cnt
= 0;
9594 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9596 FILE *fp
= fopen (tuning_db_file
, "rb");
9600 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9605 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9611 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9615 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9617 if (line_buf
== NULL
) break;
9621 const int line_len
= in_superchop (line_buf
);
9623 if (line_len
== 0) continue;
9625 if (line_buf
[0] == '#') continue;
9629 char *token_ptr
[7] = { NULL
};
9633 char *next
= strtok (line_buf
, "\t ");
9635 token_ptr
[token_cnt
] = next
;
9639 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9641 token_ptr
[token_cnt
] = next
;
9648 char *device_name
= token_ptr
[0];
9649 char *alias_name
= token_ptr
[1];
9651 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9653 alias
->device_name
= mystrdup (device_name
);
9654 alias
->alias_name
= mystrdup (alias_name
);
9656 tuning_db
->alias_cnt
++;
9658 else if (token_cnt
== 6)
9660 if ((token_ptr
[1][0] != '0') &&
9661 (token_ptr
[1][0] != '1') &&
9662 (token_ptr
[1][0] != '3') &&
9663 (token_ptr
[1][0] != '*'))
9665 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9670 if ((token_ptr
[3][0] != '1') &&
9671 (token_ptr
[3][0] != '2') &&
9672 (token_ptr
[3][0] != '4') &&
9673 (token_ptr
[3][0] != '8') &&
9674 (token_ptr
[3][0] != 'N'))
9676 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9681 char *device_name
= token_ptr
[0];
9683 int attack_mode
= -1;
9685 int vector_width
= -1;
9686 int kernel_accel
= -1;
9687 int kernel_loops
= -1;
9689 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9690 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9691 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9693 if (token_ptr
[4][0] != 'A')
9695 kernel_accel
= atoi (token_ptr
[4]);
9697 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9699 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9709 if (token_ptr
[5][0] != 'A')
9711 kernel_loops
= atoi (token_ptr
[5]);
9713 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9715 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9725 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9727 entry
->device_name
= mystrdup (device_name
);
9728 entry
->attack_mode
= attack_mode
;
9729 entry
->hash_type
= hash_type
;
9730 entry
->vector_width
= vector_width
;
9731 entry
->kernel_accel
= kernel_accel
;
9732 entry
->kernel_loops
= kernel_loops
;
9734 tuning_db
->entry_cnt
++;
9738 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9748 // todo: print loaded 'cnt' message
9750 // sort the database
9752 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9753 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9758 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9760 static tuning_db_entry_t s
;
9762 // first we need to convert all spaces in the device_name to underscore
9764 char *device_name_nospace
= strdup (device_param
->device_name
);
9766 int device_name_length
= strlen (device_name_nospace
);
9770 for (i
= 0; i
< device_name_length
; i
++)
9772 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9775 // find out if there's an alias configured
9777 tuning_db_alias_t a
;
9779 a
.device_name
= device_name_nospace
;
9781 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
);
9783 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9785 // attack-mode 6 and 7 are attack-mode 1 basically
9787 if (attack_mode
== 6) attack_mode
= 1;
9788 if (attack_mode
== 7) attack_mode
= 1;
9790 // bsearch is not ideal but fast enough
9792 s
.device_name
= device_name_nospace
;
9793 s
.attack_mode
= attack_mode
;
9794 s
.hash_type
= hash_type
;
9796 tuning_db_entry_t
*entry
= NULL
;
9798 // this will produce all 2^3 combinations required
9800 for (i
= 0; i
< 8; i
++)
9802 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9803 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9804 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9806 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9808 if (entry
!= NULL
) break;
9810 // in non-wildcard mode do some additional checks:
9814 // in case we have an alias-name
9816 if (alias_name
!= NULL
)
9818 s
.device_name
= alias_name
;
9820 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9822 if (entry
!= NULL
) break;
9825 // or by device type
9827 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9829 s
.device_name
= "DEVICE_TYPE_CPU";
9831 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9833 s
.device_name
= "DEVICE_TYPE_GPU";
9835 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9837 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9840 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9842 if (entry
!= NULL
) break;
9846 // free converted device_name
9848 myfree (device_name_nospace
);
9857 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9859 u8 tmp
[256] = { 0 };
9861 if (salt_len
> sizeof (tmp
))
9866 memcpy (tmp
, in
, salt_len
);
9868 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9870 if ((salt_len
% 2) == 0)
9872 u32 new_salt_len
= salt_len
/ 2;
9874 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9879 tmp
[i
] = hex_convert (p1
) << 0;
9880 tmp
[i
] |= hex_convert (p0
) << 4;
9883 salt_len
= new_salt_len
;
9890 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9892 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9895 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9897 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9901 u32
*tmp_uint
= (u32
*) tmp
;
9903 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9904 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9905 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9906 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9907 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9908 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9909 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9910 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9911 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9912 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9914 salt_len
= salt_len
* 2;
9922 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9924 lowercase (tmp
, salt_len
);
9927 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9929 uppercase (tmp
, salt_len
);
9934 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9939 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9944 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9946 u32
*tmp_uint
= (uint
*) tmp
;
9952 for (u32 i
= 0; i
< max
; i
++)
9954 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9957 // Important: we may need to increase the length of memcpy since
9958 // we don't want to "loose" some swapped bytes (could happen if
9959 // they do not perfectly fit in the 4-byte blocks)
9960 // Memcpy does always copy the bytes in the BE order, but since
9961 // we swapped them, some important bytes could be in positions
9962 // we normally skip with the original len
9964 if (len
% 4) len
+= 4 - (len
% 4);
9967 memcpy (out
, tmp
, len
);
9972 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9974 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9976 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9978 u32
*digest
= (u32
*) hash_buf
->digest
;
9980 salt_t
*salt
= hash_buf
->salt
;
9982 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9984 char *iter_pos
= input_buf
+ 4;
9986 salt
->salt_iter
= 1 << atoi (iter_pos
);
9988 char *salt_pos
= strchr (iter_pos
, '$');
9990 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9996 salt
->salt_len
= salt_len
;
9998 u8 tmp_buf
[100] = { 0 };
10000 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
10002 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10004 memcpy (salt_buf_ptr
, tmp_buf
, 16);
10006 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
10007 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
10008 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
10009 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
10011 char *hash_pos
= salt_pos
+ 22;
10013 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10015 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
10017 memcpy (digest
, tmp_buf
, 24);
10019 digest
[0] = byte_swap_32 (digest
[0]);
10020 digest
[1] = byte_swap_32 (digest
[1]);
10021 digest
[2] = byte_swap_32 (digest
[2]);
10022 digest
[3] = byte_swap_32 (digest
[3]);
10023 digest
[4] = byte_swap_32 (digest
[4]);
10024 digest
[5] = byte_swap_32 (digest
[5]);
10026 digest
[5] &= ~0xff; // its just 23 not 24 !
10028 return (PARSER_OK
);
10031 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10033 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
10035 u32
*digest
= (u32
*) hash_buf
->digest
;
10037 u8 tmp_buf
[100] = { 0 };
10039 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
10041 memcpy (digest
, tmp_buf
, 32);
10043 digest
[0] = byte_swap_32 (digest
[0]);
10044 digest
[1] = byte_swap_32 (digest
[1]);
10045 digest
[2] = byte_swap_32 (digest
[2]);
10046 digest
[3] = byte_swap_32 (digest
[3]);
10047 digest
[4] = byte_swap_32 (digest
[4]);
10048 digest
[5] = byte_swap_32 (digest
[5]);
10049 digest
[6] = byte_swap_32 (digest
[6]);
10050 digest
[7] = byte_swap_32 (digest
[7]);
10052 digest
[0] -= SHA256M_A
;
10053 digest
[1] -= SHA256M_B
;
10054 digest
[2] -= SHA256M_C
;
10055 digest
[3] -= SHA256M_D
;
10056 digest
[4] -= SHA256M_E
;
10057 digest
[5] -= SHA256M_F
;
10058 digest
[6] -= SHA256M_G
;
10059 digest
[7] -= SHA256M_H
;
10061 return (PARSER_OK
);
10064 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10066 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
10068 u32
*digest
= (u32
*) hash_buf
->digest
;
10070 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10071 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10073 digest
[0] = byte_swap_32 (digest
[0]);
10074 digest
[1] = byte_swap_32 (digest
[1]);
10078 IP (digest
[0], digest
[1], tt
);
10080 digest
[0] = digest
[0];
10081 digest
[1] = digest
[1];
10085 return (PARSER_OK
);
10088 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10090 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
10092 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
10094 u32
*digest
= (u32
*) hash_buf
->digest
;
10096 salt_t
*salt
= hash_buf
->salt
;
10098 char *hash_pos
= input_buf
+ 10;
10100 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10101 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10102 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10103 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10104 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10106 digest
[0] -= SHA1M_A
;
10107 digest
[1] -= SHA1M_B
;
10108 digest
[2] -= SHA1M_C
;
10109 digest
[3] -= SHA1M_D
;
10110 digest
[4] -= SHA1M_E
;
10112 uint salt_len
= 10;
10114 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10116 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10118 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10120 salt
->salt_len
= salt_len
;
10122 return (PARSER_OK
);
10125 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10127 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
10129 u32
*digest
= (u32
*) hash_buf
->digest
;
10131 salt_t
*salt
= hash_buf
->salt
;
10133 char *hash_pos
= input_buf
+ 8;
10135 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10136 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10137 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10138 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10139 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10141 digest
[0] -= SHA1M_A
;
10142 digest
[1] -= SHA1M_B
;
10143 digest
[2] -= SHA1M_C
;
10144 digest
[3] -= SHA1M_D
;
10145 digest
[4] -= SHA1M_E
;
10149 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10151 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10153 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10155 salt
->salt_len
= salt_len
;
10157 return (PARSER_OK
);
10160 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10162 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
10164 u64
*digest
= (u64
*) hash_buf
->digest
;
10166 salt_t
*salt
= hash_buf
->salt
;
10168 char *hash_pos
= input_buf
+ 8;
10170 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
10171 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
10172 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
10173 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
10174 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
10175 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
10176 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
10177 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
10179 digest
[0] -= SHA512M_A
;
10180 digest
[1] -= SHA512M_B
;
10181 digest
[2] -= SHA512M_C
;
10182 digest
[3] -= SHA512M_D
;
10183 digest
[4] -= SHA512M_E
;
10184 digest
[5] -= SHA512M_F
;
10185 digest
[6] -= SHA512M_G
;
10186 digest
[7] -= SHA512M_H
;
10190 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10192 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10194 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10196 salt
->salt_len
= salt_len
;
10198 return (PARSER_OK
);
10201 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10203 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10205 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
10209 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
10212 u32
*digest
= (u32
*) hash_buf
->digest
;
10214 salt_t
*salt
= hash_buf
->salt
;
10216 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10217 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10218 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10219 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10221 digest
[0] = byte_swap_32 (digest
[0]);
10222 digest
[1] = byte_swap_32 (digest
[1]);
10223 digest
[2] = byte_swap_32 (digest
[2]);
10224 digest
[3] = byte_swap_32 (digest
[3]);
10226 digest
[0] -= MD5M_A
;
10227 digest
[1] -= MD5M_B
;
10228 digest
[2] -= MD5M_C
;
10229 digest
[3] -= MD5M_D
;
10231 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10233 uint salt_len
= input_len
- 32 - 1;
10235 char *salt_buf
= input_buf
+ 32 + 1;
10237 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10239 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10241 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10243 salt
->salt_len
= salt_len
;
10245 return (PARSER_OK
);
10248 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10250 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10252 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
10256 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
10261 char clean_input_buf
[32] = { 0 };
10263 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
10264 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
10266 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
10270 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
10276 clean_input_buf
[k
] = input_buf
[i
];
10284 u32
*digest
= (u32
*) hash_buf
->digest
;
10286 salt_t
*salt
= hash_buf
->salt
;
10288 u32 a
, b
, c
, d
, e
, f
;
10290 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10291 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10292 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10293 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10294 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10295 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10297 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10298 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10300 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10301 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10302 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10303 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10304 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10305 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10307 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10308 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10310 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10311 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10312 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10313 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10314 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10315 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10317 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10318 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10320 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10321 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10322 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10323 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10324 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10325 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10327 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10328 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10330 digest
[0] = byte_swap_32 (digest
[0]);
10331 digest
[1] = byte_swap_32 (digest
[1]);
10332 digest
[2] = byte_swap_32 (digest
[2]);
10333 digest
[3] = byte_swap_32 (digest
[3]);
10335 digest
[0] -= MD5M_A
;
10336 digest
[1] -= MD5M_B
;
10337 digest
[2] -= MD5M_C
;
10338 digest
[3] -= MD5M_D
;
10340 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10342 uint salt_len
= input_len
- 30 - 1;
10344 char *salt_buf
= input_buf
+ 30 + 1;
10346 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10348 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10350 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10351 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10353 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10355 salt
->salt_len
= salt_len
;
10357 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10359 salt
->salt_len
+= 22;
10361 return (PARSER_OK
);
10364 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10366 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10368 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10372 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10375 u32
*digest
= (u32
*) hash_buf
->digest
;
10377 salt_t
*salt
= hash_buf
->salt
;
10379 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10380 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10381 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10382 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10383 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10385 digest
[0] -= SHA1M_A
;
10386 digest
[1] -= SHA1M_B
;
10387 digest
[2] -= SHA1M_C
;
10388 digest
[3] -= SHA1M_D
;
10389 digest
[4] -= SHA1M_E
;
10391 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10393 uint salt_len
= input_len
- 40 - 1;
10395 char *salt_buf
= input_buf
+ 40 + 1;
10397 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10399 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10401 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10403 salt
->salt_len
= salt_len
;
10405 return (PARSER_OK
);
10408 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10410 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10412 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10416 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10419 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10421 char *iter_pos
= input_buf
+ 6;
10423 salt_t
*salt
= hash_buf
->salt
;
10425 uint iter
= atoi (iter_pos
);
10429 iter
= ROUNDS_DCC2
;
10432 salt
->salt_iter
= iter
- 1;
10434 char *salt_pos
= strchr (iter_pos
, '#');
10436 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10440 char *digest_pos
= strchr (salt_pos
, '#');
10442 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10446 uint salt_len
= digest_pos
- salt_pos
- 1;
10448 u32
*digest
= (u32
*) hash_buf
->digest
;
10450 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10451 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10452 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10453 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10455 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10457 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10459 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10461 salt
->salt_len
= salt_len
;
10463 return (PARSER_OK
);
10466 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10468 u32
*digest
= (u32
*) hash_buf
->digest
;
10470 salt_t
*salt
= hash_buf
->salt
;
10472 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10476 memcpy (&in
, input_buf
, input_len
);
10478 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10480 memcpy (digest
, in
.keymic
, 16);
10483 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10484 The phrase "Pairwise key expansion"
10485 Access Point Address (referred to as Authenticator Address AA)
10486 Supplicant Address (referred to as Supplicant Address SA)
10487 Access Point Nonce (referred to as Authenticator Anonce)
10488 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10491 uint salt_len
= strlen (in
.essid
);
10495 log_info ("WARNING: the length of the ESSID is too long. The hccap file may be invalid or corrupted");
10497 return (PARSER_SALT_LENGTH
);
10500 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10502 salt
->salt_len
= salt_len
;
10504 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10506 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10508 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10510 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10512 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10513 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10517 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10518 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10521 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10523 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10524 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10528 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10529 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10532 for (int i
= 0; i
< 25; i
++)
10534 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10537 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10538 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10539 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10540 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10542 wpa
->keyver
= in
.keyver
;
10544 if (wpa
->keyver
> 255)
10546 log_info ("ATTENTION!");
10547 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10548 log_info (" This could be due to a recent aircrack-ng bug.");
10549 log_info (" The key version was automatically reset to a reasonable value.");
10552 wpa
->keyver
&= 0xff;
10555 wpa
->eapol_size
= in
.eapol_size
;
10557 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10559 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10561 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10563 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10565 if (wpa
->keyver
== 1)
10571 digest
[0] = byte_swap_32 (digest
[0]);
10572 digest
[1] = byte_swap_32 (digest
[1]);
10573 digest
[2] = byte_swap_32 (digest
[2]);
10574 digest
[3] = byte_swap_32 (digest
[3]);
10576 for (int i
= 0; i
< 64; i
++)
10578 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10582 uint32_t *p0
= (uint32_t *) in
.essid
;
10586 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10587 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10589 salt
->salt_buf
[10] = c0
;
10590 salt
->salt_buf
[11] = c1
;
10592 return (PARSER_OK
);
10595 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10597 u32
*digest
= (u32
*) hash_buf
->digest
;
10599 salt_t
*salt
= hash_buf
->salt
;
10601 if (input_len
== 0)
10603 log_error ("Password Safe v2 container not specified");
10608 FILE *fp
= fopen (input_buf
, "rb");
10612 log_error ("%s: %s", input_buf
, strerror (errno
));
10619 memset (&buf
, 0, sizeof (psafe2_hdr
));
10621 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10625 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10627 salt
->salt_buf
[0] = buf
.random
[0];
10628 salt
->salt_buf
[1] = buf
.random
[1];
10630 salt
->salt_len
= 8;
10631 salt
->salt_iter
= 1000;
10633 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10634 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10635 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10636 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10637 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10639 return (PARSER_OK
);
10642 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10644 u32
*digest
= (u32
*) hash_buf
->digest
;
10646 salt_t
*salt
= hash_buf
->salt
;
10648 if (input_len
== 0)
10650 log_error (".psafe3 not specified");
10655 FILE *fp
= fopen (input_buf
, "rb");
10659 log_error ("%s: %s", input_buf
, strerror (errno
));
10666 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10670 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10672 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10674 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10676 salt
->salt_iter
= in
.iterations
+ 1;
10678 salt
->salt_buf
[0] = in
.salt_buf
[0];
10679 salt
->salt_buf
[1] = in
.salt_buf
[1];
10680 salt
->salt_buf
[2] = in
.salt_buf
[2];
10681 salt
->salt_buf
[3] = in
.salt_buf
[3];
10682 salt
->salt_buf
[4] = in
.salt_buf
[4];
10683 salt
->salt_buf
[5] = in
.salt_buf
[5];
10684 salt
->salt_buf
[6] = in
.salt_buf
[6];
10685 salt
->salt_buf
[7] = in
.salt_buf
[7];
10687 salt
->salt_len
= 32;
10689 digest
[0] = in
.hash_buf
[0];
10690 digest
[1] = in
.hash_buf
[1];
10691 digest
[2] = in
.hash_buf
[2];
10692 digest
[3] = in
.hash_buf
[3];
10693 digest
[4] = in
.hash_buf
[4];
10694 digest
[5] = in
.hash_buf
[5];
10695 digest
[6] = in
.hash_buf
[6];
10696 digest
[7] = in
.hash_buf
[7];
10698 digest
[0] = byte_swap_32 (digest
[0]);
10699 digest
[1] = byte_swap_32 (digest
[1]);
10700 digest
[2] = byte_swap_32 (digest
[2]);
10701 digest
[3] = byte_swap_32 (digest
[3]);
10702 digest
[4] = byte_swap_32 (digest
[4]);
10703 digest
[5] = byte_swap_32 (digest
[5]);
10704 digest
[6] = byte_swap_32 (digest
[6]);
10705 digest
[7] = byte_swap_32 (digest
[7]);
10707 return (PARSER_OK
);
10710 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10712 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10714 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10716 u32
*digest
= (u32
*) hash_buf
->digest
;
10718 salt_t
*salt
= hash_buf
->salt
;
10720 char *iter_pos
= input_buf
+ 3;
10722 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10724 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10726 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10728 salt
->salt_iter
= salt_iter
;
10730 char *salt_pos
= iter_pos
+ 1;
10734 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10736 salt
->salt_len
= salt_len
;
10738 char *hash_pos
= salt_pos
+ salt_len
;
10740 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10742 return (PARSER_OK
);
10745 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10747 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10749 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10751 u32
*digest
= (u32
*) hash_buf
->digest
;
10753 salt_t
*salt
= hash_buf
->salt
;
10755 char *salt_pos
= input_buf
+ 3;
10757 uint iterations_len
= 0;
10759 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10763 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10765 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10766 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10770 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10774 iterations_len
+= 8;
10778 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10781 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10783 char *hash_pos
= strchr (salt_pos
, '$');
10785 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10787 uint salt_len
= hash_pos
- salt_pos
;
10789 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10791 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10793 salt
->salt_len
= salt_len
;
10797 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10799 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10801 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10803 return (PARSER_OK
);
10806 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10808 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10810 u32
*digest
= (u32
*) hash_buf
->digest
;
10812 salt_t
*salt
= hash_buf
->salt
;
10814 char *salt_pos
= input_buf
+ 6;
10816 uint iterations_len
= 0;
10818 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10822 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10824 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10825 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10829 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10833 iterations_len
+= 8;
10837 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10840 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10842 char *hash_pos
= strchr (salt_pos
, '$');
10844 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10846 uint salt_len
= hash_pos
- salt_pos
;
10848 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10850 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10852 salt
->salt_len
= salt_len
;
10856 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10858 return (PARSER_OK
);
10861 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10863 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10865 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10867 u32
*digest
= (u32
*) hash_buf
->digest
;
10869 salt_t
*salt
= hash_buf
->salt
;
10871 char *salt_pos
= input_buf
+ 14;
10873 char *hash_pos
= strchr (salt_pos
, '*');
10875 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10879 uint salt_len
= hash_pos
- salt_pos
- 1;
10881 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10883 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10885 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10887 salt
->salt_len
= salt_len
;
10889 u8 tmp_buf
[100] = { 0 };
10891 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10893 memcpy (digest
, tmp_buf
, 20);
10895 digest
[0] = byte_swap_32 (digest
[0]);
10896 digest
[1] = byte_swap_32 (digest
[1]);
10897 digest
[2] = byte_swap_32 (digest
[2]);
10898 digest
[3] = byte_swap_32 (digest
[3]);
10899 digest
[4] = byte_swap_32 (digest
[4]);
10901 digest
[0] -= SHA1M_A
;
10902 digest
[1] -= SHA1M_B
;
10903 digest
[2] -= SHA1M_C
;
10904 digest
[3] -= SHA1M_D
;
10905 digest
[4] -= SHA1M_E
;
10907 return (PARSER_OK
);
10910 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10912 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10914 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10916 if (c12
& 3) return (PARSER_HASH_VALUE
);
10918 u32
*digest
= (u32
*) hash_buf
->digest
;
10920 salt_t
*salt
= hash_buf
->salt
;
10922 // for ascii_digest
10923 salt
->salt_sign
[0] = input_buf
[0];
10924 salt
->salt_sign
[1] = input_buf
[1];
10926 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10927 | itoa64_to_int (input_buf
[1]) << 6;
10929 salt
->salt_len
= 2;
10931 u8 tmp_buf
[100] = { 0 };
10933 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10935 memcpy (digest
, tmp_buf
, 8);
10939 IP (digest
[0], digest
[1], tt
);
10944 return (PARSER_OK
);
10947 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10949 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10951 u32
*digest
= (u32
*) hash_buf
->digest
;
10953 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10954 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10955 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10956 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10958 digest
[0] = byte_swap_32 (digest
[0]);
10959 digest
[1] = byte_swap_32 (digest
[1]);
10960 digest
[2] = byte_swap_32 (digest
[2]);
10961 digest
[3] = byte_swap_32 (digest
[3]);
10963 digest
[0] -= MD4M_A
;
10964 digest
[1] -= MD4M_B
;
10965 digest
[2] -= MD4M_C
;
10966 digest
[3] -= MD4M_D
;
10968 return (PARSER_OK
);
10971 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10973 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10975 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10979 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10982 u32
*digest
= (u32
*) hash_buf
->digest
;
10984 salt_t
*salt
= hash_buf
->salt
;
10986 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10987 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10988 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10989 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10991 digest
[0] = byte_swap_32 (digest
[0]);
10992 digest
[1] = byte_swap_32 (digest
[1]);
10993 digest
[2] = byte_swap_32 (digest
[2]);
10994 digest
[3] = byte_swap_32 (digest
[3]);
10996 digest
[0] -= MD4M_A
;
10997 digest
[1] -= MD4M_B
;
10998 digest
[2] -= MD4M_C
;
10999 digest
[3] -= MD4M_D
;
11001 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11003 uint salt_len
= input_len
- 32 - 1;
11005 char *salt_buf
= input_buf
+ 32 + 1;
11007 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11009 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11011 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11013 salt
->salt_len
= salt_len
;
11015 return (PARSER_OK
);
11018 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11020 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
11022 u32
*digest
= (u32
*) hash_buf
->digest
;
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] -= MD5M_A
;
11035 digest
[1] -= MD5M_B
;
11036 digest
[2] -= MD5M_C
;
11037 digest
[3] -= MD5M_D
;
11039 return (PARSER_OK
);
11042 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11044 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
11046 u32
*digest
= (u32
*) hash_buf
->digest
;
11048 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
11049 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
11053 digest
[0] = byte_swap_32 (digest
[0]);
11054 digest
[1] = byte_swap_32 (digest
[1]);
11056 return (PARSER_OK
);
11059 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11061 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11063 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
11067 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
11070 u32
*digest
= (u32
*) hash_buf
->digest
;
11072 salt_t
*salt
= hash_buf
->salt
;
11074 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11075 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11076 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11077 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11079 digest
[0] = byte_swap_32 (digest
[0]);
11080 digest
[1] = byte_swap_32 (digest
[1]);
11081 digest
[2] = byte_swap_32 (digest
[2]);
11082 digest
[3] = byte_swap_32 (digest
[3]);
11084 digest
[0] -= MD5M_A
;
11085 digest
[1] -= MD5M_B
;
11086 digest
[2] -= MD5M_C
;
11087 digest
[3] -= MD5M_D
;
11089 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11091 uint salt_len
= input_len
- 32 - 1;
11093 char *salt_buf
= input_buf
+ 32 + 1;
11095 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11097 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11099 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11101 salt
->salt_len
= salt_len
;
11103 return (PARSER_OK
);
11106 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11108 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
11110 u32
*digest
= (u32
*) hash_buf
->digest
;
11112 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11113 | itoa64_to_int (input_buf
[ 1]) << 6
11114 | itoa64_to_int (input_buf
[ 2]) << 12
11115 | itoa64_to_int (input_buf
[ 3]) << 18;
11116 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11117 | itoa64_to_int (input_buf
[ 5]) << 6
11118 | itoa64_to_int (input_buf
[ 6]) << 12
11119 | itoa64_to_int (input_buf
[ 7]) << 18;
11120 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11121 | itoa64_to_int (input_buf
[ 9]) << 6
11122 | itoa64_to_int (input_buf
[10]) << 12
11123 | itoa64_to_int (input_buf
[11]) << 18;
11124 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11125 | itoa64_to_int (input_buf
[13]) << 6
11126 | itoa64_to_int (input_buf
[14]) << 12
11127 | itoa64_to_int (input_buf
[15]) << 18;
11129 digest
[0] -= MD5M_A
;
11130 digest
[1] -= MD5M_B
;
11131 digest
[2] -= MD5M_C
;
11132 digest
[3] -= MD5M_D
;
11134 digest
[0] &= 0x00ffffff;
11135 digest
[1] &= 0x00ffffff;
11136 digest
[2] &= 0x00ffffff;
11137 digest
[3] &= 0x00ffffff;
11139 return (PARSER_OK
);
11142 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11144 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11146 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
11150 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
11153 u32
*digest
= (u32
*) hash_buf
->digest
;
11155 salt_t
*salt
= hash_buf
->salt
;
11157 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11158 | itoa64_to_int (input_buf
[ 1]) << 6
11159 | itoa64_to_int (input_buf
[ 2]) << 12
11160 | itoa64_to_int (input_buf
[ 3]) << 18;
11161 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11162 | itoa64_to_int (input_buf
[ 5]) << 6
11163 | itoa64_to_int (input_buf
[ 6]) << 12
11164 | itoa64_to_int (input_buf
[ 7]) << 18;
11165 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11166 | itoa64_to_int (input_buf
[ 9]) << 6
11167 | itoa64_to_int (input_buf
[10]) << 12
11168 | itoa64_to_int (input_buf
[11]) << 18;
11169 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11170 | itoa64_to_int (input_buf
[13]) << 6
11171 | itoa64_to_int (input_buf
[14]) << 12
11172 | itoa64_to_int (input_buf
[15]) << 18;
11174 digest
[0] -= MD5M_A
;
11175 digest
[1] -= MD5M_B
;
11176 digest
[2] -= MD5M_C
;
11177 digest
[3] -= MD5M_D
;
11179 digest
[0] &= 0x00ffffff;
11180 digest
[1] &= 0x00ffffff;
11181 digest
[2] &= 0x00ffffff;
11182 digest
[3] &= 0x00ffffff;
11184 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11186 uint salt_len
= input_len
- 16 - 1;
11188 char *salt_buf
= input_buf
+ 16 + 1;
11190 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11192 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11194 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11196 salt
->salt_len
= salt_len
;
11198 return (PARSER_OK
);
11201 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
11203 key
[0] = (nthash
[0] >> 0);
11204 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
11205 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
11206 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
11207 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
11208 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
11209 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
11210 key
[7] = (nthash
[6] << 1);
11222 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11224 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
11226 u32
*digest
= (u32
*) hash_buf
->digest
;
11228 salt_t
*salt
= hash_buf
->salt
;
11230 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11236 char *user_pos
= input_buf
;
11238 char *unused_pos
= strchr (user_pos
, ':');
11240 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11242 uint user_len
= unused_pos
- user_pos
;
11244 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11248 char *domain_pos
= strchr (unused_pos
, ':');
11250 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11252 uint unused_len
= domain_pos
- unused_pos
;
11254 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11258 char *srvchall_pos
= strchr (domain_pos
, ':');
11260 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11262 uint domain_len
= srvchall_pos
- domain_pos
;
11264 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11268 char *hash_pos
= strchr (srvchall_pos
, ':');
11270 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11272 uint srvchall_len
= hash_pos
- srvchall_pos
;
11274 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
11278 char *clichall_pos
= strchr (hash_pos
, ':');
11280 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11282 uint hash_len
= clichall_pos
- hash_pos
;
11284 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11288 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11290 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11293 * store some data for later use
11296 netntlm
->user_len
= user_len
* 2;
11297 netntlm
->domain_len
= domain_len
* 2;
11298 netntlm
->srvchall_len
= srvchall_len
/ 2;
11299 netntlm
->clichall_len
= clichall_len
/ 2;
11301 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11302 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11305 * handle username and domainname
11308 for (uint i
= 0; i
< user_len
; i
++)
11310 *userdomain_ptr
++ = user_pos
[i
];
11311 *userdomain_ptr
++ = 0;
11314 for (uint i
= 0; i
< domain_len
; i
++)
11316 *userdomain_ptr
++ = domain_pos
[i
];
11317 *userdomain_ptr
++ = 0;
11321 * handle server challenge encoding
11324 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11326 const char p0
= srvchall_pos
[i
+ 0];
11327 const char p1
= srvchall_pos
[i
+ 1];
11329 *chall_ptr
++ = hex_convert (p1
) << 0
11330 | hex_convert (p0
) << 4;
11334 * handle client challenge encoding
11337 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11339 const char p0
= clichall_pos
[i
+ 0];
11340 const char p1
= clichall_pos
[i
+ 1];
11342 *chall_ptr
++ = hex_convert (p1
) << 0
11343 | hex_convert (p0
) << 4;
11350 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11352 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11354 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11356 salt
->salt_len
= salt_len
;
11358 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11359 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11360 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11361 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11363 digest
[0] = byte_swap_32 (digest
[0]);
11364 digest
[1] = byte_swap_32 (digest
[1]);
11365 digest
[2] = byte_swap_32 (digest
[2]);
11366 digest
[3] = byte_swap_32 (digest
[3]);
11368 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11370 uint digest_tmp
[2] = { 0 };
11372 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11373 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11375 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11376 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11378 /* special case 2: ESS */
11380 if (srvchall_len
== 48)
11382 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11384 uint w
[16] = { 0 };
11386 w
[ 0] = netntlm
->chall_buf
[6];
11387 w
[ 1] = netntlm
->chall_buf
[7];
11388 w
[ 2] = netntlm
->chall_buf
[0];
11389 w
[ 3] = netntlm
->chall_buf
[1];
11393 uint dgst
[4] = { 0 };
11402 salt
->salt_buf
[0] = dgst
[0];
11403 salt
->salt_buf
[1] = dgst
[1];
11407 /* precompute netntlmv1 exploit start */
11409 for (uint i
= 0; i
< 0x10000; i
++)
11411 uint key_md4
[2] = { i
, 0 };
11412 uint key_des
[2] = { 0, 0 };
11414 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11416 uint Kc
[16] = { 0 };
11417 uint Kd
[16] = { 0 };
11419 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11421 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11423 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11425 if (data3
[0] != digest_tmp
[0]) continue;
11426 if (data3
[1] != digest_tmp
[1]) continue;
11428 salt
->salt_buf
[2] = i
;
11430 salt
->salt_len
= 24;
11435 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11436 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11438 /* precompute netntlmv1 exploit stop */
11442 IP (digest
[0], digest
[1], tt
);
11443 IP (digest
[2], digest
[3], tt
);
11445 digest
[0] = rotr32 (digest
[0], 29);
11446 digest
[1] = rotr32 (digest
[1], 29);
11447 digest
[2] = rotr32 (digest
[2], 29);
11448 digest
[3] = rotr32 (digest
[3], 29);
11450 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11452 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11453 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11455 return (PARSER_OK
);
11458 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11460 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11462 u32
*digest
= (u32
*) hash_buf
->digest
;
11464 salt_t
*salt
= hash_buf
->salt
;
11466 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11472 char *user_pos
= input_buf
;
11474 char *unused_pos
= strchr (user_pos
, ':');
11476 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11478 uint user_len
= unused_pos
- user_pos
;
11480 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11484 char *domain_pos
= strchr (unused_pos
, ':');
11486 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11488 uint unused_len
= domain_pos
- unused_pos
;
11490 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11494 char *srvchall_pos
= strchr (domain_pos
, ':');
11496 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11498 uint domain_len
= srvchall_pos
- domain_pos
;
11500 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11504 char *hash_pos
= strchr (srvchall_pos
, ':');
11506 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11508 uint srvchall_len
= hash_pos
- srvchall_pos
;
11510 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11514 char *clichall_pos
= strchr (hash_pos
, ':');
11516 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11518 uint hash_len
= clichall_pos
- hash_pos
;
11520 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11524 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11526 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11528 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11531 * store some data for later use
11534 netntlm
->user_len
= user_len
* 2;
11535 netntlm
->domain_len
= domain_len
* 2;
11536 netntlm
->srvchall_len
= srvchall_len
/ 2;
11537 netntlm
->clichall_len
= clichall_len
/ 2;
11539 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11540 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11543 * handle username and domainname
11546 for (uint i
= 0; i
< user_len
; i
++)
11548 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11549 *userdomain_ptr
++ = 0;
11552 for (uint i
= 0; i
< domain_len
; i
++)
11554 *userdomain_ptr
++ = domain_pos
[i
];
11555 *userdomain_ptr
++ = 0;
11558 *userdomain_ptr
++ = 0x80;
11561 * handle server challenge encoding
11564 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11566 const char p0
= srvchall_pos
[i
+ 0];
11567 const char p1
= srvchall_pos
[i
+ 1];
11569 *chall_ptr
++ = hex_convert (p1
) << 0
11570 | hex_convert (p0
) << 4;
11574 * handle client challenge encoding
11577 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11579 const char p0
= clichall_pos
[i
+ 0];
11580 const char p1
= clichall_pos
[i
+ 1];
11582 *chall_ptr
++ = hex_convert (p1
) << 0
11583 | hex_convert (p0
) << 4;
11586 *chall_ptr
++ = 0x80;
11589 * handle hash itself
11592 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11593 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11594 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11595 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11597 digest
[0] = byte_swap_32 (digest
[0]);
11598 digest
[1] = byte_swap_32 (digest
[1]);
11599 digest
[2] = byte_swap_32 (digest
[2]);
11600 digest
[3] = byte_swap_32 (digest
[3]);
11603 * reuse challange data as salt_buf, its the buffer that is most likely unique
11606 salt
->salt_buf
[0] = 0;
11607 salt
->salt_buf
[1] = 0;
11608 salt
->salt_buf
[2] = 0;
11609 salt
->salt_buf
[3] = 0;
11610 salt
->salt_buf
[4] = 0;
11611 salt
->salt_buf
[5] = 0;
11612 salt
->salt_buf
[6] = 0;
11613 salt
->salt_buf
[7] = 0;
11617 uptr
= (uint
*) netntlm
->userdomain_buf
;
11619 for (uint i
= 0; i
< 16; i
+= 16)
11621 md5_64 (uptr
, salt
->salt_buf
);
11624 uptr
= (uint
*) netntlm
->chall_buf
;
11626 for (uint i
= 0; i
< 256; i
+= 16)
11628 md5_64 (uptr
, salt
->salt_buf
);
11631 salt
->salt_len
= 16;
11633 return (PARSER_OK
);
11636 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11638 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11640 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11644 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11647 u32
*digest
= (u32
*) hash_buf
->digest
;
11649 salt_t
*salt
= hash_buf
->salt
;
11651 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11652 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11653 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11654 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11656 digest
[0] = byte_swap_32 (digest
[0]);
11657 digest
[1] = byte_swap_32 (digest
[1]);
11658 digest
[2] = byte_swap_32 (digest
[2]);
11659 digest
[3] = byte_swap_32 (digest
[3]);
11661 digest
[0] -= MD5M_A
;
11662 digest
[1] -= MD5M_B
;
11663 digest
[2] -= MD5M_C
;
11664 digest
[3] -= MD5M_D
;
11666 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11668 uint salt_len
= input_len
- 32 - 1;
11670 char *salt_buf
= input_buf
+ 32 + 1;
11672 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11674 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11676 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11678 salt
->salt_len
= salt_len
;
11680 return (PARSER_OK
);
11683 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11685 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11687 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11691 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11694 u32
*digest
= (u32
*) hash_buf
->digest
;
11696 salt_t
*salt
= hash_buf
->salt
;
11698 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11699 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11700 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11701 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11703 digest
[0] = byte_swap_32 (digest
[0]);
11704 digest
[1] = byte_swap_32 (digest
[1]);
11705 digest
[2] = byte_swap_32 (digest
[2]);
11706 digest
[3] = byte_swap_32 (digest
[3]);
11708 digest
[0] -= MD5M_A
;
11709 digest
[1] -= MD5M_B
;
11710 digest
[2] -= MD5M_C
;
11711 digest
[3] -= MD5M_D
;
11713 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11715 uint salt_len
= input_len
- 32 - 1;
11717 char *salt_buf
= input_buf
+ 32 + 1;
11719 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11721 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11723 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11725 salt
->salt_len
= salt_len
;
11727 return (PARSER_OK
);
11730 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11732 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11734 u32
*digest
= (u32
*) hash_buf
->digest
;
11736 salt_t
*salt
= hash_buf
->salt
;
11738 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11739 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11740 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11741 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11743 digest
[0] = byte_swap_32 (digest
[0]);
11744 digest
[1] = byte_swap_32 (digest
[1]);
11745 digest
[2] = byte_swap_32 (digest
[2]);
11746 digest
[3] = byte_swap_32 (digest
[3]);
11748 digest
[0] -= MD5M_A
;
11749 digest
[1] -= MD5M_B
;
11750 digest
[2] -= MD5M_C
;
11751 digest
[3] -= MD5M_D
;
11754 * This is a virtual salt. While the algorithm is basically not salted
11755 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11756 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11759 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11761 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11763 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11765 salt
->salt_len
= salt_len
;
11767 return (PARSER_OK
);
11770 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11772 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11774 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11778 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11781 u32
*digest
= (u32
*) hash_buf
->digest
;
11783 salt_t
*salt
= hash_buf
->salt
;
11785 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11786 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11787 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11788 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11790 digest
[0] = byte_swap_32 (digest
[0]);
11791 digest
[1] = byte_swap_32 (digest
[1]);
11792 digest
[2] = byte_swap_32 (digest
[2]);
11793 digest
[3] = byte_swap_32 (digest
[3]);
11795 digest
[0] -= MD5M_A
;
11796 digest
[1] -= MD5M_B
;
11797 digest
[2] -= MD5M_C
;
11798 digest
[3] -= MD5M_D
;
11800 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11802 uint salt_len
= input_len
- 32 - 1;
11804 char *salt_buf
= input_buf
+ 32 + 1;
11806 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11808 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11810 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11812 salt
->salt_len
= salt_len
;
11814 return (PARSER_OK
);
11817 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11819 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11821 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11825 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11828 u32
*digest
= (u32
*) hash_buf
->digest
;
11830 salt_t
*salt
= hash_buf
->salt
;
11832 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11833 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11834 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11835 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11837 digest
[0] = byte_swap_32 (digest
[0]);
11838 digest
[1] = byte_swap_32 (digest
[1]);
11839 digest
[2] = byte_swap_32 (digest
[2]);
11840 digest
[3] = byte_swap_32 (digest
[3]);
11842 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11844 uint salt_len
= input_len
- 32 - 1;
11846 char *salt_buf
= input_buf
+ 32 + 1;
11848 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11850 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11852 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11854 salt
->salt_len
= salt_len
;
11856 return (PARSER_OK
);
11859 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11861 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11863 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11867 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11870 u32
*digest
= (u32
*) hash_buf
->digest
;
11872 salt_t
*salt
= hash_buf
->salt
;
11874 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11875 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11876 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11877 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11879 digest
[0] = byte_swap_32 (digest
[0]);
11880 digest
[1] = byte_swap_32 (digest
[1]);
11881 digest
[2] = byte_swap_32 (digest
[2]);
11882 digest
[3] = byte_swap_32 (digest
[3]);
11884 digest
[0] -= MD4M_A
;
11885 digest
[1] -= MD4M_B
;
11886 digest
[2] -= MD4M_C
;
11887 digest
[3] -= MD4M_D
;
11889 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11891 uint salt_len
= input_len
- 32 - 1;
11893 char *salt_buf
= input_buf
+ 32 + 1;
11895 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11897 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11899 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11901 salt
->salt_len
= salt_len
;
11903 return (PARSER_OK
);
11906 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11908 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11910 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11914 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11917 u32
*digest
= (u32
*) hash_buf
->digest
;
11919 salt_t
*salt
= hash_buf
->salt
;
11921 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11922 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11923 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11924 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11926 digest
[0] = byte_swap_32 (digest
[0]);
11927 digest
[1] = byte_swap_32 (digest
[1]);
11928 digest
[2] = byte_swap_32 (digest
[2]);
11929 digest
[3] = byte_swap_32 (digest
[3]);
11931 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11933 uint salt_len
= input_len
- 32 - 1;
11935 char *salt_buf
= input_buf
+ 32 + 1;
11937 uint salt_pc_block
[16] = { 0 };
11939 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11941 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11943 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11945 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11947 salt_pc_block
[14] = salt_len
* 8;
11949 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11951 md5_64 (salt_pc_block
, salt_pc_digest
);
11953 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11954 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11955 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11956 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11958 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11960 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11962 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11964 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11965 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11966 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11967 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11969 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11971 return (PARSER_OK
);
11974 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11976 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11978 u32
*digest
= (u32
*) hash_buf
->digest
;
11980 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11981 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11982 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11983 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11984 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11986 digest
[0] -= SHA1M_A
;
11987 digest
[1] -= SHA1M_B
;
11988 digest
[2] -= SHA1M_C
;
11989 digest
[3] -= SHA1M_D
;
11990 digest
[4] -= SHA1M_E
;
11992 return (PARSER_OK
);
11995 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11997 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11999 u32
*digest
= (u32
*) hash_buf
->digest
;
12001 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12002 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12003 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12004 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12005 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12007 return (PARSER_OK
);
12010 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12012 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
12014 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
12016 u32
*digest
= (u32
*) hash_buf
->digest
;
12020 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12021 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12022 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12023 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12024 digest
[4] = 0x00000000;
12026 return (PARSER_OK
);
12029 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12031 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12033 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
12037 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
12040 u32
*digest
= (u32
*) hash_buf
->digest
;
12042 salt_t
*salt
= hash_buf
->salt
;
12044 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12045 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12046 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12047 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12048 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12050 digest
[0] -= SHA1M_A
;
12051 digest
[1] -= SHA1M_B
;
12052 digest
[2] -= SHA1M_C
;
12053 digest
[3] -= SHA1M_D
;
12054 digest
[4] -= SHA1M_E
;
12056 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12058 uint salt_len
= input_len
- 40 - 1;
12060 char *salt_buf
= input_buf
+ 40 + 1;
12062 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12064 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12066 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12068 salt
->salt_len
= salt_len
;
12070 return (PARSER_OK
);
12073 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12075 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
12077 u32
*digest
= (u32
*) hash_buf
->digest
;
12079 salt_t
*salt
= hash_buf
->salt
;
12081 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
12083 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12084 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12085 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12086 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12087 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12089 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12091 uint salt_len
= input_len
- 40 - 1;
12093 char *salt_buf
= input_buf
+ 40 + 1;
12095 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
12097 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
12099 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
12101 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
12104 pstoken
->salt_len
= salt_len
/ 2;
12106 /* some fake salt for the sorting mechanisms */
12108 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
12109 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
12110 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
12111 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
12112 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
12113 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
12114 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
12115 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
12117 salt
->salt_len
= 32;
12119 /* we need to check if we can precompute some of the data --
12120 this is possible since the scheme is badly designed */
12122 pstoken
->pc_digest
[0] = SHA1M_A
;
12123 pstoken
->pc_digest
[1] = SHA1M_B
;
12124 pstoken
->pc_digest
[2] = SHA1M_C
;
12125 pstoken
->pc_digest
[3] = SHA1M_D
;
12126 pstoken
->pc_digest
[4] = SHA1M_E
;
12128 pstoken
->pc_offset
= 0;
12130 for (int i
= 0; i
< (int) pstoken
->salt_len
- 64; i
+= 64)
12134 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
12135 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
12136 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
12137 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
12138 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
12139 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
12140 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
12141 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
12142 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
12143 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
12144 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
12145 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
12146 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
12147 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
12148 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
12149 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
12151 sha1_64 (w
, pstoken
->pc_digest
);
12153 pstoken
->pc_offset
+= 16;
12156 return (PARSER_OK
);
12159 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12161 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
12163 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
12165 u32
*digest
= (u32
*) hash_buf
->digest
;
12167 u8 tmp_buf
[100] = { 0 };
12169 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
12171 memcpy (digest
, tmp_buf
, 20);
12173 digest
[0] = byte_swap_32 (digest
[0]);
12174 digest
[1] = byte_swap_32 (digest
[1]);
12175 digest
[2] = byte_swap_32 (digest
[2]);
12176 digest
[3] = byte_swap_32 (digest
[3]);
12177 digest
[4] = byte_swap_32 (digest
[4]);
12179 digest
[0] -= SHA1M_A
;
12180 digest
[1] -= SHA1M_B
;
12181 digest
[2] -= SHA1M_C
;
12182 digest
[3] -= SHA1M_D
;
12183 digest
[4] -= SHA1M_E
;
12185 return (PARSER_OK
);
12188 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12190 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
12192 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12194 u32
*digest
= (u32
*) hash_buf
->digest
;
12196 salt_t
*salt
= hash_buf
->salt
;
12198 u8 tmp_buf
[100] = { 0 };
12200 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
12202 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
12204 memcpy (digest
, tmp_buf
, 20);
12206 int salt_len
= tmp_len
- 20;
12208 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
12210 salt
->salt_len
= salt_len
;
12212 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
12214 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12216 char *ptr
= (char *) salt
->salt_buf
;
12218 ptr
[salt
->salt_len
] = 0x80;
12221 digest
[0] = byte_swap_32 (digest
[0]);
12222 digest
[1] = byte_swap_32 (digest
[1]);
12223 digest
[2] = byte_swap_32 (digest
[2]);
12224 digest
[3] = byte_swap_32 (digest
[3]);
12225 digest
[4] = byte_swap_32 (digest
[4]);
12227 digest
[0] -= SHA1M_A
;
12228 digest
[1] -= SHA1M_B
;
12229 digest
[2] -= SHA1M_C
;
12230 digest
[3] -= SHA1M_D
;
12231 digest
[4] -= SHA1M_E
;
12233 return (PARSER_OK
);
12236 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12238 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
12240 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12242 u32
*digest
= (u32
*) hash_buf
->digest
;
12244 salt_t
*salt
= hash_buf
->salt
;
12246 char *salt_buf
= input_buf
+ 6;
12250 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12252 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12254 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12256 salt
->salt_len
= salt_len
;
12258 char *hash_pos
= input_buf
+ 6 + 8 + 40;
12260 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12261 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12262 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12263 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12264 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12266 digest
[0] -= SHA1M_A
;
12267 digest
[1] -= SHA1M_B
;
12268 digest
[2] -= SHA1M_C
;
12269 digest
[3] -= SHA1M_D
;
12270 digest
[4] -= SHA1M_E
;
12272 return (PARSER_OK
);
12275 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12277 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
12279 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12281 u32
*digest
= (u32
*) hash_buf
->digest
;
12283 salt_t
*salt
= hash_buf
->salt
;
12285 char *salt_buf
= input_buf
+ 6;
12289 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12291 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12293 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12295 salt
->salt_len
= salt_len
;
12297 char *hash_pos
= input_buf
+ 6 + 8;
12299 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12300 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12301 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12302 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12303 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12305 digest
[0] -= SHA1M_A
;
12306 digest
[1] -= SHA1M_B
;
12307 digest
[2] -= SHA1M_C
;
12308 digest
[3] -= SHA1M_D
;
12309 digest
[4] -= SHA1M_E
;
12311 return (PARSER_OK
);
12314 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12316 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12318 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12320 u64
*digest
= (u64
*) hash_buf
->digest
;
12322 salt_t
*salt
= hash_buf
->salt
;
12324 char *salt_buf
= input_buf
+ 6;
12328 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12330 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12332 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12334 salt
->salt_len
= salt_len
;
12336 char *hash_pos
= input_buf
+ 6 + 8;
12338 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12339 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12340 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12341 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12342 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12343 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12344 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12345 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12347 digest
[0] -= SHA512M_A
;
12348 digest
[1] -= SHA512M_B
;
12349 digest
[2] -= SHA512M_C
;
12350 digest
[3] -= SHA512M_D
;
12351 digest
[4] -= SHA512M_E
;
12352 digest
[5] -= SHA512M_F
;
12353 digest
[6] -= SHA512M_G
;
12354 digest
[7] -= SHA512M_H
;
12356 return (PARSER_OK
);
12359 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12361 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12363 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12367 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12370 u32
*digest
= (u32
*) hash_buf
->digest
;
12372 salt_t
*salt
= hash_buf
->salt
;
12374 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12375 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12379 digest
[0] = byte_swap_32 (digest
[0]);
12380 digest
[1] = byte_swap_32 (digest
[1]);
12382 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12384 uint salt_len
= input_len
- 16 - 1;
12386 char *salt_buf
= input_buf
+ 16 + 1;
12388 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12390 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12392 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12394 salt
->salt_len
= salt_len
;
12396 return (PARSER_OK
);
12399 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12401 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12403 u32
*digest
= (u32
*) hash_buf
->digest
;
12405 salt_t
*salt
= hash_buf
->salt
;
12407 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12408 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12409 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12410 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12411 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12413 digest
[0] -= SHA1M_A
;
12414 digest
[1] -= SHA1M_B
;
12415 digest
[2] -= SHA1M_C
;
12416 digest
[3] -= SHA1M_D
;
12417 digest
[4] -= SHA1M_E
;
12419 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12421 uint salt_len
= input_len
- 40 - 1;
12423 char *salt_buf
= input_buf
+ 40 + 1;
12425 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12427 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12429 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12431 salt
->salt_len
= salt_len
;
12433 return (PARSER_OK
);
12436 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12438 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12440 u32
*digest
= (u32
*) hash_buf
->digest
;
12442 salt_t
*salt
= hash_buf
->salt
;
12444 char *hash_pos
= input_buf
;
12446 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12447 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12448 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12449 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12450 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12451 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12452 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12453 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12454 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12455 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12456 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12457 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12458 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12459 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12460 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12461 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12463 char *salt_pos
= input_buf
+ 128;
12465 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12466 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12467 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12468 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12470 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12471 salt
->salt_len
= 16;
12473 return (PARSER_OK
);
12476 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12478 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12480 u32
*digest
= (u32
*) hash_buf
->digest
;
12482 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12483 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12484 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12485 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12486 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12487 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12488 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12489 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12491 digest
[0] -= SHA256M_A
;
12492 digest
[1] -= SHA256M_B
;
12493 digest
[2] -= SHA256M_C
;
12494 digest
[3] -= SHA256M_D
;
12495 digest
[4] -= SHA256M_E
;
12496 digest
[5] -= SHA256M_F
;
12497 digest
[6] -= SHA256M_G
;
12498 digest
[7] -= SHA256M_H
;
12500 return (PARSER_OK
);
12503 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12505 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12507 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12511 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12514 u32
*digest
= (u32
*) hash_buf
->digest
;
12516 salt_t
*salt
= hash_buf
->salt
;
12518 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12519 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12520 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12521 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12522 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12523 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12524 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12525 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12527 digest
[0] -= SHA256M_A
;
12528 digest
[1] -= SHA256M_B
;
12529 digest
[2] -= SHA256M_C
;
12530 digest
[3] -= SHA256M_D
;
12531 digest
[4] -= SHA256M_E
;
12532 digest
[5] -= SHA256M_F
;
12533 digest
[6] -= SHA256M_G
;
12534 digest
[7] -= SHA256M_H
;
12536 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12538 uint salt_len
= input_len
- 64 - 1;
12540 char *salt_buf
= input_buf
+ 64 + 1;
12542 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12544 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12546 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12548 salt
->salt_len
= salt_len
;
12550 return (PARSER_OK
);
12553 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12555 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12557 u64
*digest
= (u64
*) hash_buf
->digest
;
12559 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12560 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12561 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12562 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12563 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12564 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12568 digest
[0] -= SHA384M_A
;
12569 digest
[1] -= SHA384M_B
;
12570 digest
[2] -= SHA384M_C
;
12571 digest
[3] -= SHA384M_D
;
12572 digest
[4] -= SHA384M_E
;
12573 digest
[5] -= SHA384M_F
;
12577 return (PARSER_OK
);
12580 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12582 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12584 u64
*digest
= (u64
*) hash_buf
->digest
;
12586 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12587 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12588 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12589 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12590 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12591 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12592 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12593 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12595 digest
[0] -= SHA512M_A
;
12596 digest
[1] -= SHA512M_B
;
12597 digest
[2] -= SHA512M_C
;
12598 digest
[3] -= SHA512M_D
;
12599 digest
[4] -= SHA512M_E
;
12600 digest
[5] -= SHA512M_F
;
12601 digest
[6] -= SHA512M_G
;
12602 digest
[7] -= SHA512M_H
;
12604 return (PARSER_OK
);
12607 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12609 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12611 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12615 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12618 u64
*digest
= (u64
*) hash_buf
->digest
;
12620 salt_t
*salt
= hash_buf
->salt
;
12622 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12623 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12624 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12625 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12626 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12627 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12628 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12629 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12631 digest
[0] -= SHA512M_A
;
12632 digest
[1] -= SHA512M_B
;
12633 digest
[2] -= SHA512M_C
;
12634 digest
[3] -= SHA512M_D
;
12635 digest
[4] -= SHA512M_E
;
12636 digest
[5] -= SHA512M_F
;
12637 digest
[6] -= SHA512M_G
;
12638 digest
[7] -= SHA512M_H
;
12640 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12642 uint salt_len
= input_len
- 128 - 1;
12644 char *salt_buf
= input_buf
+ 128 + 1;
12646 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12648 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12650 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12652 salt
->salt_len
= salt_len
;
12654 return (PARSER_OK
);
12657 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12659 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12661 u64
*digest
= (u64
*) hash_buf
->digest
;
12663 salt_t
*salt
= hash_buf
->salt
;
12665 char *salt_pos
= input_buf
+ 3;
12667 uint iterations_len
= 0;
12669 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12673 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12675 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12676 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12680 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12684 iterations_len
+= 8;
12688 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12691 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12693 char *hash_pos
= strchr (salt_pos
, '$');
12695 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12697 uint salt_len
= hash_pos
- salt_pos
;
12699 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12701 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12703 salt
->salt_len
= salt_len
;
12707 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12709 return (PARSER_OK
);
12712 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12714 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12716 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12718 u64
*digest
= (u64
*) hash_buf
->digest
;
12720 salt_t
*salt
= hash_buf
->salt
;
12722 uint keccak_mdlen
= input_len
/ 2;
12724 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12726 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12728 digest
[i
] = byte_swap_64 (digest
[i
]);
12731 salt
->keccak_mdlen
= keccak_mdlen
;
12733 return (PARSER_OK
);
12736 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12738 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12740 u32
*digest
= (u32
*) hash_buf
->digest
;
12742 salt_t
*salt
= hash_buf
->salt
;
12744 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12747 * Parse that strange long line
12752 size_t in_len
[9] = { 0 };
12754 in_off
[0] = strtok (input_buf
, ":");
12756 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12758 in_len
[0] = strlen (in_off
[0]);
12762 for (i
= 1; i
< 9; i
++)
12764 in_off
[i
] = strtok (NULL
, ":");
12766 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12768 in_len
[i
] = strlen (in_off
[i
]);
12771 char *ptr
= (char *) ikepsk
->msg_buf
;
12773 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12774 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12775 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12776 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12777 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12778 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12782 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12784 ptr
= (char *) ikepsk
->nr_buf
;
12786 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12787 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12791 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12794 * Store to database
12799 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12800 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12801 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12802 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12804 digest
[0] = byte_swap_32 (digest
[0]);
12805 digest
[1] = byte_swap_32 (digest
[1]);
12806 digest
[2] = byte_swap_32 (digest
[2]);
12807 digest
[3] = byte_swap_32 (digest
[3]);
12809 salt
->salt_len
= 32;
12811 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12812 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12813 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12814 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12815 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12816 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12817 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12818 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12820 return (PARSER_OK
);
12823 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12825 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12827 u32
*digest
= (u32
*) hash_buf
->digest
;
12829 salt_t
*salt
= hash_buf
->salt
;
12831 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12834 * Parse that strange long line
12839 size_t in_len
[9] = { 0 };
12841 in_off
[0] = strtok (input_buf
, ":");
12843 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12845 in_len
[0] = strlen (in_off
[0]);
12849 for (i
= 1; i
< 9; i
++)
12851 in_off
[i
] = strtok (NULL
, ":");
12853 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12855 in_len
[i
] = strlen (in_off
[i
]);
12858 char *ptr
= (char *) ikepsk
->msg_buf
;
12860 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12861 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12862 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12863 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12864 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12865 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12869 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12871 ptr
= (char *) ikepsk
->nr_buf
;
12873 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12874 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12878 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12881 * Store to database
12886 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12887 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12888 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12889 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12890 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12892 salt
->salt_len
= 32;
12894 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12895 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12896 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12897 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12898 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12899 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12900 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12901 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12903 return (PARSER_OK
);
12906 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12908 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12910 u32
*digest
= (u32
*) hash_buf
->digest
;
12912 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12913 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12914 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12915 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12916 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12918 digest
[0] = byte_swap_32 (digest
[0]);
12919 digest
[1] = byte_swap_32 (digest
[1]);
12920 digest
[2] = byte_swap_32 (digest
[2]);
12921 digest
[3] = byte_swap_32 (digest
[3]);
12922 digest
[4] = byte_swap_32 (digest
[4]);
12924 return (PARSER_OK
);
12927 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12929 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12931 u32
*digest
= (u32
*) hash_buf
->digest
;
12933 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12934 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12935 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12936 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12937 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12938 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12939 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12940 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12941 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12942 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12943 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12944 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12945 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12946 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12947 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12948 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12950 return (PARSER_OK
);
12953 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12955 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12957 u32
*digest
= (u32
*) hash_buf
->digest
;
12959 salt_t
*salt
= hash_buf
->salt
;
12961 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12962 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12963 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12964 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12965 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12967 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12969 uint salt_len
= input_len
- 40 - 1;
12971 char *salt_buf
= input_buf
+ 40 + 1;
12973 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12975 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12977 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12979 salt
->salt_len
= salt_len
;
12981 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12983 return (PARSER_OK
);
12986 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12988 u32
*digest
= (u32
*) hash_buf
->digest
;
12990 salt_t
*salt
= hash_buf
->salt
;
12992 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12994 if (input_len
== 0)
12996 log_error ("TrueCrypt container not specified");
13001 FILE *fp
= fopen (input_buf
, "rb");
13005 log_error ("%s: %s", input_buf
, strerror (errno
));
13010 char buf
[512] = { 0 };
13012 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13016 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13018 memcpy (tc
->salt_buf
, buf
, 64);
13020 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13022 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13024 salt
->salt_len
= 4;
13026 salt
->salt_iter
= ROUNDS_TRUECRYPT_1K
- 1;
13028 tc
->signature
= 0x45555254; // "TRUE"
13030 digest
[0] = tc
->data_buf
[0];
13032 return (PARSER_OK
);
13035 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13037 u32
*digest
= (u32
*) hash_buf
->digest
;
13039 salt_t
*salt
= hash_buf
->salt
;
13041 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13043 if (input_len
== 0)
13045 log_error ("TrueCrypt container not specified");
13050 FILE *fp
= fopen (input_buf
, "rb");
13054 log_error ("%s: %s", input_buf
, strerror (errno
));
13059 char buf
[512] = { 0 };
13061 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13065 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13067 memcpy (tc
->salt_buf
, buf
, 64);
13069 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13071 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13073 salt
->salt_len
= 4;
13075 salt
->salt_iter
= ROUNDS_TRUECRYPT_2K
- 1;
13077 tc
->signature
= 0x45555254; // "TRUE"
13079 digest
[0] = tc
->data_buf
[0];
13081 return (PARSER_OK
);
13084 int veracrypt_parse_hash_200000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13086 u32
*digest
= (u32
*) hash_buf
->digest
;
13088 salt_t
*salt
= hash_buf
->salt
;
13090 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13092 if (input_len
== 0)
13094 log_error ("VeraCrypt container not specified");
13099 FILE *fp
= fopen (input_buf
, "rb");
13103 log_error ("%s: %s", input_buf
, strerror (errno
));
13108 char buf
[512] = { 0 };
13110 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13114 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13116 memcpy (tc
->salt_buf
, buf
, 64);
13118 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13120 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13122 salt
->salt_len
= 4;
13124 salt
->salt_iter
= ROUNDS_VERACRYPT_200000
- 1;
13126 tc
->signature
= 0x41524556; // "VERA"
13128 digest
[0] = tc
->data_buf
[0];
13130 return (PARSER_OK
);
13133 int veracrypt_parse_hash_500000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13135 u32
*digest
= (u32
*) hash_buf
->digest
;
13137 salt_t
*salt
= hash_buf
->salt
;
13139 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13141 if (input_len
== 0)
13143 log_error ("VeraCrypt container not specified");
13148 FILE *fp
= fopen (input_buf
, "rb");
13152 log_error ("%s: %s", input_buf
, strerror (errno
));
13157 char buf
[512] = { 0 };
13159 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13163 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13165 memcpy (tc
->salt_buf
, buf
, 64);
13167 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13169 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13171 salt
->salt_len
= 4;
13173 salt
->salt_iter
= ROUNDS_VERACRYPT_500000
- 1;
13175 tc
->signature
= 0x41524556; // "VERA"
13177 digest
[0] = tc
->data_buf
[0];
13179 return (PARSER_OK
);
13182 int veracrypt_parse_hash_327661 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13184 u32
*digest
= (u32
*) hash_buf
->digest
;
13186 salt_t
*salt
= hash_buf
->salt
;
13188 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13190 if (input_len
== 0)
13192 log_error ("VeraCrypt container not specified");
13197 FILE *fp
= fopen (input_buf
, "rb");
13201 log_error ("%s: %s", input_buf
, strerror (errno
));
13206 char buf
[512] = { 0 };
13208 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13212 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13214 memcpy (tc
->salt_buf
, buf
, 64);
13216 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13218 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13220 salt
->salt_len
= 4;
13222 salt
->salt_iter
= ROUNDS_VERACRYPT_327661
- 1;
13224 tc
->signature
= 0x41524556; // "VERA"
13226 digest
[0] = tc
->data_buf
[0];
13228 return (PARSER_OK
);
13231 int veracrypt_parse_hash_655331 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13233 u32
*digest
= (u32
*) hash_buf
->digest
;
13235 salt_t
*salt
= hash_buf
->salt
;
13237 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13239 if (input_len
== 0)
13241 log_error ("VeraCrypt container not specified");
13246 FILE *fp
= fopen (input_buf
, "rb");
13250 log_error ("%s: %s", input_buf
, strerror (errno
));
13255 char buf
[512] = { 0 };
13257 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13261 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13263 memcpy (tc
->salt_buf
, buf
, 64);
13265 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13267 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13269 salt
->salt_len
= 4;
13271 salt
->salt_iter
= ROUNDS_VERACRYPT_655331
- 1;
13273 tc
->signature
= 0x41524556; // "VERA"
13275 digest
[0] = tc
->data_buf
[0];
13277 return (PARSER_OK
);
13280 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13282 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
13284 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13286 u32
*digest
= (u32
*) hash_buf
->digest
;
13288 salt_t
*salt
= hash_buf
->salt
;
13290 char *salt_pos
= input_buf
+ 6;
13292 char *hash_pos
= strchr (salt_pos
, '$');
13294 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13296 uint salt_len
= hash_pos
- salt_pos
;
13298 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
13300 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13302 salt
->salt_len
= salt_len
;
13304 salt
->salt_iter
= 1000;
13308 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13310 return (PARSER_OK
);
13313 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13315 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
13317 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
13319 u32
*digest
= (u32
*) hash_buf
->digest
;
13321 salt_t
*salt
= hash_buf
->salt
;
13323 char *iter_pos
= input_buf
+ 7;
13325 char *salt_pos
= strchr (iter_pos
, '$');
13327 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13331 char *hash_pos
= strchr (salt_pos
, '$');
13333 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13335 uint salt_len
= hash_pos
- salt_pos
;
13337 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13339 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13341 salt
->salt_len
= salt_len
;
13343 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13345 salt
->salt_sign
[0] = atoi (salt_iter
);
13347 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13351 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13353 digest
[0] = byte_swap_32 (digest
[0]);
13354 digest
[1] = byte_swap_32 (digest
[1]);
13355 digest
[2] = byte_swap_32 (digest
[2]);
13356 digest
[3] = byte_swap_32 (digest
[3]);
13357 digest
[4] = byte_swap_32 (digest
[4]);
13359 return (PARSER_OK
);
13362 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13364 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
13366 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13368 u32
*digest
= (u32
*) hash_buf
->digest
;
13370 salt_t
*salt
= hash_buf
->salt
;
13372 char *iter_pos
= input_buf
+ 9;
13374 char *salt_pos
= strchr (iter_pos
, '$');
13376 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13380 char *hash_pos
= strchr (salt_pos
, '$');
13382 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13384 uint salt_len
= hash_pos
- salt_pos
;
13386 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13388 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13390 salt
->salt_len
= salt_len
;
13392 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13394 salt
->salt_sign
[0] = atoi (salt_iter
);
13396 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13400 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13402 digest
[0] = byte_swap_32 (digest
[0]);
13403 digest
[1] = byte_swap_32 (digest
[1]);
13404 digest
[2] = byte_swap_32 (digest
[2]);
13405 digest
[3] = byte_swap_32 (digest
[3]);
13406 digest
[4] = byte_swap_32 (digest
[4]);
13407 digest
[5] = byte_swap_32 (digest
[5]);
13408 digest
[6] = byte_swap_32 (digest
[6]);
13409 digest
[7] = byte_swap_32 (digest
[7]);
13411 return (PARSER_OK
);
13414 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13416 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
13418 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13420 u64
*digest
= (u64
*) hash_buf
->digest
;
13422 salt_t
*salt
= hash_buf
->salt
;
13424 char *iter_pos
= input_buf
+ 9;
13426 char *salt_pos
= strchr (iter_pos
, '$');
13428 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13432 char *hash_pos
= strchr (salt_pos
, '$');
13434 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13436 uint salt_len
= hash_pos
- salt_pos
;
13438 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13440 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13442 salt
->salt_len
= salt_len
;
13444 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13446 salt
->salt_sign
[0] = atoi (salt_iter
);
13448 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13452 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13454 digest
[0] = byte_swap_64 (digest
[0]);
13455 digest
[1] = byte_swap_64 (digest
[1]);
13456 digest
[2] = byte_swap_64 (digest
[2]);
13457 digest
[3] = byte_swap_64 (digest
[3]);
13458 digest
[4] = byte_swap_64 (digest
[4]);
13459 digest
[5] = byte_swap_64 (digest
[5]);
13460 digest
[6] = byte_swap_64 (digest
[6]);
13461 digest
[7] = byte_swap_64 (digest
[7]);
13463 return (PARSER_OK
);
13466 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13468 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
13470 u32
*digest
= (u32
*) hash_buf
->digest
;
13472 salt_t
*salt
= hash_buf
->salt
;
13474 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
13480 char *iterations_pos
= input_buf
;
13482 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13484 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13486 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13488 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13492 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13494 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13496 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13498 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13500 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13502 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13507 * pbkdf2 iterations
13510 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13513 * handle salt encoding
13516 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13518 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13520 const char p0
= saltbuf_pos
[i
+ 0];
13521 const char p1
= saltbuf_pos
[i
+ 1];
13523 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13524 | hex_convert (p0
) << 4;
13527 salt
->salt_len
= saltbuf_len
/ 2;
13530 * handle cipher encoding
13533 uint
*tmp
= (uint
*) mymalloc (32);
13535 char *cipherbuf_ptr
= (char *) tmp
;
13537 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13539 const char p0
= cipherbuf_pos
[i
+ 0];
13540 const char p1
= cipherbuf_pos
[i
+ 1];
13542 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13543 | hex_convert (p0
) << 4;
13546 // iv is stored at salt_buf 4 (length 16)
13547 // data is stored at salt_buf 8 (length 16)
13549 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13550 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13551 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13552 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13554 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13555 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13556 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13557 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13561 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13563 const char p0
= cipherbuf_pos
[j
+ 0];
13564 const char p1
= cipherbuf_pos
[j
+ 1];
13566 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13567 | hex_convert (p0
) << 4;
13574 digest
[0] = 0x10101010;
13575 digest
[1] = 0x10101010;
13576 digest
[2] = 0x10101010;
13577 digest
[3] = 0x10101010;
13579 return (PARSER_OK
);
13582 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13584 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13586 u32
*digest
= (u32
*) hash_buf
->digest
;
13588 salt_t
*salt
= hash_buf
->salt
;
13590 char *hashbuf_pos
= input_buf
;
13592 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13594 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13596 uint hash_len
= iterations_pos
- hashbuf_pos
;
13598 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13602 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13604 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13606 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13610 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13612 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13614 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13616 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13618 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13620 salt
->salt_len
= salt_len
;
13622 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13624 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13625 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13626 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13627 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13629 return (PARSER_OK
);
13632 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13634 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13636 u32
*digest
= (u32
*) hash_buf
->digest
;
13638 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13639 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13640 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13641 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13642 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13643 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13644 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13645 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13647 digest
[0] = byte_swap_32 (digest
[0]);
13648 digest
[1] = byte_swap_32 (digest
[1]);
13649 digest
[2] = byte_swap_32 (digest
[2]);
13650 digest
[3] = byte_swap_32 (digest
[3]);
13651 digest
[4] = byte_swap_32 (digest
[4]);
13652 digest
[5] = byte_swap_32 (digest
[5]);
13653 digest
[6] = byte_swap_32 (digest
[6]);
13654 digest
[7] = byte_swap_32 (digest
[7]);
13656 return (PARSER_OK
);
13659 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13661 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13663 u32
*digest
= (u32
*) hash_buf
->digest
;
13665 salt_t
*salt
= hash_buf
->salt
;
13667 char *salt_pos
= input_buf
+ 3;
13669 uint iterations_len
= 0;
13671 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13675 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13677 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13678 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13682 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13686 iterations_len
+= 8;
13690 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13693 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13695 char *hash_pos
= strchr (salt_pos
, '$');
13697 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13699 uint salt_len
= hash_pos
- salt_pos
;
13701 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13703 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13705 salt
->salt_len
= salt_len
;
13709 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13711 return (PARSER_OK
);
13714 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13716 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13718 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13720 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13722 u64
*digest
= (u64
*) hash_buf
->digest
;
13724 salt_t
*salt
= hash_buf
->salt
;
13726 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13728 char *iter_pos
= input_buf
+ 4;
13730 char *salt_pos
= strchr (iter_pos
, '$');
13732 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13736 char *hash_pos
= strchr (salt_pos
, '$');
13738 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13740 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13744 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13745 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13746 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13747 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13748 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13749 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13750 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13751 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13753 uint salt_len
= hash_pos
- salt_pos
- 1;
13755 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13757 salt
->salt_len
= salt_len
/ 2;
13759 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13760 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13761 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13762 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13763 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13764 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13765 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13766 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13768 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13769 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13770 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13771 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13772 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13773 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13774 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13775 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13776 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13777 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13779 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13781 salt
->salt_iter
= atoi (iter_pos
) - 1;
13783 return (PARSER_OK
);
13786 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13788 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13790 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13792 u32
*digest
= (u32
*) hash_buf
->digest
;
13794 salt_t
*salt
= hash_buf
->salt
;
13796 char *salt_pos
= input_buf
+ 14;
13798 char *hash_pos
= strchr (salt_pos
, '*');
13800 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13804 uint salt_len
= hash_pos
- salt_pos
- 1;
13806 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13808 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13810 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13812 salt
->salt_len
= salt_len
;
13814 u8 tmp_buf
[100] = { 0 };
13816 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13818 memcpy (digest
, tmp_buf
, 32);
13820 digest
[0] = byte_swap_32 (digest
[0]);
13821 digest
[1] = byte_swap_32 (digest
[1]);
13822 digest
[2] = byte_swap_32 (digest
[2]);
13823 digest
[3] = byte_swap_32 (digest
[3]);
13824 digest
[4] = byte_swap_32 (digest
[4]);
13825 digest
[5] = byte_swap_32 (digest
[5]);
13826 digest
[6] = byte_swap_32 (digest
[6]);
13827 digest
[7] = byte_swap_32 (digest
[7]);
13829 digest
[0] -= SHA256M_A
;
13830 digest
[1] -= SHA256M_B
;
13831 digest
[2] -= SHA256M_C
;
13832 digest
[3] -= SHA256M_D
;
13833 digest
[4] -= SHA256M_E
;
13834 digest
[5] -= SHA256M_F
;
13835 digest
[6] -= SHA256M_G
;
13836 digest
[7] -= SHA256M_H
;
13838 return (PARSER_OK
);
13841 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13843 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13845 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13847 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13849 u64
*digest
= (u64
*) hash_buf
->digest
;
13851 salt_t
*salt
= hash_buf
->salt
;
13853 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13855 char *iter_pos
= input_buf
+ 19;
13857 char *salt_pos
= strchr (iter_pos
, '.');
13859 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13863 char *hash_pos
= strchr (salt_pos
, '.');
13865 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13867 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13871 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13872 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13873 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13874 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13875 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13876 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13877 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13878 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13880 uint salt_len
= hash_pos
- salt_pos
- 1;
13884 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13888 for (i
= 0; i
< salt_len
; i
++)
13890 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13893 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13894 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13896 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13898 salt
->salt_len
= salt_len
;
13900 salt
->salt_iter
= atoi (iter_pos
) - 1;
13902 return (PARSER_OK
);
13905 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13907 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13909 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13911 u64
*digest
= (u64
*) hash_buf
->digest
;
13913 salt_t
*salt
= hash_buf
->salt
;
13915 u8 tmp_buf
[120] = { 0 };
13917 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13919 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13921 memcpy (digest
, tmp_buf
, 64);
13923 digest
[0] = byte_swap_64 (digest
[0]);
13924 digest
[1] = byte_swap_64 (digest
[1]);
13925 digest
[2] = byte_swap_64 (digest
[2]);
13926 digest
[3] = byte_swap_64 (digest
[3]);
13927 digest
[4] = byte_swap_64 (digest
[4]);
13928 digest
[5] = byte_swap_64 (digest
[5]);
13929 digest
[6] = byte_swap_64 (digest
[6]);
13930 digest
[7] = byte_swap_64 (digest
[7]);
13932 digest
[0] -= SHA512M_A
;
13933 digest
[1] -= SHA512M_B
;
13934 digest
[2] -= SHA512M_C
;
13935 digest
[3] -= SHA512M_D
;
13936 digest
[4] -= SHA512M_E
;
13937 digest
[5] -= SHA512M_F
;
13938 digest
[6] -= SHA512M_G
;
13939 digest
[7] -= SHA512M_H
;
13941 int salt_len
= tmp_len
- 64;
13943 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13945 salt
->salt_len
= salt_len
;
13947 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13949 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13951 char *ptr
= (char *) salt
->salt_buf
;
13953 ptr
[salt
->salt_len
] = 0x80;
13956 return (PARSER_OK
);
13959 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13961 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13963 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13967 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13970 u32
*digest
= (u32
*) hash_buf
->digest
;
13972 salt_t
*salt
= hash_buf
->salt
;
13974 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13975 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13976 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13977 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13979 digest
[0] = byte_swap_32 (digest
[0]);
13980 digest
[1] = byte_swap_32 (digest
[1]);
13981 digest
[2] = byte_swap_32 (digest
[2]);
13982 digest
[3] = byte_swap_32 (digest
[3]);
13984 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13986 uint salt_len
= input_len
- 32 - 1;
13988 char *salt_buf
= input_buf
+ 32 + 1;
13990 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13992 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13994 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13996 salt
->salt_len
= salt_len
;
13998 return (PARSER_OK
);
14001 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14003 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14005 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
14009 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
14012 u32
*digest
= (u32
*) hash_buf
->digest
;
14014 salt_t
*salt
= hash_buf
->salt
;
14016 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14017 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14018 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14019 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14020 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14022 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14024 uint salt_len
= input_len
- 40 - 1;
14026 char *salt_buf
= input_buf
+ 40 + 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 hmacsha256_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_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
14047 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) 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]);
14059 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
14060 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
14061 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
14063 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14065 uint salt_len
= input_len
- 64 - 1;
14067 char *salt_buf
= input_buf
+ 64 + 1;
14069 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14071 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14073 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14075 salt
->salt_len
= salt_len
;
14077 return (PARSER_OK
);
14080 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14082 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14084 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
14088 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
14091 u64
*digest
= (u64
*) hash_buf
->digest
;
14093 salt_t
*salt
= hash_buf
->salt
;
14095 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
14096 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
14097 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
14098 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
14099 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
14100 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
14101 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
14102 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
14104 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14106 uint salt_len
= input_len
- 128 - 1;
14108 char *salt_buf
= input_buf
+ 128 + 1;
14110 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14112 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14114 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14116 salt
->salt_len
= salt_len
;
14118 return (PARSER_OK
);
14121 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14123 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
14125 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
14127 u32
*digest
= (u32
*) hash_buf
->digest
;
14129 salt_t
*salt
= hash_buf
->salt
;
14131 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
14137 char *user_pos
= input_buf
+ 10 + 1;
14139 char *realm_pos
= strchr (user_pos
, '$');
14141 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14143 uint user_len
= realm_pos
- user_pos
;
14145 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
14149 char *salt_pos
= strchr (realm_pos
, '$');
14151 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14153 uint realm_len
= salt_pos
- realm_pos
;
14155 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
14159 char *data_pos
= strchr (salt_pos
, '$');
14161 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14163 uint salt_len
= data_pos
- salt_pos
;
14165 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
14169 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
14171 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
14177 memcpy (krb5pa
->user
, user_pos
, user_len
);
14178 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
14179 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
14181 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
14183 for (uint i
= 0; i
< (36 * 2); i
+= 2)
14185 const char p0
= data_pos
[i
+ 0];
14186 const char p1
= data_pos
[i
+ 1];
14188 *timestamp_ptr
++ = hex_convert (p1
) << 0
14189 | hex_convert (p0
) << 4;
14192 char *checksum_ptr
= (char *) krb5pa
->checksum
;
14194 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
14196 const char p0
= data_pos
[i
+ 0];
14197 const char p1
= data_pos
[i
+ 1];
14199 *checksum_ptr
++ = hex_convert (p1
) << 0
14200 | hex_convert (p0
) << 4;
14204 * copy some data to generic buffers to make sorting happy
14207 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
14208 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
14209 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
14210 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
14211 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
14212 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
14213 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
14214 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
14215 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
14217 salt
->salt_len
= 36;
14219 digest
[0] = krb5pa
->checksum
[0];
14220 digest
[1] = krb5pa
->checksum
[1];
14221 digest
[2] = krb5pa
->checksum
[2];
14222 digest
[3] = krb5pa
->checksum
[3];
14224 return (PARSER_OK
);
14227 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14229 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
14231 u32
*digest
= (u32
*) hash_buf
->digest
;
14233 salt_t
*salt
= hash_buf
->salt
;
14239 char *salt_pos
= input_buf
;
14241 char *hash_pos
= strchr (salt_pos
, '$');
14243 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14245 uint salt_len
= hash_pos
- salt_pos
;
14247 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14251 uint hash_len
= input_len
- 1 - salt_len
;
14253 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14261 for (uint i
= 0; i
< salt_len
; i
++)
14263 if (salt_pos
[i
] == ' ') continue;
14268 // SAP user names cannot be longer than 12 characters
14269 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14271 // SAP user name cannot start with ! or ?
14272 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14278 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14280 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14282 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14284 salt
->salt_len
= salt_len
;
14286 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
14287 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
14291 digest
[0] = byte_swap_32 (digest
[0]);
14292 digest
[1] = byte_swap_32 (digest
[1]);
14294 return (PARSER_OK
);
14297 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14299 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
14301 u32
*digest
= (u32
*) hash_buf
->digest
;
14303 salt_t
*salt
= hash_buf
->salt
;
14309 char *salt_pos
= input_buf
;
14311 char *hash_pos
= strchr (salt_pos
, '$');
14313 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14315 uint salt_len
= hash_pos
- salt_pos
;
14317 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14321 uint hash_len
= input_len
- 1 - salt_len
;
14323 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
14331 for (uint i
= 0; i
< salt_len
; i
++)
14333 if (salt_pos
[i
] == ' ') continue;
14338 // SAP user names cannot be longer than 12 characters
14339 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
14340 // so far nobody complained so we stay with this because it helps in optimization
14341 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
14343 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14345 // SAP user name cannot start with ! or ?
14346 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14352 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14354 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14356 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14358 salt
->salt_len
= salt_len
;
14360 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14361 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14362 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14363 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14364 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14366 return (PARSER_OK
);
14369 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14371 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
14373 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14375 u64
*digest
= (u64
*) hash_buf
->digest
;
14377 salt_t
*salt
= hash_buf
->salt
;
14379 char *iter_pos
= input_buf
+ 3;
14381 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
14383 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
14385 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
14387 salt
->salt_iter
= salt_iter
;
14389 char *salt_pos
= iter_pos
+ 1;
14393 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
14395 salt
->salt_len
= salt_len
;
14397 char *hash_pos
= salt_pos
+ salt_len
;
14399 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14403 char *tmp
= (char *) salt
->salt_buf_pc
;
14405 tmp
[0] = hash_pos
[42];
14409 digest
[ 0] = byte_swap_64 (digest
[ 0]);
14410 digest
[ 1] = byte_swap_64 (digest
[ 1]);
14411 digest
[ 2] = byte_swap_64 (digest
[ 2]);
14412 digest
[ 3] = byte_swap_64 (digest
[ 3]);
14418 return (PARSER_OK
);
14421 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14423 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
14425 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14427 u32
*digest
= (u32
*) hash_buf
->digest
;
14429 salt_t
*salt
= hash_buf
->salt
;
14431 char *salt_buf
= input_buf
+ 6;
14433 uint salt_len
= 16;
14435 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14437 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14439 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14441 salt
->salt_len
= salt_len
;
14443 char *hash_pos
= input_buf
+ 6 + 16;
14445 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14446 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14447 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14448 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14449 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14450 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
14451 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
14452 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
14454 return (PARSER_OK
);
14457 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14459 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
14461 u32
*digest
= (u32
*) hash_buf
->digest
;
14463 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14464 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14468 return (PARSER_OK
);
14471 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14473 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
14475 u32
*digest
= (u32
*) hash_buf
->digest
;
14477 salt_t
*salt
= hash_buf
->salt
;
14479 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
14481 char *saltbuf_pos
= input_buf
;
14483 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
14485 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14487 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14489 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14490 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14492 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14496 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14498 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14500 char *salt_ptr
= (char *) saltbuf_pos
;
14501 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14506 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14508 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14511 rakp_ptr
[j
] = 0x80;
14513 rakp
->salt_len
= j
;
14515 for (i
= 0; i
< 64; i
++)
14517 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14520 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14521 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14522 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14523 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14524 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14525 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14526 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14527 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14529 salt
->salt_len
= 32; // muss min. 32 haben
14531 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14532 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14533 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14534 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14535 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14537 return (PARSER_OK
);
14540 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14542 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14544 u32
*digest
= (u32
*) hash_buf
->digest
;
14546 salt_t
*salt
= hash_buf
->salt
;
14548 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14550 char *salt_pos
= input_buf
+ 1;
14552 memcpy (salt
->salt_buf
, salt_pos
, 8);
14554 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14555 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14557 salt
->salt_len
= 8;
14559 char *hash_pos
= salt_pos
+ 8;
14561 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14562 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14563 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14564 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14565 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14567 digest
[0] -= SHA1M_A
;
14568 digest
[1] -= SHA1M_B
;
14569 digest
[2] -= SHA1M_C
;
14570 digest
[3] -= SHA1M_D
;
14571 digest
[4] -= SHA1M_E
;
14573 return (PARSER_OK
);
14576 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14578 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14580 u32
*digest
= (u32
*) hash_buf
->digest
;
14582 salt_t
*salt
= hash_buf
->salt
;
14584 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14585 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14586 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14587 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14589 digest
[0] = byte_swap_32 (digest
[0]);
14590 digest
[1] = byte_swap_32 (digest
[1]);
14591 digest
[2] = byte_swap_32 (digest
[2]);
14592 digest
[3] = byte_swap_32 (digest
[3]);
14594 digest
[0] -= MD5M_A
;
14595 digest
[1] -= MD5M_B
;
14596 digest
[2] -= MD5M_C
;
14597 digest
[3] -= MD5M_D
;
14599 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14601 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14603 u32
*salt_buf
= salt
->salt_buf
;
14605 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14606 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14607 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14608 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14610 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14611 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14612 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14613 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14615 salt
->salt_len
= 16 + 1;
14617 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14619 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14621 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14623 return (PARSER_OK
);
14626 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14628 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14630 u32
*digest
= (u32
*) hash_buf
->digest
;
14632 salt_t
*salt
= hash_buf
->salt
;
14634 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14640 char *hashbuf_pos
= input_buf
;
14642 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14644 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14646 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14648 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14652 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14654 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14656 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14658 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14662 char *databuf_pos
= strchr (iteration_pos
, ':');
14664 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14666 const uint iteration_len
= databuf_pos
- iteration_pos
;
14668 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14669 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14671 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14673 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14674 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14680 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14681 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14682 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14683 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14684 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14685 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14686 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14687 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14691 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14693 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14695 const char p0
= saltbuf_pos
[i
+ 0];
14696 const char p1
= saltbuf_pos
[i
+ 1];
14698 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14699 | hex_convert (p0
) << 4;
14702 salt
->salt_buf
[4] = 0x01000000;
14703 salt
->salt_buf
[5] = 0x80;
14705 salt
->salt_len
= saltbuf_len
/ 2;
14709 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14713 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14715 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14717 const char p0
= databuf_pos
[i
+ 0];
14718 const char p1
= databuf_pos
[i
+ 1];
14720 *databuf_ptr
++ = hex_convert (p1
) << 0
14721 | hex_convert (p0
) << 4;
14724 *databuf_ptr
++ = 0x80;
14726 for (uint i
= 0; i
< 512; i
++)
14728 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14731 cloudkey
->data_len
= databuf_len
/ 2;
14733 return (PARSER_OK
);
14736 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14738 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14740 u32
*digest
= (u32
*) hash_buf
->digest
;
14742 salt_t
*salt
= hash_buf
->salt
;
14748 char *hashbuf_pos
= input_buf
;
14750 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14752 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14754 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14756 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14760 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14762 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14764 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14766 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14768 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14772 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14774 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14776 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14778 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14780 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14784 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14786 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14787 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14789 // ok, the plan for this algorithm is the following:
14790 // we have 2 salts here, the domain-name and a random salt
14791 // while both are used in the initial transformation,
14792 // only the random salt is used in the following iterations
14793 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14794 // and one that includes only the real salt (stored into salt_buf[]).
14795 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14797 u8 tmp_buf
[100] = { 0 };
14799 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14801 memcpy (digest
, tmp_buf
, 20);
14803 digest
[0] = byte_swap_32 (digest
[0]);
14804 digest
[1] = byte_swap_32 (digest
[1]);
14805 digest
[2] = byte_swap_32 (digest
[2]);
14806 digest
[3] = byte_swap_32 (digest
[3]);
14807 digest
[4] = byte_swap_32 (digest
[4]);
14811 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14813 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14815 char *len_ptr
= NULL
;
14817 for (uint i
= 0; i
< domainbuf_len
; i
++)
14819 if (salt_buf_pc_ptr
[i
] == '.')
14821 len_ptr
= &salt_buf_pc_ptr
[i
];
14831 salt
->salt_buf_pc
[7] = domainbuf_len
;
14835 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14837 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14839 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14841 salt
->salt_len
= salt_len
;
14845 salt
->salt_iter
= atoi (iteration_pos
);
14847 return (PARSER_OK
);
14850 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14852 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14854 u32
*digest
= (u32
*) hash_buf
->digest
;
14856 salt_t
*salt
= hash_buf
->salt
;
14858 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14859 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14860 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14861 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14862 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14864 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14866 uint salt_len
= input_len
- 40 - 1;
14868 char *salt_buf
= input_buf
+ 40 + 1;
14870 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14872 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14874 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14876 salt
->salt_len
= salt_len
;
14878 return (PARSER_OK
);
14881 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14883 const u8 ascii_to_ebcdic
[] =
14885 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14886 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14887 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14888 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14889 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14890 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14891 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14892 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14893 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14894 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14895 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14896 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14897 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14898 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14899 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14900 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14903 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14905 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14907 u32
*digest
= (u32
*) hash_buf
->digest
;
14909 salt_t
*salt
= hash_buf
->salt
;
14911 char *salt_pos
= input_buf
+ 6 + 1;
14913 char *digest_pos
= strchr (salt_pos
, '*');
14915 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14917 uint salt_len
= digest_pos
- salt_pos
;
14919 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14921 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14923 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14927 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14928 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14930 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14932 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14934 salt
->salt_len
= salt_len
;
14936 for (uint i
= 0; i
< salt_len
; i
++)
14938 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14940 for (uint i
= salt_len
; i
< 8; i
++)
14942 salt_buf_pc_ptr
[i
] = 0x40;
14947 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14949 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14950 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14952 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14953 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14955 digest
[0] = byte_swap_32 (digest
[0]);
14956 digest
[1] = byte_swap_32 (digest
[1]);
14958 IP (digest
[0], digest
[1], tt
);
14960 digest
[0] = rotr32 (digest
[0], 29);
14961 digest
[1] = rotr32 (digest
[1], 29);
14965 return (PARSER_OK
);
14968 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14970 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14972 u32
*digest
= (u32
*) hash_buf
->digest
;
14974 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14975 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14976 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14977 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14979 digest
[0] = byte_swap_32 (digest
[0]);
14980 digest
[1] = byte_swap_32 (digest
[1]);
14981 digest
[2] = byte_swap_32 (digest
[2]);
14982 digest
[3] = byte_swap_32 (digest
[3]);
14984 return (PARSER_OK
);
14987 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14989 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14991 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14993 u32
*digest
= (u32
*) hash_buf
->digest
;
14995 salt_t
*salt
= hash_buf
->salt
;
14997 u8 tmp_buf
[120] = { 0 };
14999 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15001 tmp_buf
[3] += -4; // dont ask!
15003 memcpy (salt
->salt_buf
, tmp_buf
, 5);
15005 salt
->salt_len
= 5;
15007 memcpy (digest
, tmp_buf
+ 5, 9);
15009 // yes, only 9 byte are needed to crack, but 10 to display
15011 salt
->salt_buf_pc
[7] = input_buf
[20];
15013 return (PARSER_OK
);
15016 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15018 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
15020 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15022 u32
*digest
= (u32
*) hash_buf
->digest
;
15024 salt_t
*salt
= hash_buf
->salt
;
15026 u8 tmp_buf
[120] = { 0 };
15028 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15030 tmp_buf
[3] += -4; // dont ask!
15034 memcpy (salt
->salt_buf
, tmp_buf
, 16);
15036 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)
15040 char tmp_iter_buf
[11] = { 0 };
15042 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
15044 tmp_iter_buf
[10] = 0;
15046 salt
->salt_iter
= atoi (tmp_iter_buf
);
15048 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
15050 return (PARSER_SALT_ITERATION
);
15053 salt
->salt_iter
--; // first round in init
15055 // 2 additional bytes for display only
15057 salt
->salt_buf_pc
[0] = tmp_buf
[26];
15058 salt
->salt_buf_pc
[1] = tmp_buf
[27];
15062 memcpy (digest
, tmp_buf
+ 28, 8);
15064 digest
[0] = byte_swap_32 (digest
[0]);
15065 digest
[1] = byte_swap_32 (digest
[1]);
15069 return (PARSER_OK
);
15072 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15074 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
15076 u32
*digest
= (u32
*) hash_buf
->digest
;
15078 salt_t
*salt
= hash_buf
->salt
;
15080 char *salt_buf_pos
= input_buf
;
15082 char *hash_buf_pos
= salt_buf_pos
+ 6;
15084 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
15085 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
15086 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
15087 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
15088 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
15089 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
15090 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
15091 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
15093 digest
[0] -= SHA256M_A
;
15094 digest
[1] -= SHA256M_B
;
15095 digest
[2] -= SHA256M_C
;
15096 digest
[3] -= SHA256M_D
;
15097 digest
[4] -= SHA256M_E
;
15098 digest
[5] -= SHA256M_F
;
15099 digest
[6] -= SHA256M_G
;
15100 digest
[7] -= SHA256M_H
;
15102 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15104 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
15106 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15108 salt
->salt_len
= salt_len
;
15110 return (PARSER_OK
);
15113 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15115 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
15117 u32
*digest
= (u32
*) hash_buf
->digest
;
15119 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15121 salt_t
*salt
= hash_buf
->salt
;
15123 char *salt_buf
= input_buf
+ 6;
15125 char *digest_buf
= strchr (salt_buf
, '$');
15127 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15129 uint salt_len
= digest_buf
- salt_buf
;
15131 digest_buf
++; // skip the '$' symbol
15133 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15135 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15137 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15139 salt
->salt_len
= salt_len
;
15141 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15142 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15143 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15144 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15146 digest
[0] = byte_swap_32 (digest
[0]);
15147 digest
[1] = byte_swap_32 (digest
[1]);
15148 digest
[2] = byte_swap_32 (digest
[2]);
15149 digest
[3] = byte_swap_32 (digest
[3]);
15151 digest
[0] -= MD5M_A
;
15152 digest
[1] -= MD5M_B
;
15153 digest
[2] -= MD5M_C
;
15154 digest
[3] -= MD5M_D
;
15156 return (PARSER_OK
);
15159 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15161 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
15163 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15165 u32
*digest
= (u32
*) hash_buf
->digest
;
15167 salt_t
*salt
= hash_buf
->salt
;
15169 char *salt_buf
= input_buf
+ 3;
15171 char *digest_buf
= strchr (salt_buf
, '$');
15173 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15175 uint salt_len
= digest_buf
- salt_buf
;
15177 digest_buf
++; // skip the '$' symbol
15179 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15181 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15183 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15185 salt_buf_ptr
[salt_len
] = 0x2d;
15187 salt
->salt_len
= salt_len
+ 1;
15189 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15190 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15191 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15192 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15194 digest
[0] = byte_swap_32 (digest
[0]);
15195 digest
[1] = byte_swap_32 (digest
[1]);
15196 digest
[2] = byte_swap_32 (digest
[2]);
15197 digest
[3] = byte_swap_32 (digest
[3]);
15199 digest
[0] -= MD5M_A
;
15200 digest
[1] -= MD5M_B
;
15201 digest
[2] -= MD5M_C
;
15202 digest
[3] -= MD5M_D
;
15204 return (PARSER_OK
);
15207 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15209 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
15211 u32
*digest
= (u32
*) hash_buf
->digest
;
15213 salt_t
*salt
= hash_buf
->salt
;
15215 u8 tmp_buf
[100] = { 0 };
15217 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
15219 memcpy (digest
, tmp_buf
, 20);
15221 digest
[0] = byte_swap_32 (digest
[0]);
15222 digest
[1] = byte_swap_32 (digest
[1]);
15223 digest
[2] = byte_swap_32 (digest
[2]);
15224 digest
[3] = byte_swap_32 (digest
[3]);
15225 digest
[4] = byte_swap_32 (digest
[4]);
15227 digest
[0] -= SHA1M_A
;
15228 digest
[1] -= SHA1M_B
;
15229 digest
[2] -= SHA1M_C
;
15230 digest
[3] -= SHA1M_D
;
15231 digest
[4] -= SHA1M_E
;
15233 salt
->salt_buf
[0] = 0x80;
15235 salt
->salt_len
= 0;
15237 return (PARSER_OK
);
15240 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15242 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
15244 u32
*digest
= (u32
*) hash_buf
->digest
;
15246 salt_t
*salt
= hash_buf
->salt
;
15248 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15249 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15250 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15251 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15253 digest
[0] = byte_swap_32 (digest
[0]);
15254 digest
[1] = byte_swap_32 (digest
[1]);
15255 digest
[2] = byte_swap_32 (digest
[2]);
15256 digest
[3] = byte_swap_32 (digest
[3]);
15258 digest
[0] -= MD5M_A
;
15259 digest
[1] -= MD5M_B
;
15260 digest
[2] -= MD5M_C
;
15261 digest
[3] -= MD5M_D
;
15263 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15265 uint salt_len
= input_len
- 32 - 1;
15267 char *salt_buf
= input_buf
+ 32 + 1;
15269 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15271 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15273 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15276 * add static "salt" part
15279 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
15283 salt
->salt_len
= salt_len
;
15285 return (PARSER_OK
);
15288 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15290 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
15292 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
15294 u32
*digest
= (u32
*) hash_buf
->digest
;
15296 salt_t
*salt
= hash_buf
->salt
;
15298 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
15304 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
15306 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
15308 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15310 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
15312 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
15316 char *keylen_pos
= strchr (saltbuf_pos
, '$');
15318 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15320 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
15322 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15326 char *keybuf_pos
= strchr (keylen_pos
, '$');
15328 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15330 uint keylen_len
= keybuf_pos
- keylen_pos
;
15332 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
15336 char *databuf_pos
= strchr (keybuf_pos
, '$');
15338 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15340 uint keybuf_len
= databuf_pos
- keybuf_pos
;
15342 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15346 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
15348 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
15354 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
15355 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
15356 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
15357 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
15359 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
15360 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
15361 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
15362 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
15364 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15365 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15366 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15367 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15369 salt
->salt_len
= 16;
15370 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
15372 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
15374 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
15377 return (PARSER_OK
);
15380 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15382 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
15384 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15386 u32
*digest
= (u32
*) hash_buf
->digest
;
15388 salt_t
*salt
= hash_buf
->salt
;
15394 // first is the N salt parameter
15396 char *N_pos
= input_buf
+ 6;
15398 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15402 salt
->scrypt_N
= atoi (N_pos
);
15406 char *r_pos
= strchr (N_pos
, ':');
15408 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15412 salt
->scrypt_r
= atoi (r_pos
);
15416 char *p_pos
= strchr (r_pos
, ':');
15418 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15422 salt
->scrypt_p
= atoi (p_pos
);
15426 char *saltbuf_pos
= strchr (p_pos
, ':');
15428 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15432 char *hash_pos
= strchr (saltbuf_pos
, ':');
15434 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15440 int salt_len_base64
= hash_pos
- saltbuf_pos
;
15442 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
15444 u8 tmp_buf
[33] = { 0 };
15446 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
15448 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15450 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
15452 salt
->salt_len
= tmp_len
;
15453 salt
->salt_iter
= 1;
15455 // digest - base64 decode
15457 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15459 tmp_len
= input_len
- (hash_pos
- input_buf
);
15461 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
15463 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
15465 memcpy (digest
, tmp_buf
, 32);
15467 return (PARSER_OK
);
15470 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15472 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
15474 u32
*digest
= (u32
*) hash_buf
->digest
;
15476 salt_t
*salt
= hash_buf
->salt
;
15482 char decrypted
[76] = { 0 }; // iv + hash
15484 juniper_decrypt_hash (input_buf
, decrypted
);
15486 char *md5crypt_hash
= decrypted
+ 12;
15488 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15490 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15492 char *salt_pos
= md5crypt_hash
+ 3;
15494 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15496 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15498 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15502 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15504 return (PARSER_OK
);
15507 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15509 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15511 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15513 u32
*digest
= (u32
*) hash_buf
->digest
;
15515 salt_t
*salt
= hash_buf
->salt
;
15517 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15523 // first is *raw* salt
15525 char *salt_pos
= input_buf
+ 3;
15527 char *hash_pos
= strchr (salt_pos
, '$');
15529 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15531 uint salt_len
= hash_pos
- salt_pos
;
15533 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15537 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15539 memcpy (salt_buf_ptr
, salt_pos
, 14);
15541 salt_buf_ptr
[17] = 0x01;
15542 salt_buf_ptr
[18] = 0x80;
15544 // add some stuff to normal salt to make sorted happy
15546 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15547 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15548 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15549 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15551 salt
->salt_len
= salt_len
;
15552 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15554 // base64 decode hash
15556 u8 tmp_buf
[100] = { 0 };
15558 uint hash_len
= input_len
- 3 - salt_len
- 1;
15560 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15562 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15564 memcpy (digest
, tmp_buf
, 32);
15566 digest
[0] = byte_swap_32 (digest
[0]);
15567 digest
[1] = byte_swap_32 (digest
[1]);
15568 digest
[2] = byte_swap_32 (digest
[2]);
15569 digest
[3] = byte_swap_32 (digest
[3]);
15570 digest
[4] = byte_swap_32 (digest
[4]);
15571 digest
[5] = byte_swap_32 (digest
[5]);
15572 digest
[6] = byte_swap_32 (digest
[6]);
15573 digest
[7] = byte_swap_32 (digest
[7]);
15575 return (PARSER_OK
);
15578 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15580 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15582 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15584 u32
*digest
= (u32
*) hash_buf
->digest
;
15586 salt_t
*salt
= hash_buf
->salt
;
15592 // first is *raw* salt
15594 char *salt_pos
= input_buf
+ 3;
15596 char *hash_pos
= strchr (salt_pos
, '$');
15598 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15600 uint salt_len
= hash_pos
- salt_pos
;
15602 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15604 salt
->salt_len
= salt_len
;
15607 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15609 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15610 salt_buf_ptr
[salt_len
] = 0;
15612 // base64 decode hash
15614 u8 tmp_buf
[100] = { 0 };
15616 uint hash_len
= input_len
- 3 - salt_len
- 1;
15618 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15620 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15622 memcpy (digest
, tmp_buf
, 32);
15625 salt
->scrypt_N
= 16384;
15626 salt
->scrypt_r
= 1;
15627 salt
->scrypt_p
= 1;
15628 salt
->salt_iter
= 1;
15630 return (PARSER_OK
);
15633 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15635 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15637 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15639 u32
*digest
= (u32
*) hash_buf
->digest
;
15641 salt_t
*salt
= hash_buf
->salt
;
15643 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15649 char *version_pos
= input_buf
+ 8 + 1;
15651 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15653 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15655 u32 version_len
= verifierHashSize_pos
- version_pos
;
15657 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15659 verifierHashSize_pos
++;
15661 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15663 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15665 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15667 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15671 char *saltSize_pos
= strchr (keySize_pos
, '*');
15673 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15675 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15677 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15681 char *osalt_pos
= strchr (saltSize_pos
, '*');
15683 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15685 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15687 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15691 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15693 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15695 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15697 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15699 encryptedVerifier_pos
++;
15701 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15703 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15705 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15707 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15709 encryptedVerifierHash_pos
++;
15711 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;
15713 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15715 const uint version
= atoi (version_pos
);
15717 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15719 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15721 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15723 const uint keySize
= atoi (keySize_pos
);
15725 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15727 office2007
->keySize
= keySize
;
15729 const uint saltSize
= atoi (saltSize_pos
);
15731 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15737 salt
->salt_len
= 16;
15738 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15740 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15741 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15742 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15743 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15749 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15750 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15751 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15752 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15754 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15755 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15756 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15757 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15758 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15764 digest
[0] = office2007
->encryptedVerifierHash
[0];
15765 digest
[1] = office2007
->encryptedVerifierHash
[1];
15766 digest
[2] = office2007
->encryptedVerifierHash
[2];
15767 digest
[3] = office2007
->encryptedVerifierHash
[3];
15769 return (PARSER_OK
);
15772 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15774 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15776 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15778 u32
*digest
= (u32
*) hash_buf
->digest
;
15780 salt_t
*salt
= hash_buf
->salt
;
15782 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15788 char *version_pos
= input_buf
+ 8 + 1;
15790 char *spinCount_pos
= strchr (version_pos
, '*');
15792 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15794 u32 version_len
= spinCount_pos
- version_pos
;
15796 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15800 char *keySize_pos
= strchr (spinCount_pos
, '*');
15802 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15804 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15806 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15810 char *saltSize_pos
= strchr (keySize_pos
, '*');
15812 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15814 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15816 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15820 char *osalt_pos
= strchr (saltSize_pos
, '*');
15822 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15824 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15826 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15830 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15832 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15834 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15836 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15838 encryptedVerifier_pos
++;
15840 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15842 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15844 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15846 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15848 encryptedVerifierHash_pos
++;
15850 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;
15852 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15854 const uint version
= atoi (version_pos
);
15856 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15858 const uint spinCount
= atoi (spinCount_pos
);
15860 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15862 const uint keySize
= atoi (keySize_pos
);
15864 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15866 const uint saltSize
= atoi (saltSize_pos
);
15868 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15874 salt
->salt_len
= 16;
15875 salt
->salt_iter
= spinCount
;
15877 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15878 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15879 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15880 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15886 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15887 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15888 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15889 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15891 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15892 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15893 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15894 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15895 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15896 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15897 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15898 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15904 digest
[0] = office2010
->encryptedVerifierHash
[0];
15905 digest
[1] = office2010
->encryptedVerifierHash
[1];
15906 digest
[2] = office2010
->encryptedVerifierHash
[2];
15907 digest
[3] = office2010
->encryptedVerifierHash
[3];
15909 return (PARSER_OK
);
15912 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15914 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15916 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15918 u32
*digest
= (u32
*) hash_buf
->digest
;
15920 salt_t
*salt
= hash_buf
->salt
;
15922 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15928 char *version_pos
= input_buf
+ 8 + 1;
15930 char *spinCount_pos
= strchr (version_pos
, '*');
15932 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15934 u32 version_len
= spinCount_pos
- version_pos
;
15936 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15940 char *keySize_pos
= strchr (spinCount_pos
, '*');
15942 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15944 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15946 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15950 char *saltSize_pos
= strchr (keySize_pos
, '*');
15952 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15954 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15956 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15960 char *osalt_pos
= strchr (saltSize_pos
, '*');
15962 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15964 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15966 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15970 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15972 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15974 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15976 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15978 encryptedVerifier_pos
++;
15980 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15982 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15984 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15986 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15988 encryptedVerifierHash_pos
++;
15990 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;
15992 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15994 const uint version
= atoi (version_pos
);
15996 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15998 const uint spinCount
= atoi (spinCount_pos
);
16000 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
16002 const uint keySize
= atoi (keySize_pos
);
16004 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
16006 const uint saltSize
= atoi (saltSize_pos
);
16008 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
16014 salt
->salt_len
= 16;
16015 salt
->salt_iter
= spinCount
;
16017 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16018 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16019 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16020 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16026 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16027 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16028 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16029 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16031 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16032 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16033 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16034 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16035 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16036 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
16037 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
16038 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
16044 digest
[0] = office2013
->encryptedVerifierHash
[0];
16045 digest
[1] = office2013
->encryptedVerifierHash
[1];
16046 digest
[2] = office2013
->encryptedVerifierHash
[2];
16047 digest
[3] = office2013
->encryptedVerifierHash
[3];
16049 return (PARSER_OK
);
16052 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16054 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
16056 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16058 u32
*digest
= (u32
*) hash_buf
->digest
;
16060 salt_t
*salt
= hash_buf
->salt
;
16062 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16068 char *version_pos
= input_buf
+ 11;
16070 char *osalt_pos
= strchr (version_pos
, '*');
16072 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16074 u32 version_len
= osalt_pos
- version_pos
;
16076 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16080 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16082 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16084 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16086 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16088 encryptedVerifier_pos
++;
16090 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16092 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16094 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16096 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16098 encryptedVerifierHash_pos
++;
16100 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16102 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16104 const uint version
= *version_pos
- 0x30;
16106 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16112 oldoffice01
->version
= version
;
16114 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16115 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16116 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16117 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16119 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16120 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16121 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16122 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16124 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16125 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16126 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16127 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16129 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16130 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16131 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16132 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16138 salt
->salt_len
= 16;
16140 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16141 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16142 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16143 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16145 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16146 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16147 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16148 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16150 // this is a workaround as office produces multiple documents with the same salt
16152 salt
->salt_len
+= 32;
16154 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16155 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16156 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16157 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16158 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16159 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16160 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16161 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16167 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
16168 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
16169 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
16170 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
16172 return (PARSER_OK
);
16175 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16177 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
16180 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16182 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
16184 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16186 u32
*digest
= (u32
*) hash_buf
->digest
;
16188 salt_t
*salt
= hash_buf
->salt
;
16190 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16196 char *version_pos
= input_buf
+ 11;
16198 char *osalt_pos
= strchr (version_pos
, '*');
16200 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16202 u32 version_len
= osalt_pos
- version_pos
;
16204 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16208 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16210 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16212 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16214 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16216 encryptedVerifier_pos
++;
16218 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16220 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16222 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16224 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16226 encryptedVerifierHash_pos
++;
16228 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16230 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16232 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16234 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16238 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16240 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16242 const uint version
= *version_pos
- 0x30;
16244 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16250 oldoffice01
->version
= version
;
16252 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16253 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16254 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16255 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16257 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16258 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16259 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16260 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16262 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16263 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16264 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16265 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16267 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16268 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16269 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16270 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16272 oldoffice01
->rc4key
[1] = 0;
16273 oldoffice01
->rc4key
[0] = 0;
16275 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16276 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16277 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16278 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16279 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16280 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16281 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16282 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16283 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16284 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16286 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
16287 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
16293 salt
->salt_len
= 16;
16295 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16296 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16297 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16298 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16300 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16301 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16302 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16303 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16305 // this is a workaround as office produces multiple documents with the same salt
16307 salt
->salt_len
+= 32;
16309 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16310 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16311 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16312 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16313 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16314 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16315 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16316 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16322 digest
[0] = oldoffice01
->rc4key
[0];
16323 digest
[1] = oldoffice01
->rc4key
[1];
16327 return (PARSER_OK
);
16330 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16332 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
16334 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16336 u32
*digest
= (u32
*) hash_buf
->digest
;
16338 salt_t
*salt
= hash_buf
->salt
;
16340 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16346 char *version_pos
= input_buf
+ 11;
16348 char *osalt_pos
= strchr (version_pos
, '*');
16350 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16352 u32 version_len
= osalt_pos
- version_pos
;
16354 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16358 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16360 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16362 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16364 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16366 encryptedVerifier_pos
++;
16368 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16370 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16372 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16374 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16376 encryptedVerifierHash_pos
++;
16378 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16380 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16382 const uint version
= *version_pos
- 0x30;
16384 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16390 oldoffice34
->version
= version
;
16392 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16393 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16394 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16395 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16397 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16398 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16399 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16400 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16402 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16403 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16404 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16405 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16406 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16408 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16409 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16410 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16411 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16412 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16418 salt
->salt_len
= 16;
16420 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16421 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16422 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16423 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16425 // this is a workaround as office produces multiple documents with the same salt
16427 salt
->salt_len
+= 32;
16429 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16430 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16431 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16432 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16433 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16434 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16435 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16436 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16442 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
16443 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
16444 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
16445 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
16447 return (PARSER_OK
);
16450 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16452 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16454 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
16457 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16459 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
16461 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16463 u32
*digest
= (u32
*) hash_buf
->digest
;
16465 salt_t
*salt
= hash_buf
->salt
;
16467 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16473 char *version_pos
= input_buf
+ 11;
16475 char *osalt_pos
= strchr (version_pos
, '*');
16477 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16479 u32 version_len
= osalt_pos
- version_pos
;
16481 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16485 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16487 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16489 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16491 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16493 encryptedVerifier_pos
++;
16495 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16497 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16499 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16501 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16503 encryptedVerifierHash_pos
++;
16505 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16507 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16509 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16511 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16515 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16517 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16519 const uint version
= *version_pos
- 0x30;
16521 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16527 oldoffice34
->version
= version
;
16529 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16530 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16531 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16532 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16534 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16535 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16536 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16537 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16539 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16540 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16541 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16542 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16543 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16545 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16546 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16547 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16548 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16549 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16551 oldoffice34
->rc4key
[1] = 0;
16552 oldoffice34
->rc4key
[0] = 0;
16554 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16555 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16556 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16557 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16558 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16559 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16560 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16561 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16562 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16563 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16565 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16566 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16572 salt
->salt_len
= 16;
16574 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16575 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16576 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16577 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16579 // this is a workaround as office produces multiple documents with the same salt
16581 salt
->salt_len
+= 32;
16583 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16584 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16585 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16586 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16587 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16588 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16589 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16590 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16596 digest
[0] = oldoffice34
->rc4key
[0];
16597 digest
[1] = oldoffice34
->rc4key
[1];
16601 return (PARSER_OK
);
16604 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16606 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16608 u32
*digest
= (u32
*) hash_buf
->digest
;
16610 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16611 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16612 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16613 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16615 digest
[0] = byte_swap_32 (digest
[0]);
16616 digest
[1] = byte_swap_32 (digest
[1]);
16617 digest
[2] = byte_swap_32 (digest
[2]);
16618 digest
[3] = byte_swap_32 (digest
[3]);
16620 return (PARSER_OK
);
16623 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16625 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16627 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16629 u32
*digest
= (u32
*) hash_buf
->digest
;
16631 salt_t
*salt
= hash_buf
->salt
;
16633 char *signature_pos
= input_buf
;
16635 char *salt_pos
= strchr (signature_pos
, '$');
16637 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16639 u32 signature_len
= salt_pos
- signature_pos
;
16641 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16645 char *hash_pos
= strchr (salt_pos
, '$');
16647 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16649 u32 salt_len
= hash_pos
- salt_pos
;
16651 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16655 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16657 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16659 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16660 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16661 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16662 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16663 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16665 digest
[0] -= SHA1M_A
;
16666 digest
[1] -= SHA1M_B
;
16667 digest
[2] -= SHA1M_C
;
16668 digest
[3] -= SHA1M_D
;
16669 digest
[4] -= SHA1M_E
;
16671 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16673 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16675 salt
->salt_len
= salt_len
;
16677 return (PARSER_OK
);
16680 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16682 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16684 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16686 u32
*digest
= (u32
*) hash_buf
->digest
;
16688 salt_t
*salt
= hash_buf
->salt
;
16690 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16696 char *iter_pos
= input_buf
+ 14;
16698 const int iter
= atoi (iter_pos
);
16700 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16702 salt
->salt_iter
= iter
- 1;
16704 char *salt_pos
= strchr (iter_pos
, '$');
16706 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16710 char *hash_pos
= strchr (salt_pos
, '$');
16712 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16714 const uint salt_len
= hash_pos
- salt_pos
;
16718 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16720 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16722 salt
->salt_len
= salt_len
;
16724 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16725 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16727 // add some stuff to normal salt to make sorted happy
16729 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16730 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16731 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16732 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16733 salt
->salt_buf
[4] = salt
->salt_iter
;
16735 // base64 decode hash
16737 u8 tmp_buf
[100] = { 0 };
16739 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16741 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16743 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16745 memcpy (digest
, tmp_buf
, 32);
16747 digest
[0] = byte_swap_32 (digest
[0]);
16748 digest
[1] = byte_swap_32 (digest
[1]);
16749 digest
[2] = byte_swap_32 (digest
[2]);
16750 digest
[3] = byte_swap_32 (digest
[3]);
16751 digest
[4] = byte_swap_32 (digest
[4]);
16752 digest
[5] = byte_swap_32 (digest
[5]);
16753 digest
[6] = byte_swap_32 (digest
[6]);
16754 digest
[7] = byte_swap_32 (digest
[7]);
16756 return (PARSER_OK
);
16759 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16761 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16763 u32
*digest
= (u32
*) hash_buf
->digest
;
16765 salt_t
*salt
= hash_buf
->salt
;
16767 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16768 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16772 digest
[0] = byte_swap_32 (digest
[0]);
16773 digest
[1] = byte_swap_32 (digest
[1]);
16775 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16776 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16777 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16779 char iter_c
= input_buf
[17];
16780 char iter_d
= input_buf
[19];
16782 // atm only defaults, let's see if there's more request
16783 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16784 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16786 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16788 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16789 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16790 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16791 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16793 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16794 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16795 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16796 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16798 salt
->salt_len
= 16;
16800 return (PARSER_OK
);
16803 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16805 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16807 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16809 u32
*digest
= (u32
*) hash_buf
->digest
;
16811 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16813 salt_t
*salt
= hash_buf
->salt
;
16815 char *salt_pos
= input_buf
+ 10;
16817 char *hash_pos
= strchr (salt_pos
, '$');
16819 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16821 uint salt_len
= hash_pos
- salt_pos
;
16825 uint hash_len
= input_len
- 10 - salt_len
- 1;
16827 // base64 decode salt
16829 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16831 u8 tmp_buf
[100] = { 0 };
16833 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16835 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16837 tmp_buf
[salt_len
] = 0x80;
16839 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16841 salt
->salt_len
= salt_len
;
16843 // base64 decode hash
16845 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16847 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16849 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16851 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16853 uint user_len
= hash_len
- 32;
16855 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16857 user_len
--; // skip the trailing space
16859 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16860 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16861 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16862 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16864 digest
[0] = byte_swap_32 (digest
[0]);
16865 digest
[1] = byte_swap_32 (digest
[1]);
16866 digest
[2] = byte_swap_32 (digest
[2]);
16867 digest
[3] = byte_swap_32 (digest
[3]);
16869 // store username for host only (output hash if cracked)
16871 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16872 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16874 return (PARSER_OK
);
16877 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16879 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16881 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16883 u32
*digest
= (u32
*) hash_buf
->digest
;
16885 salt_t
*salt
= hash_buf
->salt
;
16887 char *iter_pos
= input_buf
+ 10;
16889 u32 iter
= atoi (iter_pos
);
16893 return (PARSER_SALT_ITERATION
);
16896 iter
--; // first iteration is special
16898 salt
->salt_iter
= iter
;
16900 char *base64_pos
= strchr (iter_pos
, '}');
16902 if (base64_pos
== NULL
)
16904 return (PARSER_SIGNATURE_UNMATCHED
);
16909 // base64 decode salt
16911 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16913 u8 tmp_buf
[100] = { 0 };
16915 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16917 if (decoded_len
< 24)
16919 return (PARSER_SALT_LENGTH
);
16924 uint salt_len
= decoded_len
- 20;
16926 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16927 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16929 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16931 salt
->salt_len
= salt_len
;
16935 u32
*digest_ptr
= (u32
*) tmp_buf
;
16937 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16938 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16939 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16940 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16941 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16943 return (PARSER_OK
);
16946 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16948 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16950 u32
*digest
= (u32
*) hash_buf
->digest
;
16952 salt_t
*salt
= hash_buf
->salt
;
16954 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16955 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16956 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16957 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16958 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16960 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16962 uint salt_len
= input_len
- 40 - 1;
16964 char *salt_buf
= input_buf
+ 40 + 1;
16966 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16968 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16970 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16972 salt
->salt_len
= salt_len
;
16974 return (PARSER_OK
);
16977 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16979 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16981 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16983 u32
*digest
= (u32
*) hash_buf
->digest
;
16985 salt_t
*salt
= hash_buf
->salt
;
16987 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16993 char *V_pos
= input_buf
+ 5;
16995 char *R_pos
= strchr (V_pos
, '*');
16997 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16999 u32 V_len
= R_pos
- V_pos
;
17003 char *bits_pos
= strchr (R_pos
, '*');
17005 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17007 u32 R_len
= bits_pos
- R_pos
;
17011 char *P_pos
= strchr (bits_pos
, '*');
17013 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17015 u32 bits_len
= P_pos
- bits_pos
;
17019 char *enc_md_pos
= strchr (P_pos
, '*');
17021 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17023 u32 P_len
= enc_md_pos
- P_pos
;
17027 char *id_len_pos
= strchr (enc_md_pos
, '*');
17029 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17031 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17035 char *id_buf_pos
= strchr (id_len_pos
, '*');
17037 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17039 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17043 char *u_len_pos
= strchr (id_buf_pos
, '*');
17045 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17047 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17049 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17053 char *u_buf_pos
= strchr (u_len_pos
, '*');
17055 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17057 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17061 char *o_len_pos
= strchr (u_buf_pos
, '*');
17063 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17065 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17067 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17071 char *o_buf_pos
= strchr (o_len_pos
, '*');
17073 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17075 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17079 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;
17081 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17085 const int V
= atoi (V_pos
);
17086 const int R
= atoi (R_pos
);
17087 const int P
= atoi (P_pos
);
17089 if (V
!= 1) return (PARSER_SALT_VALUE
);
17090 if (R
!= 2) return (PARSER_SALT_VALUE
);
17092 const int enc_md
= atoi (enc_md_pos
);
17094 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17096 const int id_len
= atoi (id_len_pos
);
17097 const int u_len
= atoi (u_len_pos
);
17098 const int o_len
= atoi (o_len_pos
);
17100 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17101 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17102 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17104 const int bits
= atoi (bits_pos
);
17106 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17108 // copy data to esalt
17114 pdf
->enc_md
= enc_md
;
17116 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17117 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17118 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17119 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17120 pdf
->id_len
= id_len
;
17122 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17123 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17124 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17125 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17126 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17127 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17128 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17129 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17130 pdf
->u_len
= u_len
;
17132 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17133 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17134 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17135 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17136 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17137 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17138 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17139 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17140 pdf
->o_len
= o_len
;
17142 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17143 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17144 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17145 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17147 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17148 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17149 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17150 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17151 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17152 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17153 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17154 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17156 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17157 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17158 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17159 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17160 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17161 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17162 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17163 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17165 // we use ID for salt, maybe needs to change, we will see...
17167 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17168 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17169 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17170 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17171 salt
->salt_len
= pdf
->id_len
;
17173 digest
[0] = pdf
->u_buf
[0];
17174 digest
[1] = pdf
->u_buf
[1];
17175 digest
[2] = pdf
->u_buf
[2];
17176 digest
[3] = pdf
->u_buf
[3];
17178 return (PARSER_OK
);
17181 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17183 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
17186 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17188 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
17190 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17192 u32
*digest
= (u32
*) hash_buf
->digest
;
17194 salt_t
*salt
= hash_buf
->salt
;
17196 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17202 char *V_pos
= input_buf
+ 5;
17204 char *R_pos
= strchr (V_pos
, '*');
17206 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17208 u32 V_len
= R_pos
- V_pos
;
17212 char *bits_pos
= strchr (R_pos
, '*');
17214 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17216 u32 R_len
= bits_pos
- R_pos
;
17220 char *P_pos
= strchr (bits_pos
, '*');
17222 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17224 u32 bits_len
= P_pos
- bits_pos
;
17228 char *enc_md_pos
= strchr (P_pos
, '*');
17230 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17232 u32 P_len
= enc_md_pos
- P_pos
;
17236 char *id_len_pos
= strchr (enc_md_pos
, '*');
17238 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17240 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17244 char *id_buf_pos
= strchr (id_len_pos
, '*');
17246 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17248 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17252 char *u_len_pos
= strchr (id_buf_pos
, '*');
17254 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17256 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17258 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17262 char *u_buf_pos
= strchr (u_len_pos
, '*');
17264 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17266 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17270 char *o_len_pos
= strchr (u_buf_pos
, '*');
17272 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17274 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17276 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17280 char *o_buf_pos
= strchr (o_len_pos
, '*');
17282 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17284 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17288 char *rc4key_pos
= strchr (o_buf_pos
, ':');
17290 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17292 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
17294 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17298 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;
17300 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
17304 const int V
= atoi (V_pos
);
17305 const int R
= atoi (R_pos
);
17306 const int P
= atoi (P_pos
);
17308 if (V
!= 1) return (PARSER_SALT_VALUE
);
17309 if (R
!= 2) return (PARSER_SALT_VALUE
);
17311 const int enc_md
= atoi (enc_md_pos
);
17313 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17315 const int id_len
= atoi (id_len_pos
);
17316 const int u_len
= atoi (u_len_pos
);
17317 const int o_len
= atoi (o_len_pos
);
17319 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17320 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17321 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17323 const int bits
= atoi (bits_pos
);
17325 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17327 // copy data to esalt
17333 pdf
->enc_md
= enc_md
;
17335 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17336 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17337 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17338 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17339 pdf
->id_len
= id_len
;
17341 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17342 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17343 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17344 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17345 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17346 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17347 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17348 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17349 pdf
->u_len
= u_len
;
17351 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17352 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17353 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17354 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17355 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17356 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17357 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17358 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17359 pdf
->o_len
= o_len
;
17361 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17362 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17363 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17364 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17366 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17367 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17368 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17369 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17370 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17371 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17372 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17373 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17375 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17376 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17377 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17378 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17379 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17380 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17381 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17382 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17384 pdf
->rc4key
[1] = 0;
17385 pdf
->rc4key
[0] = 0;
17387 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
17388 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
17389 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
17390 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
17391 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
17392 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
17393 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
17394 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
17395 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
17396 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
17398 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
17399 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
17401 // we use ID for salt, maybe needs to change, we will see...
17403 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17404 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17405 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17406 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17407 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17408 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17409 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17410 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17411 salt
->salt_len
= pdf
->id_len
+ 16;
17413 digest
[0] = pdf
->rc4key
[0];
17414 digest
[1] = pdf
->rc4key
[1];
17418 return (PARSER_OK
);
17421 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17423 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
17425 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17427 u32
*digest
= (u32
*) hash_buf
->digest
;
17429 salt_t
*salt
= hash_buf
->salt
;
17431 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17437 char *V_pos
= input_buf
+ 5;
17439 char *R_pos
= strchr (V_pos
, '*');
17441 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17443 u32 V_len
= R_pos
- V_pos
;
17447 char *bits_pos
= strchr (R_pos
, '*');
17449 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17451 u32 R_len
= bits_pos
- R_pos
;
17455 char *P_pos
= strchr (bits_pos
, '*');
17457 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17459 u32 bits_len
= P_pos
- bits_pos
;
17463 char *enc_md_pos
= strchr (P_pos
, '*');
17465 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17467 u32 P_len
= enc_md_pos
- P_pos
;
17471 char *id_len_pos
= strchr (enc_md_pos
, '*');
17473 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17475 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17479 char *id_buf_pos
= strchr (id_len_pos
, '*');
17481 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17483 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17487 char *u_len_pos
= strchr (id_buf_pos
, '*');
17489 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17491 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17493 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17497 char *u_buf_pos
= strchr (u_len_pos
, '*');
17499 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17501 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17505 char *o_len_pos
= strchr (u_buf_pos
, '*');
17507 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17509 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17511 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17515 char *o_buf_pos
= strchr (o_len_pos
, '*');
17517 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17519 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17523 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;
17525 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17529 const int V
= atoi (V_pos
);
17530 const int R
= atoi (R_pos
);
17531 const int P
= atoi (P_pos
);
17535 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17536 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17538 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17540 const int id_len
= atoi (id_len_pos
);
17541 const int u_len
= atoi (u_len_pos
);
17542 const int o_len
= atoi (o_len_pos
);
17544 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17546 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17547 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17549 const int bits
= atoi (bits_pos
);
17551 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17557 enc_md
= atoi (enc_md_pos
);
17560 // copy data to esalt
17566 pdf
->enc_md
= enc_md
;
17568 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17569 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17570 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17571 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17575 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17576 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17577 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17578 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17581 pdf
->id_len
= id_len
;
17583 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17584 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17585 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17586 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17587 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17588 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17589 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17590 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17591 pdf
->u_len
= u_len
;
17593 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17594 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17595 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17596 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17597 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17598 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17599 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17600 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17601 pdf
->o_len
= o_len
;
17603 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17604 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17605 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17606 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17610 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17611 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17612 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17613 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17616 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17617 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17618 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17619 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17620 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17621 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17622 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17623 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17625 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17626 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17627 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17628 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17629 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17630 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17631 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17632 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17634 // precompute rc4 data for later use
17650 uint salt_pc_block
[32] = { 0 };
17652 char *salt_pc_ptr
= (char *) salt_pc_block
;
17654 memcpy (salt_pc_ptr
, padding
, 32);
17655 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17657 uint salt_pc_digest
[4] = { 0 };
17659 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17661 pdf
->rc4data
[0] = salt_pc_digest
[0];
17662 pdf
->rc4data
[1] = salt_pc_digest
[1];
17664 // we use ID for salt, maybe needs to change, we will see...
17666 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17667 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17668 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17669 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17670 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17671 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17672 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17673 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17674 salt
->salt_len
= pdf
->id_len
+ 16;
17676 salt
->salt_iter
= ROUNDS_PDF14
;
17678 digest
[0] = pdf
->u_buf
[0];
17679 digest
[1] = pdf
->u_buf
[1];
17683 return (PARSER_OK
);
17686 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17688 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17690 if (ret
!= PARSER_OK
)
17695 u32
*digest
= (u32
*) hash_buf
->digest
;
17697 salt_t
*salt
= hash_buf
->salt
;
17699 digest
[0] -= SHA256M_A
;
17700 digest
[1] -= SHA256M_B
;
17701 digest
[2] -= SHA256M_C
;
17702 digest
[3] -= SHA256M_D
;
17703 digest
[4] -= SHA256M_E
;
17704 digest
[5] -= SHA256M_F
;
17705 digest
[6] -= SHA256M_G
;
17706 digest
[7] -= SHA256M_H
;
17708 salt
->salt_buf
[2] = 0x80;
17710 return (PARSER_OK
);
17713 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17715 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17717 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17719 u32
*digest
= (u32
*) hash_buf
->digest
;
17721 salt_t
*salt
= hash_buf
->salt
;
17723 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17729 char *V_pos
= input_buf
+ 5;
17731 char *R_pos
= strchr (V_pos
, '*');
17733 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17735 u32 V_len
= R_pos
- V_pos
;
17739 char *bits_pos
= strchr (R_pos
, '*');
17741 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17743 u32 R_len
= bits_pos
- R_pos
;
17747 char *P_pos
= strchr (bits_pos
, '*');
17749 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17751 u32 bits_len
= P_pos
- bits_pos
;
17755 char *enc_md_pos
= strchr (P_pos
, '*');
17757 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17759 u32 P_len
= enc_md_pos
- P_pos
;
17763 char *id_len_pos
= strchr (enc_md_pos
, '*');
17765 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17767 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17771 char *id_buf_pos
= strchr (id_len_pos
, '*');
17773 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17775 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17779 char *u_len_pos
= strchr (id_buf_pos
, '*');
17781 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17783 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17787 char *u_buf_pos
= strchr (u_len_pos
, '*');
17789 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17791 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17795 char *o_len_pos
= strchr (u_buf_pos
, '*');
17797 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17799 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17803 char *o_buf_pos
= strchr (o_len_pos
, '*');
17805 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17807 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17811 char *last
= strchr (o_buf_pos
, '*');
17813 if (last
== NULL
) last
= input_buf
+ input_len
;
17815 u32 o_buf_len
= last
- o_buf_pos
;
17819 const int V
= atoi (V_pos
);
17820 const int R
= atoi (R_pos
);
17824 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17825 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17827 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17829 const int bits
= atoi (bits_pos
);
17831 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17833 int enc_md
= atoi (enc_md_pos
);
17835 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17837 const uint id_len
= atoi (id_len_pos
);
17838 const uint u_len
= atoi (u_len_pos
);
17839 const uint o_len
= atoi (o_len_pos
);
17841 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17842 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17843 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17844 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17845 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17846 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17847 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17848 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17850 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17851 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17852 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17854 // copy data to esalt
17856 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17858 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17860 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17863 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17864 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17866 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17867 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17869 salt
->salt_len
= 8;
17870 salt
->salt_iter
= ROUNDS_PDF17L8
;
17872 digest
[0] = pdf
->u_buf
[0];
17873 digest
[1] = pdf
->u_buf
[1];
17874 digest
[2] = pdf
->u_buf
[2];
17875 digest
[3] = pdf
->u_buf
[3];
17876 digest
[4] = pdf
->u_buf
[4];
17877 digest
[5] = pdf
->u_buf
[5];
17878 digest
[6] = pdf
->u_buf
[6];
17879 digest
[7] = pdf
->u_buf
[7];
17881 return (PARSER_OK
);
17884 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17886 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17888 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17890 u32
*digest
= (u32
*) hash_buf
->digest
;
17892 salt_t
*salt
= hash_buf
->salt
;
17894 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17902 char *iter_pos
= input_buf
+ 7;
17904 u32 iter
= atoi (iter_pos
);
17906 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17907 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17909 // first is *raw* salt
17911 char *salt_pos
= strchr (iter_pos
, ':');
17913 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17917 char *hash_pos
= strchr (salt_pos
, ':');
17919 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17921 u32 salt_len
= hash_pos
- salt_pos
;
17923 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17927 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17929 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17933 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17935 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17937 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17939 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17940 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17942 salt
->salt_len
= salt_len
;
17943 salt
->salt_iter
= iter
- 1;
17947 u8 tmp_buf
[100] = { 0 };
17949 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17951 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17953 memcpy (digest
, tmp_buf
, 16);
17955 digest
[0] = byte_swap_32 (digest
[0]);
17956 digest
[1] = byte_swap_32 (digest
[1]);
17957 digest
[2] = byte_swap_32 (digest
[2]);
17958 digest
[3] = byte_swap_32 (digest
[3]);
17960 // add some stuff to normal salt to make sorted happy
17962 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17963 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17964 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17965 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17966 salt
->salt_buf
[4] = salt
->salt_iter
;
17968 return (PARSER_OK
);
17971 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17973 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17975 u32
*digest
= (u32
*) hash_buf
->digest
;
17977 salt_t
*salt
= hash_buf
->salt
;
17979 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17980 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17981 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17982 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17984 digest
[0] = byte_swap_32 (digest
[0]);
17985 digest
[1] = byte_swap_32 (digest
[1]);
17986 digest
[2] = byte_swap_32 (digest
[2]);
17987 digest
[3] = byte_swap_32 (digest
[3]);
17989 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17991 uint salt_len
= input_len
- 32 - 1;
17993 char *salt_buf
= input_buf
+ 32 + 1;
17995 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17997 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17999 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18001 salt
->salt_len
= salt_len
;
18003 return (PARSER_OK
);
18006 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18008 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
18010 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18012 u32
*digest
= (u32
*) hash_buf
->digest
;
18014 salt_t
*salt
= hash_buf
->salt
;
18016 char *user_pos
= input_buf
+ 10;
18018 char *salt_pos
= strchr (user_pos
, '*');
18020 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18024 char *hash_pos
= strchr (salt_pos
, '*');
18028 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18030 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
18032 uint user_len
= salt_pos
- user_pos
- 1;
18034 uint salt_len
= hash_pos
- salt_pos
- 1;
18036 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
18042 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18043 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18044 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18045 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18047 digest
[0] = byte_swap_32 (digest
[0]);
18048 digest
[1] = byte_swap_32 (digest
[1]);
18049 digest
[2] = byte_swap_32 (digest
[2]);
18050 digest
[3] = byte_swap_32 (digest
[3]);
18052 digest
[0] -= MD5M_A
;
18053 digest
[1] -= MD5M_B
;
18054 digest
[2] -= MD5M_C
;
18055 digest
[3] -= MD5M_D
;
18061 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18063 // first 4 bytes are the "challenge"
18065 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
18066 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
18067 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
18068 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
18070 // append the user name
18072 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
18074 salt
->salt_len
= 4 + user_len
;
18076 return (PARSER_OK
);
18079 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18081 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
18083 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18085 u32
*digest
= (u32
*) hash_buf
->digest
;
18087 salt_t
*salt
= hash_buf
->salt
;
18089 char *salt_pos
= input_buf
+ 9;
18091 char *hash_pos
= strchr (salt_pos
, '*');
18093 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18097 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18099 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
18101 uint salt_len
= hash_pos
- salt_pos
- 1;
18103 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
18109 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18110 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18111 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18112 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18113 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18119 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18121 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18123 salt
->salt_len
= salt_len
;
18125 return (PARSER_OK
);
18128 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18130 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
18132 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18134 u32
*digest
= (u32
*) hash_buf
->digest
;
18136 salt_t
*salt
= hash_buf
->salt
;
18138 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
18144 char *cry_master_len_pos
= input_buf
+ 9;
18146 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
18148 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18150 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
18152 cry_master_buf_pos
++;
18154 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
18156 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18158 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
18160 cry_salt_len_pos
++;
18162 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
18164 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18166 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
18168 cry_salt_buf_pos
++;
18170 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
18172 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18174 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
18178 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
18180 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18182 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
18186 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
18188 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18190 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
18194 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
18196 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18198 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
18200 public_key_len_pos
++;
18202 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
18204 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18206 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
18208 public_key_buf_pos
++;
18210 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;
18212 const uint cry_master_len
= atoi (cry_master_len_pos
);
18213 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
18214 const uint ckey_len
= atoi (ckey_len_pos
);
18215 const uint public_key_len
= atoi (public_key_len_pos
);
18217 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
18218 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
18219 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
18220 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
18222 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
18224 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
18226 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
18229 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
18231 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
18233 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
18236 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
18238 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
18240 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
18243 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
18244 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
18245 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
18248 * store digest (should be unique enought, hopefully)
18251 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
18252 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
18253 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
18254 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
18260 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
18262 const uint cry_rounds
= atoi (cry_rounds_pos
);
18264 salt
->salt_iter
= cry_rounds
- 1;
18266 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18268 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
18270 salt
->salt_len
= salt_len
;
18272 return (PARSER_OK
);
18275 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18277 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
18279 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18281 u32
*digest
= (u32
*) hash_buf
->digest
;
18283 salt_t
*salt
= hash_buf
->salt
;
18285 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
18287 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
18289 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
18291 memcpy (temp_input_buf
, input_buf
, input_len
);
18295 char *URI_server_pos
= temp_input_buf
+ 6;
18297 char *URI_client_pos
= strchr (URI_server_pos
, '*');
18299 if (URI_client_pos
== NULL
)
18301 myfree (temp_input_buf
);
18303 return (PARSER_SEPARATOR_UNMATCHED
);
18306 URI_client_pos
[0] = 0;
18309 uint URI_server_len
= strlen (URI_server_pos
);
18311 if (URI_server_len
> 512)
18313 myfree (temp_input_buf
);
18315 return (PARSER_SALT_LENGTH
);
18320 char *user_pos
= strchr (URI_client_pos
, '*');
18322 if (user_pos
== NULL
)
18324 myfree (temp_input_buf
);
18326 return (PARSER_SEPARATOR_UNMATCHED
);
18332 uint URI_client_len
= strlen (URI_client_pos
);
18334 if (URI_client_len
> 512)
18336 myfree (temp_input_buf
);
18338 return (PARSER_SALT_LENGTH
);
18343 char *realm_pos
= strchr (user_pos
, '*');
18345 if (realm_pos
== NULL
)
18347 myfree (temp_input_buf
);
18349 return (PARSER_SEPARATOR_UNMATCHED
);
18355 uint user_len
= strlen (user_pos
);
18357 if (user_len
> 116)
18359 myfree (temp_input_buf
);
18361 return (PARSER_SALT_LENGTH
);
18366 char *method_pos
= strchr (realm_pos
, '*');
18368 if (method_pos
== NULL
)
18370 myfree (temp_input_buf
);
18372 return (PARSER_SEPARATOR_UNMATCHED
);
18378 uint realm_len
= strlen (realm_pos
);
18380 if (realm_len
> 116)
18382 myfree (temp_input_buf
);
18384 return (PARSER_SALT_LENGTH
);
18389 char *URI_prefix_pos
= strchr (method_pos
, '*');
18391 if (URI_prefix_pos
== NULL
)
18393 myfree (temp_input_buf
);
18395 return (PARSER_SEPARATOR_UNMATCHED
);
18398 URI_prefix_pos
[0] = 0;
18401 uint method_len
= strlen (method_pos
);
18403 if (method_len
> 246)
18405 myfree (temp_input_buf
);
18407 return (PARSER_SALT_LENGTH
);
18412 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
18414 if (URI_resource_pos
== NULL
)
18416 myfree (temp_input_buf
);
18418 return (PARSER_SEPARATOR_UNMATCHED
);
18421 URI_resource_pos
[0] = 0;
18422 URI_resource_pos
++;
18424 uint URI_prefix_len
= strlen (URI_prefix_pos
);
18426 if (URI_prefix_len
> 245)
18428 myfree (temp_input_buf
);
18430 return (PARSER_SALT_LENGTH
);
18435 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
18437 if (URI_suffix_pos
== NULL
)
18439 myfree (temp_input_buf
);
18441 return (PARSER_SEPARATOR_UNMATCHED
);
18444 URI_suffix_pos
[0] = 0;
18447 uint URI_resource_len
= strlen (URI_resource_pos
);
18449 if (URI_resource_len
< 1 || URI_resource_len
> 246)
18451 myfree (temp_input_buf
);
18453 return (PARSER_SALT_LENGTH
);
18458 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
18460 if (nonce_pos
== NULL
)
18462 myfree (temp_input_buf
);
18464 return (PARSER_SEPARATOR_UNMATCHED
);
18470 uint URI_suffix_len
= strlen (URI_suffix_pos
);
18472 if (URI_suffix_len
> 245)
18474 myfree (temp_input_buf
);
18476 return (PARSER_SALT_LENGTH
);
18481 char *nonce_client_pos
= strchr (nonce_pos
, '*');
18483 if (nonce_client_pos
== NULL
)
18485 myfree (temp_input_buf
);
18487 return (PARSER_SEPARATOR_UNMATCHED
);
18490 nonce_client_pos
[0] = 0;
18491 nonce_client_pos
++;
18493 uint nonce_len
= strlen (nonce_pos
);
18495 if (nonce_len
< 1 || nonce_len
> 50)
18497 myfree (temp_input_buf
);
18499 return (PARSER_SALT_LENGTH
);
18504 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18506 if (nonce_count_pos
== NULL
)
18508 myfree (temp_input_buf
);
18510 return (PARSER_SEPARATOR_UNMATCHED
);
18513 nonce_count_pos
[0] = 0;
18516 uint nonce_client_len
= strlen (nonce_client_pos
);
18518 if (nonce_client_len
> 50)
18520 myfree (temp_input_buf
);
18522 return (PARSER_SALT_LENGTH
);
18527 char *qop_pos
= strchr (nonce_count_pos
, '*');
18529 if (qop_pos
== NULL
)
18531 myfree (temp_input_buf
);
18533 return (PARSER_SEPARATOR_UNMATCHED
);
18539 uint nonce_count_len
= strlen (nonce_count_pos
);
18541 if (nonce_count_len
> 50)
18543 myfree (temp_input_buf
);
18545 return (PARSER_SALT_LENGTH
);
18550 char *directive_pos
= strchr (qop_pos
, '*');
18552 if (directive_pos
== NULL
)
18554 myfree (temp_input_buf
);
18556 return (PARSER_SEPARATOR_UNMATCHED
);
18559 directive_pos
[0] = 0;
18562 uint qop_len
= strlen (qop_pos
);
18566 myfree (temp_input_buf
);
18568 return (PARSER_SALT_LENGTH
);
18573 char *digest_pos
= strchr (directive_pos
, '*');
18575 if (digest_pos
== NULL
)
18577 myfree (temp_input_buf
);
18579 return (PARSER_SEPARATOR_UNMATCHED
);
18585 uint directive_len
= strlen (directive_pos
);
18587 if (directive_len
!= 3)
18589 myfree (temp_input_buf
);
18591 return (PARSER_SALT_LENGTH
);
18594 if (memcmp (directive_pos
, "MD5", 3))
18596 log_info ("ERROR: only the MD5 directive is currently supported\n");
18598 myfree (temp_input_buf
);
18600 return (PARSER_SIP_AUTH_DIRECTIVE
);
18604 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18609 uint md5_max_len
= 4 * 64;
18611 uint md5_remaining_len
= md5_max_len
;
18613 uint tmp_md5_buf
[64] = { 0 };
18615 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18617 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18619 md5_len
+= method_len
+ 1;
18620 tmp_md5_ptr
+= method_len
+ 1;
18622 if (URI_prefix_len
> 0)
18624 md5_remaining_len
= md5_max_len
- md5_len
;
18626 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18628 md5_len
+= URI_prefix_len
+ 1;
18629 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18632 md5_remaining_len
= md5_max_len
- md5_len
;
18634 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18636 md5_len
+= URI_resource_len
;
18637 tmp_md5_ptr
+= URI_resource_len
;
18639 if (URI_suffix_len
> 0)
18641 md5_remaining_len
= md5_max_len
- md5_len
;
18643 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18645 md5_len
+= 1 + URI_suffix_len
;
18648 uint tmp_digest
[4] = { 0 };
18650 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18652 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18653 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18654 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18655 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18661 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18663 uint esalt_len
= 0;
18665 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18667 // there are 2 possibilities for the esalt:
18669 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18671 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18673 if (esalt_len
> max_esalt_len
)
18675 myfree (temp_input_buf
);
18677 return (PARSER_SALT_LENGTH
);
18680 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18692 esalt_len
= 1 + nonce_len
+ 1 + 32;
18694 if (esalt_len
> max_esalt_len
)
18696 myfree (temp_input_buf
);
18698 return (PARSER_SALT_LENGTH
);
18701 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18709 // add 0x80 to esalt
18711 esalt_buf_ptr
[esalt_len
] = 0x80;
18713 sip
->esalt_len
= esalt_len
;
18719 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18721 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18723 uint max_salt_len
= 119;
18725 if (salt_len
> max_salt_len
)
18727 myfree (temp_input_buf
);
18729 return (PARSER_SALT_LENGTH
);
18732 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18734 sip
->salt_len
= salt_len
;
18737 * fake salt (for sorting)
18740 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18744 uint fake_salt_len
= salt_len
;
18746 if (fake_salt_len
> max_salt_len
)
18748 fake_salt_len
= max_salt_len
;
18751 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18753 salt
->salt_len
= fake_salt_len
;
18759 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18760 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18761 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18762 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18764 digest
[0] = byte_swap_32 (digest
[0]);
18765 digest
[1] = byte_swap_32 (digest
[1]);
18766 digest
[2] = byte_swap_32 (digest
[2]);
18767 digest
[3] = byte_swap_32 (digest
[3]);
18769 myfree (temp_input_buf
);
18771 return (PARSER_OK
);
18774 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18776 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18778 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18780 u32
*digest
= (u32
*) hash_buf
->digest
;
18782 salt_t
*salt
= hash_buf
->salt
;
18786 char *digest_pos
= input_buf
;
18788 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18795 char *salt_buf
= input_buf
+ 8 + 1;
18799 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18801 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18803 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18805 salt
->salt_len
= salt_len
;
18807 return (PARSER_OK
);
18810 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18812 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18814 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18816 u32
*digest
= (u32
*) hash_buf
->digest
;
18818 salt_t
*salt
= hash_buf
->salt
;
18820 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18826 char *p_buf_pos
= input_buf
+ 4;
18828 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18830 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18832 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18834 NumCyclesPower_pos
++;
18836 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18838 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18840 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18844 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18846 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18848 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18852 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18854 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18856 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18860 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18862 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18864 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18868 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18870 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18872 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18876 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18878 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18880 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18884 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18886 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18888 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18892 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18894 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18896 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18900 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;
18902 const uint iter
= atoi (NumCyclesPower_pos
);
18903 const uint crc
= atoi (crc_buf_pos
);
18904 const uint p_buf
= atoi (p_buf_pos
);
18905 const uint salt_len
= atoi (salt_len_pos
);
18906 const uint iv_len
= atoi (iv_len_pos
);
18907 const uint unpack_size
= atoi (unpack_size_pos
);
18908 const uint data_len
= atoi (data_len_pos
);
18914 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18915 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18917 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18919 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18921 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18927 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18928 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18929 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18930 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18932 seven_zip
->iv_len
= iv_len
;
18934 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18936 seven_zip
->salt_len
= 0;
18938 seven_zip
->crc
= crc
;
18940 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18942 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18944 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18947 seven_zip
->data_len
= data_len
;
18949 seven_zip
->unpack_size
= unpack_size
;
18953 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18954 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18955 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18956 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18958 salt
->salt_len
= 16;
18960 salt
->salt_sign
[0] = iter
;
18962 salt
->salt_iter
= 1 << iter
;
18973 return (PARSER_OK
);
18976 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18978 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18980 u32
*digest
= (u32
*) hash_buf
->digest
;
18982 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18983 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18984 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18985 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18986 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18987 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18988 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18989 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18991 digest
[0] = byte_swap_32 (digest
[0]);
18992 digest
[1] = byte_swap_32 (digest
[1]);
18993 digest
[2] = byte_swap_32 (digest
[2]);
18994 digest
[3] = byte_swap_32 (digest
[3]);
18995 digest
[4] = byte_swap_32 (digest
[4]);
18996 digest
[5] = byte_swap_32 (digest
[5]);
18997 digest
[6] = byte_swap_32 (digest
[6]);
18998 digest
[7] = byte_swap_32 (digest
[7]);
19000 return (PARSER_OK
);
19003 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19005 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
19007 u32
*digest
= (u32
*) hash_buf
->digest
;
19009 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19010 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19011 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
19012 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
19013 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
19014 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
19015 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
19016 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
19017 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
19018 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
19019 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
19020 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
19021 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
19022 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
19023 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
19024 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
19026 digest
[ 0] = byte_swap_32 (digest
[ 0]);
19027 digest
[ 1] = byte_swap_32 (digest
[ 1]);
19028 digest
[ 2] = byte_swap_32 (digest
[ 2]);
19029 digest
[ 3] = byte_swap_32 (digest
[ 3]);
19030 digest
[ 4] = byte_swap_32 (digest
[ 4]);
19031 digest
[ 5] = byte_swap_32 (digest
[ 5]);
19032 digest
[ 6] = byte_swap_32 (digest
[ 6]);
19033 digest
[ 7] = byte_swap_32 (digest
[ 7]);
19034 digest
[ 8] = byte_swap_32 (digest
[ 8]);
19035 digest
[ 9] = byte_swap_32 (digest
[ 9]);
19036 digest
[10] = byte_swap_32 (digest
[10]);
19037 digest
[11] = byte_swap_32 (digest
[11]);
19038 digest
[12] = byte_swap_32 (digest
[12]);
19039 digest
[13] = byte_swap_32 (digest
[13]);
19040 digest
[14] = byte_swap_32 (digest
[14]);
19041 digest
[15] = byte_swap_32 (digest
[15]);
19043 return (PARSER_OK
);
19046 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19048 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
19050 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
19052 u32
*digest
= (u32
*) hash_buf
->digest
;
19054 salt_t
*salt
= hash_buf
->salt
;
19056 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
19064 char *iter_pos
= input_buf
+ 4;
19066 u32 iter
= atoi (iter_pos
);
19068 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19069 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19071 // first is *raw* salt
19073 char *salt_pos
= strchr (iter_pos
, ':');
19075 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19079 char *hash_pos
= strchr (salt_pos
, ':');
19081 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19083 u32 salt_len
= hash_pos
- salt_pos
;
19085 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19089 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19091 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19095 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
19097 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19099 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19101 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19102 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19104 salt
->salt_len
= salt_len
;
19105 salt
->salt_iter
= iter
- 1;
19109 u8 tmp_buf
[100] = { 0 };
19111 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19113 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19115 memcpy (digest
, tmp_buf
, 16);
19117 // add some stuff to normal salt to make sorted happy
19119 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
19120 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
19121 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
19122 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
19123 salt
->salt_buf
[4] = salt
->salt_iter
;
19125 return (PARSER_OK
);
19128 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19130 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
19132 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
19134 u32
*digest
= (u32
*) hash_buf
->digest
;
19136 salt_t
*salt
= hash_buf
->salt
;
19138 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
19146 char *iter_pos
= input_buf
+ 5;
19148 u32 iter
= atoi (iter_pos
);
19150 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19151 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19153 // first is *raw* salt
19155 char *salt_pos
= strchr (iter_pos
, ':');
19157 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19161 char *hash_pos
= strchr (salt_pos
, ':');
19163 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19165 u32 salt_len
= hash_pos
- salt_pos
;
19167 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19171 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19173 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19177 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
19179 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19181 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19183 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19184 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19186 salt
->salt_len
= salt_len
;
19187 salt
->salt_iter
= iter
- 1;
19191 u8 tmp_buf
[100] = { 0 };
19193 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19195 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19197 memcpy (digest
, tmp_buf
, 16);
19199 digest
[0] = byte_swap_32 (digest
[0]);
19200 digest
[1] = byte_swap_32 (digest
[1]);
19201 digest
[2] = byte_swap_32 (digest
[2]);
19202 digest
[3] = byte_swap_32 (digest
[3]);
19204 // add some stuff to normal salt to make sorted happy
19206 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
19207 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
19208 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
19209 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
19210 salt
->salt_buf
[4] = salt
->salt_iter
;
19212 return (PARSER_OK
);
19215 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19217 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
19219 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
19221 u64
*digest
= (u64
*) hash_buf
->digest
;
19223 salt_t
*salt
= hash_buf
->salt
;
19225 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
19233 char *iter_pos
= input_buf
+ 7;
19235 u32 iter
= atoi (iter_pos
);
19237 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19238 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19240 // first is *raw* salt
19242 char *salt_pos
= strchr (iter_pos
, ':');
19244 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19248 char *hash_pos
= strchr (salt_pos
, ':');
19250 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19252 u32 salt_len
= hash_pos
- salt_pos
;
19254 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19258 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19260 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19264 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
19266 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19268 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19270 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19271 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19273 salt
->salt_len
= salt_len
;
19274 salt
->salt_iter
= iter
- 1;
19278 u8 tmp_buf
[100] = { 0 };
19280 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19282 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19284 memcpy (digest
, tmp_buf
, 64);
19286 digest
[0] = byte_swap_64 (digest
[0]);
19287 digest
[1] = byte_swap_64 (digest
[1]);
19288 digest
[2] = byte_swap_64 (digest
[2]);
19289 digest
[3] = byte_swap_64 (digest
[3]);
19290 digest
[4] = byte_swap_64 (digest
[4]);
19291 digest
[5] = byte_swap_64 (digest
[5]);
19292 digest
[6] = byte_swap_64 (digest
[6]);
19293 digest
[7] = byte_swap_64 (digest
[7]);
19295 // add some stuff to normal salt to make sorted happy
19297 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
19298 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
19299 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
19300 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
19301 salt
->salt_buf
[4] = salt
->salt_iter
;
19303 return (PARSER_OK
);
19306 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19308 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
19310 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
19312 uint
*digest
= (uint
*) hash_buf
->digest
;
19314 salt_t
*salt
= hash_buf
->salt
;
19320 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
19322 char *hash_pos
= strchr (salt_pos
, '$');
19324 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19326 u32 salt_len
= hash_pos
- salt_pos
;
19328 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19332 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
19334 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
19338 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
19339 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
19357 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19358 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19360 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
19361 salt
->salt_len
= 8;
19363 return (PARSER_OK
);
19366 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19368 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
19370 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19372 unsigned char c19
= itoa64_to_int (input_buf
[19]);
19374 if (c19
& 3) return (PARSER_HASH_VALUE
);
19376 salt_t
*salt
= hash_buf
->salt
;
19378 u32
*digest
= (u32
*) hash_buf
->digest
;
19382 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
19383 | itoa64_to_int (input_buf
[2]) << 6
19384 | itoa64_to_int (input_buf
[3]) << 12
19385 | itoa64_to_int (input_buf
[4]) << 18;
19389 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
19390 | itoa64_to_int (input_buf
[6]) << 6
19391 | itoa64_to_int (input_buf
[7]) << 12
19392 | itoa64_to_int (input_buf
[8]) << 18;
19394 salt
->salt_len
= 4;
19396 u8 tmp_buf
[100] = { 0 };
19398 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
19400 memcpy (digest
, tmp_buf
, 8);
19404 IP (digest
[0], digest
[1], tt
);
19406 digest
[0] = rotr32 (digest
[0], 31);
19407 digest
[1] = rotr32 (digest
[1], 31);
19411 return (PARSER_OK
);
19414 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19416 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
19418 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
19420 u32
*digest
= (u32
*) hash_buf
->digest
;
19422 salt_t
*salt
= hash_buf
->salt
;
19428 char *type_pos
= input_buf
+ 6 + 1;
19430 char *salt_pos
= strchr (type_pos
, '*');
19432 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19434 u32 type_len
= salt_pos
- type_pos
;
19436 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
19440 char *crypted_pos
= strchr (salt_pos
, '*');
19442 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19444 u32 salt_len
= crypted_pos
- salt_pos
;
19446 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19450 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
19452 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
19458 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19459 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19461 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19462 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19464 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
19465 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
19466 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
19467 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
19469 salt
->salt_len
= 24;
19470 salt
->salt_iter
= ROUNDS_RAR3
;
19472 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
19473 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
19475 digest
[0] = 0xc43d7b00;
19476 digest
[1] = 0x40070000;
19480 return (PARSER_OK
);
19483 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19485 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19487 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19489 u32
*digest
= (u32
*) hash_buf
->digest
;
19491 salt_t
*salt
= hash_buf
->salt
;
19493 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19499 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19501 char *param1_pos
= strchr (param0_pos
, '$');
19503 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19505 u32 param0_len
= param1_pos
- param0_pos
;
19509 char *param2_pos
= strchr (param1_pos
, '$');
19511 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19513 u32 param1_len
= param2_pos
- param1_pos
;
19517 char *param3_pos
= strchr (param2_pos
, '$');
19519 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19521 u32 param2_len
= param3_pos
- param2_pos
;
19525 char *param4_pos
= strchr (param3_pos
, '$');
19527 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19529 u32 param3_len
= param4_pos
- param3_pos
;
19533 char *param5_pos
= strchr (param4_pos
, '$');
19535 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19537 u32 param4_len
= param5_pos
- param4_pos
;
19541 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19543 char *salt_buf
= param1_pos
;
19544 char *iv
= param3_pos
;
19545 char *pswcheck
= param5_pos
;
19547 const uint salt_len
= atoi (param0_pos
);
19548 const uint iterations
= atoi (param2_pos
);
19549 const uint pswcheck_len
= atoi (param4_pos
);
19555 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19556 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19557 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19559 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19560 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19561 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19567 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19568 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19569 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19570 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19572 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19573 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19574 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19575 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19577 salt
->salt_len
= 16;
19579 salt
->salt_sign
[0] = iterations
;
19581 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19587 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19588 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19592 return (PARSER_OK
);
19595 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19597 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19599 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19601 u32
*digest
= (u32
*) hash_buf
->digest
;
19603 salt_t
*salt
= hash_buf
->salt
;
19605 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19612 char *account_pos
= input_buf
+ 11 + 1;
19618 if (account_pos
[0] == '*')
19622 data_pos
= strchr (account_pos
, '*');
19627 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19629 uint account_len
= data_pos
- account_pos
+ 1;
19631 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19636 data_len
= input_len
- 11 - 1 - account_len
- 2;
19638 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19642 /* assume $krb5tgs$23$checksum$edata2 */
19643 data_pos
= account_pos
;
19645 memcpy (krb5tgs
->account_info
, "**", 3);
19647 data_len
= input_len
- 11 - 1 - 1;
19650 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19652 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19654 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19656 const char p0
= data_pos
[i
+ 0];
19657 const char p1
= data_pos
[i
+ 1];
19659 *checksum_ptr
++ = hex_convert (p1
) << 0
19660 | hex_convert (p0
) << 4;
19663 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19665 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19668 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19670 const char p0
= data_pos
[i
+ 0];
19671 const char p1
= data_pos
[i
+ 1];
19672 *edata_ptr
++ = hex_convert (p1
) << 0
19673 | hex_convert (p0
) << 4;
19676 /* this is needed for hmac_md5 */
19677 *edata_ptr
++ = 0x80;
19679 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19680 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19681 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19682 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19684 salt
->salt_len
= 32;
19686 digest
[0] = krb5tgs
->checksum
[0];
19687 digest
[1] = krb5tgs
->checksum
[1];
19688 digest
[2] = krb5tgs
->checksum
[2];
19689 digest
[3] = krb5tgs
->checksum
[3];
19691 return (PARSER_OK
);
19694 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19696 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19698 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19700 u32
*digest
= (u32
*) hash_buf
->digest
;
19702 salt_t
*salt
= hash_buf
->salt
;
19709 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19713 char *wrapped_key_pos
;
19717 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19719 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19721 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19723 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19728 data_pos
= salt_pos
;
19730 wrapped_key_pos
= strchr (salt_pos
, '*');
19732 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19734 uint salt_len
= wrapped_key_pos
- salt_pos
;
19736 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19741 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19743 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19745 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19746 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19747 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19748 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19752 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19753 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19754 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19755 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19756 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19757 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19759 salt
->salt_len
= 40;
19761 digest
[0] = salt
->salt_buf
[0];
19762 digest
[1] = salt
->salt_buf
[1];
19763 digest
[2] = salt
->salt_buf
[2];
19764 digest
[3] = salt
->salt_buf
[3];
19766 return (PARSER_OK
);
19769 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19771 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19773 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19775 u32
*digest
= (u32
*) hash_buf
->digest
;
19777 salt_t
*salt
= hash_buf
->salt
;
19779 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19789 char *algorithm_pos
;
19791 char *final_random_seed_pos
;
19792 u32 final_random_seed_len
;
19794 char *transf_random_seed_pos
;
19795 u32 transf_random_seed_len
;
19800 /* default is no keyfile provided */
19801 char *keyfile_len_pos
;
19802 u32 keyfile_len
= 0;
19803 u32 is_keyfile_present
= 0;
19804 char *keyfile_inline_pos
;
19807 /* specific to version 1 */
19808 char *contents_len_pos
;
19810 char *contents_pos
;
19812 /* specific to version 2 */
19813 char *expected_bytes_pos
;
19814 u32 expected_bytes_len
;
19816 char *contents_hash_pos
;
19817 u32 contents_hash_len
;
19819 version_pos
= input_buf
+ 8 + 1 + 1;
19821 keepass
->version
= atoi (version_pos
);
19823 rounds_pos
= strchr (version_pos
, '*');
19825 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19829 salt
->salt_iter
= (atoi (rounds_pos
));
19831 algorithm_pos
= strchr (rounds_pos
, '*');
19833 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19837 keepass
->algorithm
= atoi (algorithm_pos
);
19839 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19841 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19843 final_random_seed_pos
++;
19845 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19846 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19847 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19848 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19850 if (keepass
->version
== 2)
19852 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19853 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19854 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19855 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19858 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19860 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19862 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19864 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19865 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19867 transf_random_seed_pos
++;
19869 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19870 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19871 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19872 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19873 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19874 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19875 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19876 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19878 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19880 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19882 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19884 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19888 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19889 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19890 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19891 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19893 if (keepass
->version
== 1)
19895 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19897 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19899 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19901 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19903 contents_hash_pos
++;
19905 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19906 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19907 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19908 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19909 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19910 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19911 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19912 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19914 /* get length of contents following */
19915 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19917 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19919 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19921 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19925 u32 inline_flag
= atoi (inline_flag_pos
);
19927 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19929 contents_len_pos
= strchr (inline_flag_pos
, '*');
19931 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19933 contents_len_pos
++;
19935 contents_len
= atoi (contents_len_pos
);
19937 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19939 contents_pos
= strchr (contents_len_pos
, '*');
19941 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19947 keepass
->contents_len
= contents_len
;
19949 contents_len
= contents_len
/ 4;
19951 keyfile_inline_pos
= strchr (contents_pos
, '*');
19953 u32 real_contents_len
;
19955 if (keyfile_inline_pos
== NULL
)
19956 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19959 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19960 keyfile_inline_pos
++;
19961 is_keyfile_present
= 1;
19964 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
19966 for (i
= 0; i
< contents_len
; i
++)
19967 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
19969 else if (keepass
->version
== 2)
19971 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
19973 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19975 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
19977 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19979 expected_bytes_pos
++;
19981 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
19982 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
19983 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
19984 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
19985 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
19986 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
19987 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
19988 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
19990 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
19992 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19994 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
19996 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
19998 contents_hash_pos
++;
20000 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
20001 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
20002 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
20003 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
20004 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
20005 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
20006 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
20007 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
20009 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
20011 if (keyfile_inline_pos
== NULL
)
20012 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
20015 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
20016 keyfile_inline_pos
++;
20017 is_keyfile_present
= 1;
20019 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
20022 if (is_keyfile_present
!= 0)
20024 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
20028 keyfile_len
= atoi (keyfile_len_pos
);
20030 keepass
->keyfile_len
= keyfile_len
;
20032 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20034 keyfile_pos
= strchr (keyfile_len_pos
, '*');
20036 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20040 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
20042 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20044 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
20045 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
20046 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
20047 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
20048 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
20049 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
20050 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
20051 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
20054 digest
[0] = keepass
->enc_iv
[0];
20055 digest
[1] = keepass
->enc_iv
[1];
20056 digest
[2] = keepass
->enc_iv
[2];
20057 digest
[3] = keepass
->enc_iv
[3];
20059 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
20060 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
20061 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
20062 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
20063 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
20064 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
20065 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
20066 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
20068 return (PARSER_OK
);
20071 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20073 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
20075 u32
*digest
= (u32
*) hash_buf
->digest
;
20077 salt_t
*salt
= hash_buf
->salt
;
20079 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20080 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20081 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20082 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20083 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20084 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20085 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20086 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20088 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20090 uint salt_len
= input_len
- 64 - 1;
20092 char *salt_buf
= input_buf
+ 64 + 1;
20094 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
20096 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
20098 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
20100 salt
->salt_len
= salt_len
;
20103 * we can precompute the first sha256 transform
20106 uint w
[16] = { 0 };
20108 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
20109 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
20110 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
20111 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
20112 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
20113 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
20114 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
20115 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
20116 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
20117 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
20118 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
20119 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
20120 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
20121 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
20122 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
20123 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
20125 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
20127 sha256_64 (w
, pc256
);
20129 salt
->salt_buf_pc
[0] = pc256
[0];
20130 salt
->salt_buf_pc
[1] = pc256
[1];
20131 salt
->salt_buf_pc
[2] = pc256
[2];
20132 salt
->salt_buf_pc
[3] = pc256
[3];
20133 salt
->salt_buf_pc
[4] = pc256
[4];
20134 salt
->salt_buf_pc
[5] = pc256
[5];
20135 salt
->salt_buf_pc
[6] = pc256
[6];
20136 salt
->salt_buf_pc
[7] = pc256
[7];
20138 digest
[0] -= pc256
[0];
20139 digest
[1] -= pc256
[1];
20140 digest
[2] -= pc256
[2];
20141 digest
[3] -= pc256
[3];
20142 digest
[4] -= pc256
[4];
20143 digest
[5] -= pc256
[5];
20144 digest
[6] -= pc256
[6];
20145 digest
[7] -= pc256
[7];
20147 return (PARSER_OK
);
20150 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20152 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
20154 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
20156 u32
*digest
= (u32
*) hash_buf
->digest
;
20158 salt_t
*salt
= hash_buf
->salt
;
20164 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
20166 char *data_buf_pos
= strchr (data_len_pos
, '$');
20168 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20170 u32 data_len_len
= data_buf_pos
- data_len_pos
;
20172 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
20173 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
20177 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
20179 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
20181 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
20183 u32 data_len
= atoi (data_len_pos
);
20185 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
20191 char *salt_pos
= data_buf_pos
;
20193 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20194 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20195 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
20196 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
20198 // this is actually the CT, which is also the hash later (if matched)
20200 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
20201 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
20202 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
20203 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
20205 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
20207 salt
->salt_iter
= 10 - 1;
20213 digest
[0] = salt
->salt_buf
[4];
20214 digest
[1] = salt
->salt_buf
[5];
20215 digest
[2] = salt
->salt_buf
[6];
20216 digest
[3] = salt
->salt_buf
[7];
20218 return (PARSER_OK
);
20221 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20223 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
20225 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
20227 u32
*digest
= (u32
*) hash_buf
->digest
;
20229 salt_t
*salt
= hash_buf
->salt
;
20235 char *salt_pos
= input_buf
+ 11 + 1;
20237 char *iter_pos
= strchr (salt_pos
, ',');
20239 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20241 u32 salt_len
= iter_pos
- salt_pos
;
20243 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
20247 char *hash_pos
= strchr (iter_pos
, ',');
20249 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20251 u32 iter_len
= hash_pos
- iter_pos
;
20253 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
20257 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
20259 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
20265 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20266 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20267 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
20268 salt
->salt_buf
[3] = 0x00018000;
20270 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
20271 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
20272 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
20273 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
20275 salt
->salt_len
= salt_len
/ 2;
20277 salt
->salt_iter
= atoi (iter_pos
) - 1;
20283 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20284 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20285 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20286 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20287 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20288 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20289 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20290 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20292 return (PARSER_OK
);
20295 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20297 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
20299 u32
*digest
= (u32
*) hash_buf
->digest
;
20301 salt_t
*salt
= hash_buf
->salt
;
20307 char *hash_pos
= input_buf
+ 64;
20308 char *salt1_pos
= input_buf
+ 128;
20309 char *salt2_pos
= input_buf
;
20315 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
20316 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
20317 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
20318 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
20320 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
20321 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
20322 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
20323 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
20325 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
20326 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
20327 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
20328 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
20330 salt
->salt_len
= 48;
20332 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
20338 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20339 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20340 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20341 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20342 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20343 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20344 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20345 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20347 return (PARSER_OK
);
20350 int zip2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20352 if ((input_len
< DISPLAY_LEN_MIN_13600
) || (input_len
> DISPLAY_LEN_MAX_13600
)) return (PARSER_GLOBAL_LENGTH
);
20354 if (memcmp (SIGNATURE_ZIP2_START
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
20355 if (memcmp (SIGNATURE_ZIP2_STOP
, input_buf
+ input_len
- 7, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
20357 u32
*digest
= (u32
*) hash_buf
->digest
;
20359 salt_t
*salt
= hash_buf
->salt
;
20361 zip2_t
*zip2
= (zip2_t
*) hash_buf
->esalt
;
20367 char *param0_pos
= input_buf
+ 6 + 1;
20369 char *param1_pos
= strchr (param0_pos
, '*');
20371 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20373 u32 param0_len
= param1_pos
- param0_pos
;
20377 char *param2_pos
= strchr (param1_pos
, '*');
20379 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20381 u32 param1_len
= param2_pos
- param1_pos
;
20385 char *param3_pos
= strchr (param2_pos
, '*');
20387 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20389 u32 param2_len
= param3_pos
- param2_pos
;
20393 char *param4_pos
= strchr (param3_pos
, '*');
20395 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20397 u32 param3_len
= param4_pos
- param3_pos
;
20401 char *param5_pos
= strchr (param4_pos
, '*');
20403 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20405 u32 param4_len
= param5_pos
- param4_pos
;
20409 char *param6_pos
= strchr (param5_pos
, '*');
20411 if (param6_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20413 u32 param5_len
= param6_pos
- param5_pos
;
20417 char *param7_pos
= strchr (param6_pos
, '*');
20419 if (param7_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20421 u32 param6_len
= param7_pos
- param6_pos
;
20425 char *param8_pos
= strchr (param7_pos
, '*');
20427 if (param8_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20429 u32 param7_len
= param8_pos
- param7_pos
;
20433 const uint type
= atoi (param0_pos
);
20434 const uint mode
= atoi (param1_pos
);
20435 const uint magic
= atoi (param2_pos
);
20437 char *salt_buf
= param3_pos
;
20439 uint verify_bytes
; sscanf (param4_pos
, "%4x*", &verify_bytes
);
20441 const uint compress_length
= atoi (param5_pos
);
20443 char *data_buf
= param6_pos
;
20444 char *auth
= param7_pos
;
20450 if (param0_len
!= 1) return (PARSER_SALT_VALUE
);
20452 if (param1_len
!= 1) return (PARSER_SALT_VALUE
);
20454 if (param2_len
!= 1) return (PARSER_SALT_VALUE
);
20456 if ((param3_len
!= 16) && (param3_len
!= 24) && (param3_len
!= 32)) return (PARSER_SALT_VALUE
);
20458 if (param4_len
>= 5) return (PARSER_SALT_VALUE
);
20460 if (param5_len
>= 5) return (PARSER_SALT_VALUE
);
20462 if (param6_len
>= 8192) return (PARSER_SALT_VALUE
);
20464 if (param6_len
& 1) return (PARSER_SALT_VALUE
);
20466 if (param7_len
!= 20) return (PARSER_SALT_VALUE
);
20468 if (type
!= 0) return (PARSER_SALT_VALUE
);
20470 if ((mode
!= 1) && (mode
!= 2) && (mode
!= 3)) return (PARSER_SALT_VALUE
);
20472 if (magic
!= 0) return (PARSER_SALT_VALUE
);
20474 if (verify_bytes
>= 0x10000) return (PARSER_SALT_VALUE
);
20482 zip2
->magic
= magic
;
20486 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20487 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20488 zip2
->salt_buf
[2] = 0;
20489 zip2
->salt_buf
[3] = 0;
20491 zip2
->salt_len
= 8;
20493 else if (mode
== 2)
20495 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20496 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20497 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20498 zip2
->salt_buf
[3] = 0;
20500 zip2
->salt_len
= 12;
20502 else if (mode
== 3)
20504 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20505 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20506 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20507 zip2
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
20509 zip2
->salt_len
= 16;
20512 zip2
->salt_buf
[0] = byte_swap_32 (zip2
->salt_buf
[0]);
20513 zip2
->salt_buf
[1] = byte_swap_32 (zip2
->salt_buf
[1]);
20514 zip2
->salt_buf
[2] = byte_swap_32 (zip2
->salt_buf
[2]);
20515 zip2
->salt_buf
[3] = byte_swap_32 (zip2
->salt_buf
[3]);
20517 zip2
->verify_bytes
= verify_bytes
;
20519 zip2
->compress_length
= compress_length
;
20521 char *data_buf_ptr
= (char *) zip2
->data_buf
;
20523 for (uint i
= 0; i
< param6_len
; i
+= 2)
20525 const char p0
= data_buf
[i
+ 0];
20526 const char p1
= data_buf
[i
+ 1];
20528 *data_buf_ptr
++ = hex_convert (p1
) << 0
20529 | hex_convert (p0
) << 4;
20534 *data_buf_ptr
= 0x80;
20536 char *auth_ptr
= (char *) zip2
->auth_buf
;
20538 for (uint i
= 0; i
< param7_len
; i
+= 2)
20540 const char p0
= auth
[i
+ 0];
20541 const char p1
= auth
[i
+ 1];
20543 *auth_ptr
++ = hex_convert (p1
) << 0
20544 | hex_convert (p0
) << 4;
20553 salt
->salt_buf
[0] = zip2
->salt_buf
[0];
20554 salt
->salt_buf
[1] = zip2
->salt_buf
[1];
20555 salt
->salt_buf
[2] = zip2
->salt_buf
[2];
20556 salt
->salt_buf
[3] = zip2
->salt_buf
[3];
20557 salt
->salt_buf
[4] = zip2
->data_buf
[0];
20558 salt
->salt_buf
[5] = zip2
->data_buf
[1];
20559 salt
->salt_buf
[6] = zip2
->data_buf
[2];
20560 salt
->salt_buf
[7] = zip2
->data_buf
[3];
20562 salt
->salt_len
= 32;
20564 salt
->salt_iter
= ROUNDS_ZIP2
- 1;
20567 * digest buf (fake)
20570 digest
[0] = zip2
->auth_buf
[0];
20571 digest
[1] = zip2
->auth_buf
[1];
20572 digest
[2] = zip2
->auth_buf
[2];
20573 digest
[3] = zip2
->auth_buf
[3];
20575 return (PARSER_OK
);
20579 * parallel running threads
20584 BOOL WINAPI
sigHandler_default (DWORD sig
)
20588 case CTRL_CLOSE_EVENT
:
20591 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
20592 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
20593 * function otherwise it is too late (e.g. after returning from this function)
20598 SetConsoleCtrlHandler (NULL
, TRUE
);
20605 case CTRL_LOGOFF_EVENT
:
20606 case CTRL_SHUTDOWN_EVENT
:
20610 SetConsoleCtrlHandler (NULL
, TRUE
);
20618 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
20622 case CTRL_CLOSE_EVENT
:
20626 SetConsoleCtrlHandler (NULL
, TRUE
);
20633 case CTRL_LOGOFF_EVENT
:
20634 case CTRL_SHUTDOWN_EVENT
:
20638 SetConsoleCtrlHandler (NULL
, TRUE
);
20646 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
20648 if (callback
== NULL
)
20650 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
20654 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
20660 void sigHandler_default (int sig
)
20664 signal (sig
, NULL
);
20667 void sigHandler_benchmark (int sig
)
20671 signal (sig
, NULL
);
20674 void hc_signal (void (callback
) (int))
20676 if (callback
== NULL
) callback
= SIG_DFL
;
20678 signal (SIGINT
, callback
);
20679 signal (SIGTERM
, callback
);
20680 signal (SIGABRT
, callback
);
20685 void status_display ();
20687 void *thread_keypress (void *p
)
20689 int benchmark
= *((int *) p
);
20691 uint quiet
= data
.quiet
;
20695 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
20697 int ch
= tty_getchar();
20699 if (ch
== -1) break;
20701 if (ch
== 0) continue;
20703 //https://github.com/hashcat/hashcat/issues/302
20708 hc_thread_mutex_lock (mux_display
);
20724 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20725 if (quiet
== 0) fflush (stdout
);
20737 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20738 if (quiet
== 0) fflush (stdout
);
20750 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20751 if (quiet
== 0) fflush (stdout
);
20763 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20764 if (quiet
== 0) fflush (stdout
);
20772 if (benchmark
== 1) break;
20774 stop_at_checkpoint ();
20778 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20779 if (quiet
== 0) fflush (stdout
);
20787 if (benchmark
== 1)
20799 //https://github.com/hashcat/hashcat/issues/302
20804 hc_thread_mutex_unlock (mux_display
);
20816 bool class_num (const u8 c
)
20818 return ((c
>= '0') && (c
<= '9'));
20821 bool class_lower (const u8 c
)
20823 return ((c
>= 'a') && (c
<= 'z'));
20826 bool class_upper (const u8 c
)
20828 return ((c
>= 'A') && (c
<= 'Z'));
20831 bool class_alpha (const u8 c
)
20833 return (class_lower (c
) || class_upper (c
));
20836 int conv_ctoi (const u8 c
)
20842 else if (class_upper (c
))
20844 return c
- 'A' + 10;
20850 int conv_itoc (const u8 c
)
20858 return c
+ 'A' - 10;
20868 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20869 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20870 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20871 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20872 #define MAX_KERNEL_RULES 255
20873 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20874 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20875 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20877 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20878 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20879 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20880 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20882 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20887 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20889 switch (rule_buf
[rule_pos
])
20895 case RULE_OP_MANGLE_NOOP
:
20896 SET_NAME (rule
, rule_buf
[rule_pos
]);
20899 case RULE_OP_MANGLE_LREST
:
20900 SET_NAME (rule
, rule_buf
[rule_pos
]);
20903 case RULE_OP_MANGLE_UREST
:
20904 SET_NAME (rule
, rule_buf
[rule_pos
]);
20907 case RULE_OP_MANGLE_LREST_UFIRST
:
20908 SET_NAME (rule
, rule_buf
[rule_pos
]);
20911 case RULE_OP_MANGLE_UREST_LFIRST
:
20912 SET_NAME (rule
, rule_buf
[rule_pos
]);
20915 case RULE_OP_MANGLE_TREST
:
20916 SET_NAME (rule
, rule_buf
[rule_pos
]);
20919 case RULE_OP_MANGLE_TOGGLE_AT
:
20920 SET_NAME (rule
, rule_buf
[rule_pos
]);
20921 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20924 case RULE_OP_MANGLE_REVERSE
:
20925 SET_NAME (rule
, rule_buf
[rule_pos
]);
20928 case RULE_OP_MANGLE_DUPEWORD
:
20929 SET_NAME (rule
, rule_buf
[rule_pos
]);
20932 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20933 SET_NAME (rule
, rule_buf
[rule_pos
]);
20934 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20937 case RULE_OP_MANGLE_REFLECT
:
20938 SET_NAME (rule
, rule_buf
[rule_pos
]);
20941 case RULE_OP_MANGLE_ROTATE_LEFT
:
20942 SET_NAME (rule
, rule_buf
[rule_pos
]);
20945 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20946 SET_NAME (rule
, rule_buf
[rule_pos
]);
20949 case RULE_OP_MANGLE_APPEND
:
20950 SET_NAME (rule
, rule_buf
[rule_pos
]);
20951 SET_P0 (rule
, rule_buf
[rule_pos
]);
20954 case RULE_OP_MANGLE_PREPEND
:
20955 SET_NAME (rule
, rule_buf
[rule_pos
]);
20956 SET_P0 (rule
, rule_buf
[rule_pos
]);
20959 case RULE_OP_MANGLE_DELETE_FIRST
:
20960 SET_NAME (rule
, rule_buf
[rule_pos
]);
20963 case RULE_OP_MANGLE_DELETE_LAST
:
20964 SET_NAME (rule
, rule_buf
[rule_pos
]);
20967 case RULE_OP_MANGLE_DELETE_AT
:
20968 SET_NAME (rule
, rule_buf
[rule_pos
]);
20969 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20972 case RULE_OP_MANGLE_EXTRACT
:
20973 SET_NAME (rule
, rule_buf
[rule_pos
]);
20974 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20975 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20978 case RULE_OP_MANGLE_OMIT
:
20979 SET_NAME (rule
, rule_buf
[rule_pos
]);
20980 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20981 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20984 case RULE_OP_MANGLE_INSERT
:
20985 SET_NAME (rule
, rule_buf
[rule_pos
]);
20986 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20987 SET_P1 (rule
, rule_buf
[rule_pos
]);
20990 case RULE_OP_MANGLE_OVERSTRIKE
:
20991 SET_NAME (rule
, rule_buf
[rule_pos
]);
20992 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20993 SET_P1 (rule
, rule_buf
[rule_pos
]);
20996 case RULE_OP_MANGLE_TRUNCATE_AT
:
20997 SET_NAME (rule
, rule_buf
[rule_pos
]);
20998 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21001 case RULE_OP_MANGLE_REPLACE
:
21002 SET_NAME (rule
, rule_buf
[rule_pos
]);
21003 SET_P0 (rule
, rule_buf
[rule_pos
]);
21004 SET_P1 (rule
, rule_buf
[rule_pos
]);
21007 case RULE_OP_MANGLE_PURGECHAR
:
21011 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21015 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21016 SET_NAME (rule
, rule_buf
[rule_pos
]);
21017 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21020 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21021 SET_NAME (rule
, rule_buf
[rule_pos
]);
21022 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21025 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21026 SET_NAME (rule
, rule_buf
[rule_pos
]);
21029 case RULE_OP_MANGLE_SWITCH_FIRST
:
21030 SET_NAME (rule
, rule_buf
[rule_pos
]);
21033 case RULE_OP_MANGLE_SWITCH_LAST
:
21034 SET_NAME (rule
, rule_buf
[rule_pos
]);
21037 case RULE_OP_MANGLE_SWITCH_AT
:
21038 SET_NAME (rule
, rule_buf
[rule_pos
]);
21039 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21040 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21043 case RULE_OP_MANGLE_CHR_SHIFTL
:
21044 SET_NAME (rule
, rule_buf
[rule_pos
]);
21045 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21048 case RULE_OP_MANGLE_CHR_SHIFTR
:
21049 SET_NAME (rule
, rule_buf
[rule_pos
]);
21050 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21053 case RULE_OP_MANGLE_CHR_INCR
:
21054 SET_NAME (rule
, rule_buf
[rule_pos
]);
21055 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21058 case RULE_OP_MANGLE_CHR_DECR
:
21059 SET_NAME (rule
, rule_buf
[rule_pos
]);
21060 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21063 case RULE_OP_MANGLE_REPLACE_NP1
:
21064 SET_NAME (rule
, rule_buf
[rule_pos
]);
21065 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21068 case RULE_OP_MANGLE_REPLACE_NM1
:
21069 SET_NAME (rule
, rule_buf
[rule_pos
]);
21070 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21073 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21074 SET_NAME (rule
, rule_buf
[rule_pos
]);
21075 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21078 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21079 SET_NAME (rule
, rule_buf
[rule_pos
]);
21080 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21083 case RULE_OP_MANGLE_TITLE
:
21084 SET_NAME (rule
, rule_buf
[rule_pos
]);
21093 if (rule_pos
< rule_len
) return (-1);
21098 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
21102 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
21106 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
21110 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
21114 case RULE_OP_MANGLE_NOOP
:
21115 rule_buf
[rule_pos
] = rule_cmd
;
21118 case RULE_OP_MANGLE_LREST
:
21119 rule_buf
[rule_pos
] = rule_cmd
;
21122 case RULE_OP_MANGLE_UREST
:
21123 rule_buf
[rule_pos
] = rule_cmd
;
21126 case RULE_OP_MANGLE_LREST_UFIRST
:
21127 rule_buf
[rule_pos
] = rule_cmd
;
21130 case RULE_OP_MANGLE_UREST_LFIRST
:
21131 rule_buf
[rule_pos
] = rule_cmd
;
21134 case RULE_OP_MANGLE_TREST
:
21135 rule_buf
[rule_pos
] = rule_cmd
;
21138 case RULE_OP_MANGLE_TOGGLE_AT
:
21139 rule_buf
[rule_pos
] = rule_cmd
;
21140 GET_P0_CONV (rule
);
21143 case RULE_OP_MANGLE_REVERSE
:
21144 rule_buf
[rule_pos
] = rule_cmd
;
21147 case RULE_OP_MANGLE_DUPEWORD
:
21148 rule_buf
[rule_pos
] = rule_cmd
;
21151 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21152 rule_buf
[rule_pos
] = rule_cmd
;
21153 GET_P0_CONV (rule
);
21156 case RULE_OP_MANGLE_REFLECT
:
21157 rule_buf
[rule_pos
] = rule_cmd
;
21160 case RULE_OP_MANGLE_ROTATE_LEFT
:
21161 rule_buf
[rule_pos
] = rule_cmd
;
21164 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21165 rule_buf
[rule_pos
] = rule_cmd
;
21168 case RULE_OP_MANGLE_APPEND
:
21169 rule_buf
[rule_pos
] = rule_cmd
;
21173 case RULE_OP_MANGLE_PREPEND
:
21174 rule_buf
[rule_pos
] = rule_cmd
;
21178 case RULE_OP_MANGLE_DELETE_FIRST
:
21179 rule_buf
[rule_pos
] = rule_cmd
;
21182 case RULE_OP_MANGLE_DELETE_LAST
:
21183 rule_buf
[rule_pos
] = rule_cmd
;
21186 case RULE_OP_MANGLE_DELETE_AT
:
21187 rule_buf
[rule_pos
] = rule_cmd
;
21188 GET_P0_CONV (rule
);
21191 case RULE_OP_MANGLE_EXTRACT
:
21192 rule_buf
[rule_pos
] = rule_cmd
;
21193 GET_P0_CONV (rule
);
21194 GET_P1_CONV (rule
);
21197 case RULE_OP_MANGLE_OMIT
:
21198 rule_buf
[rule_pos
] = rule_cmd
;
21199 GET_P0_CONV (rule
);
21200 GET_P1_CONV (rule
);
21203 case RULE_OP_MANGLE_INSERT
:
21204 rule_buf
[rule_pos
] = rule_cmd
;
21205 GET_P0_CONV (rule
);
21209 case RULE_OP_MANGLE_OVERSTRIKE
:
21210 rule_buf
[rule_pos
] = rule_cmd
;
21211 GET_P0_CONV (rule
);
21215 case RULE_OP_MANGLE_TRUNCATE_AT
:
21216 rule_buf
[rule_pos
] = rule_cmd
;
21217 GET_P0_CONV (rule
);
21220 case RULE_OP_MANGLE_REPLACE
:
21221 rule_buf
[rule_pos
] = rule_cmd
;
21226 case RULE_OP_MANGLE_PURGECHAR
:
21230 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21234 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21235 rule_buf
[rule_pos
] = rule_cmd
;
21236 GET_P0_CONV (rule
);
21239 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21240 rule_buf
[rule_pos
] = rule_cmd
;
21241 GET_P0_CONV (rule
);
21244 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21245 rule_buf
[rule_pos
] = rule_cmd
;
21248 case RULE_OP_MANGLE_SWITCH_FIRST
:
21249 rule_buf
[rule_pos
] = rule_cmd
;
21252 case RULE_OP_MANGLE_SWITCH_LAST
:
21253 rule_buf
[rule_pos
] = rule_cmd
;
21256 case RULE_OP_MANGLE_SWITCH_AT
:
21257 rule_buf
[rule_pos
] = rule_cmd
;
21258 GET_P0_CONV (rule
);
21259 GET_P1_CONV (rule
);
21262 case RULE_OP_MANGLE_CHR_SHIFTL
:
21263 rule_buf
[rule_pos
] = rule_cmd
;
21264 GET_P0_CONV (rule
);
21267 case RULE_OP_MANGLE_CHR_SHIFTR
:
21268 rule_buf
[rule_pos
] = rule_cmd
;
21269 GET_P0_CONV (rule
);
21272 case RULE_OP_MANGLE_CHR_INCR
:
21273 rule_buf
[rule_pos
] = rule_cmd
;
21274 GET_P0_CONV (rule
);
21277 case RULE_OP_MANGLE_CHR_DECR
:
21278 rule_buf
[rule_pos
] = rule_cmd
;
21279 GET_P0_CONV (rule
);
21282 case RULE_OP_MANGLE_REPLACE_NP1
:
21283 rule_buf
[rule_pos
] = rule_cmd
;
21284 GET_P0_CONV (rule
);
21287 case RULE_OP_MANGLE_REPLACE_NM1
:
21288 rule_buf
[rule_pos
] = rule_cmd
;
21289 GET_P0_CONV (rule
);
21292 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21293 rule_buf
[rule_pos
] = rule_cmd
;
21294 GET_P0_CONV (rule
);
21297 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21298 rule_buf
[rule_pos
] = rule_cmd
;
21299 GET_P0_CONV (rule
);
21302 case RULE_OP_MANGLE_TITLE
:
21303 rule_buf
[rule_pos
] = rule_cmd
;
21307 return rule_pos
- 1;
21325 * CPU rules : this is from hashcat sources, cpu based rules
21328 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
21329 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
21331 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
21332 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
21333 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
21335 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
21336 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
21337 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
21339 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
21343 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
21348 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
21352 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
21357 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
21361 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
21366 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
21371 for (l
= 0; l
< arr_len
; l
++)
21373 r
= arr_len
- 1 - l
;
21377 MANGLE_SWITCH (arr
, l
, r
);
21383 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
21385 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21387 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
21389 return (arr_len
* 2);
21392 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
21394 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21396 int orig_len
= arr_len
;
21400 for (i
= 0; i
< times
; i
++)
21402 memcpy (&arr
[arr_len
], arr
, orig_len
);
21404 arr_len
+= orig_len
;
21410 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
21412 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21414 mangle_double (arr
, arr_len
);
21416 mangle_reverse (arr
+ arr_len
, arr_len
);
21418 return (arr_len
* 2);
21421 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
21426 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
21428 MANGLE_SWITCH (arr
, l
, r
);
21434 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
21439 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
21441 MANGLE_SWITCH (arr
, l
, r
);
21447 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21449 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21453 return (arr_len
+ 1);
21456 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21458 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21462 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21464 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21469 return (arr_len
+ 1);
21472 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21474 if (upos
>= arr_len
) return (arr_len
);
21478 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
21480 arr
[arr_pos
] = arr
[arr_pos
+ 1];
21483 return (arr_len
- 1);
21486 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21488 if (upos
>= arr_len
) return (arr_len
);
21490 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
21494 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
21496 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
21502 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21504 if (upos
>= arr_len
) return (arr_len
);
21506 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
21510 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
21512 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
21515 return (arr_len
- ulen
);
21518 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21520 if (upos
>= arr_len
) return (arr_len
);
21522 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21526 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
21528 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21533 return (arr_len
+ 1);
21536 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
)
21538 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21540 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
21542 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
21544 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
21546 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
21548 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
21550 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
21552 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
21554 return (arr_len
+ arr2_cpy
);
21557 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21559 if (upos
>= arr_len
) return (arr_len
);
21566 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21568 if (upos
>= arr_len
) return (arr_len
);
21570 memset (arr
+ upos
, 0, arr_len
- upos
);
21575 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
21579 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21581 if (arr
[arr_pos
] != oldc
) continue;
21583 arr
[arr_pos
] = newc
;
21589 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21595 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21597 if (arr
[arr_pos
] == c
) continue;
21599 arr
[ret_len
] = arr
[arr_pos
];
21607 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21609 if (ulen
> arr_len
) return (arr_len
);
21611 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21613 char cs
[100] = { 0 };
21615 memcpy (cs
, arr
, ulen
);
21619 for (i
= 0; i
< ulen
; i
++)
21623 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
21629 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21631 if (ulen
> arr_len
) return (arr_len
);
21633 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21635 int upos
= arr_len
- ulen
;
21639 for (i
= 0; i
< ulen
; i
++)
21641 char c
= arr
[upos
+ i
];
21643 arr_len
= mangle_append (arr
, arr_len
, c
);
21649 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21651 if ( arr_len
== 0) return (arr_len
);
21652 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21654 char c
= arr
[upos
];
21658 for (i
= 0; i
< ulen
; i
++)
21660 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
21666 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
21668 if ( arr_len
== 0) return (arr_len
);
21669 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21673 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21675 int new_pos
= arr_pos
* 2;
21677 arr
[new_pos
] = arr
[arr_pos
];
21679 arr
[new_pos
+ 1] = arr
[arr_pos
];
21682 return (arr_len
* 2);
21685 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21687 if (upos
>= arr_len
) return (arr_len
);
21688 if (upos2
>= arr_len
) return (arr_len
);
21690 MANGLE_SWITCH (arr
, upos
, upos2
);
21695 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21697 MANGLE_SWITCH (arr
, upos
, upos2
);
21702 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21704 if (upos
>= arr_len
) return (arr_len
);
21711 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21713 if (upos
>= arr_len
) return (arr_len
);
21720 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21722 if (upos
>= arr_len
) return (arr_len
);
21729 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21731 if (upos
>= arr_len
) return (arr_len
);
21738 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21740 int upper_next
= 1;
21744 for (pos
= 0; pos
< arr_len
; pos
++)
21746 if (arr
[pos
] == ' ')
21757 MANGLE_UPPER_AT (arr
, pos
);
21761 MANGLE_LOWER_AT (arr
, pos
);
21768 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21770 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21776 for (j
= 0; j
< rp_gen_num
; j
++)
21783 switch ((char) get_random_num (0, 9))
21786 r
= get_random_num (0, sizeof (grp_op_nop
));
21787 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21791 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21792 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21793 p1
= get_random_num (0, sizeof (grp_pos
));
21794 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21798 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21799 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21800 p1
= get_random_num (1, 6);
21801 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21805 r
= get_random_num (0, sizeof (grp_op_chr
));
21806 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21807 p1
= get_random_num (0x20, 0x7e);
21808 rule_buf
[rule_pos
++] = (char) p1
;
21812 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21813 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21814 p1
= get_random_num (0x20, 0x7e);
21815 rule_buf
[rule_pos
++] = (char) p1
;
21816 p2
= get_random_num (0x20, 0x7e);
21818 p2
= get_random_num (0x20, 0x7e);
21819 rule_buf
[rule_pos
++] = (char) p2
;
21823 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21824 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21825 p1
= get_random_num (0, sizeof (grp_pos
));
21826 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21827 p2
= get_random_num (0x20, 0x7e);
21828 rule_buf
[rule_pos
++] = (char) p2
;
21832 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21833 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21834 p1
= get_random_num (0, sizeof (grp_pos
));
21835 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21836 p2
= get_random_num (0, sizeof (grp_pos
));
21838 p2
= get_random_num (0, sizeof (grp_pos
));
21839 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21843 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21844 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21845 p1
= get_random_num (0, sizeof (grp_pos
));
21846 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21847 p2
= get_random_num (1, sizeof (grp_pos
));
21849 p2
= get_random_num (1, sizeof (grp_pos
));
21850 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21854 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21855 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21856 p1
= get_random_num (0, sizeof (grp_pos
));
21857 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21858 p2
= get_random_num (1, sizeof (grp_pos
));
21859 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21860 p3
= get_random_num (0, sizeof (grp_pos
));
21861 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21869 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21871 char mem
[BLOCK_SIZE
] = { 0 };
21873 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21875 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21877 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21879 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21881 int out_len
= in_len
;
21882 int mem_len
= in_len
;
21884 memcpy (out
, in
, out_len
);
21888 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21893 switch (rule
[rule_pos
])
21898 case RULE_OP_MANGLE_NOOP
:
21901 case RULE_OP_MANGLE_LREST
:
21902 out_len
= mangle_lrest (out
, out_len
);
21905 case RULE_OP_MANGLE_UREST
:
21906 out_len
= mangle_urest (out
, out_len
);
21909 case RULE_OP_MANGLE_LREST_UFIRST
:
21910 out_len
= mangle_lrest (out
, out_len
);
21911 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21914 case RULE_OP_MANGLE_UREST_LFIRST
:
21915 out_len
= mangle_urest (out
, out_len
);
21916 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21919 case RULE_OP_MANGLE_TREST
:
21920 out_len
= mangle_trest (out
, out_len
);
21923 case RULE_OP_MANGLE_TOGGLE_AT
:
21924 NEXT_RULEPOS (rule_pos
);
21925 NEXT_RPTOI (rule
, rule_pos
, upos
);
21926 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21929 case RULE_OP_MANGLE_REVERSE
:
21930 out_len
= mangle_reverse (out
, out_len
);
21933 case RULE_OP_MANGLE_DUPEWORD
:
21934 out_len
= mangle_double (out
, out_len
);
21937 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21938 NEXT_RULEPOS (rule_pos
);
21939 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21940 out_len
= mangle_double_times (out
, out_len
, ulen
);
21943 case RULE_OP_MANGLE_REFLECT
:
21944 out_len
= mangle_reflect (out
, out_len
);
21947 case RULE_OP_MANGLE_ROTATE_LEFT
:
21948 mangle_rotate_left (out
, out_len
);
21951 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21952 mangle_rotate_right (out
, out_len
);
21955 case RULE_OP_MANGLE_APPEND
:
21956 NEXT_RULEPOS (rule_pos
);
21957 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
21960 case RULE_OP_MANGLE_PREPEND
:
21961 NEXT_RULEPOS (rule_pos
);
21962 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
21965 case RULE_OP_MANGLE_DELETE_FIRST
:
21966 out_len
= mangle_delete_at (out
, out_len
, 0);
21969 case RULE_OP_MANGLE_DELETE_LAST
:
21970 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
21973 case RULE_OP_MANGLE_DELETE_AT
:
21974 NEXT_RULEPOS (rule_pos
);
21975 NEXT_RPTOI (rule
, rule_pos
, upos
);
21976 out_len
= mangle_delete_at (out
, out_len
, upos
);
21979 case RULE_OP_MANGLE_EXTRACT
:
21980 NEXT_RULEPOS (rule_pos
);
21981 NEXT_RPTOI (rule
, rule_pos
, upos
);
21982 NEXT_RULEPOS (rule_pos
);
21983 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21984 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
21987 case RULE_OP_MANGLE_OMIT
:
21988 NEXT_RULEPOS (rule_pos
);
21989 NEXT_RPTOI (rule
, rule_pos
, upos
);
21990 NEXT_RULEPOS (rule_pos
);
21991 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21992 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
21995 case RULE_OP_MANGLE_INSERT
:
21996 NEXT_RULEPOS (rule_pos
);
21997 NEXT_RPTOI (rule
, rule_pos
, upos
);
21998 NEXT_RULEPOS (rule_pos
);
21999 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
22002 case RULE_OP_MANGLE_OVERSTRIKE
:
22003 NEXT_RULEPOS (rule_pos
);
22004 NEXT_RPTOI (rule
, rule_pos
, upos
);
22005 NEXT_RULEPOS (rule_pos
);
22006 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
22009 case RULE_OP_MANGLE_TRUNCATE_AT
:
22010 NEXT_RULEPOS (rule_pos
);
22011 NEXT_RPTOI (rule
, rule_pos
, upos
);
22012 out_len
= mangle_truncate_at (out
, out_len
, upos
);
22015 case RULE_OP_MANGLE_REPLACE
:
22016 NEXT_RULEPOS (rule_pos
);
22017 NEXT_RULEPOS (rule_pos
);
22018 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
22021 case RULE_OP_MANGLE_PURGECHAR
:
22022 NEXT_RULEPOS (rule_pos
);
22023 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
22026 case RULE_OP_MANGLE_TOGGLECASE_REC
:
22030 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
22031 NEXT_RULEPOS (rule_pos
);
22032 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22033 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
22036 case RULE_OP_MANGLE_DUPECHAR_LAST
:
22037 NEXT_RULEPOS (rule_pos
);
22038 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22039 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
22042 case RULE_OP_MANGLE_DUPECHAR_ALL
:
22043 out_len
= mangle_dupechar (out
, out_len
);
22046 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
22047 NEXT_RULEPOS (rule_pos
);
22048 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22049 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
22052 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
22053 NEXT_RULEPOS (rule_pos
);
22054 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22055 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
22058 case RULE_OP_MANGLE_SWITCH_FIRST
:
22059 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
22062 case RULE_OP_MANGLE_SWITCH_LAST
:
22063 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
22066 case RULE_OP_MANGLE_SWITCH_AT
:
22067 NEXT_RULEPOS (rule_pos
);
22068 NEXT_RPTOI (rule
, rule_pos
, upos
);
22069 NEXT_RULEPOS (rule_pos
);
22070 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22071 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
22074 case RULE_OP_MANGLE_CHR_SHIFTL
:
22075 NEXT_RULEPOS (rule_pos
);
22076 NEXT_RPTOI (rule
, rule_pos
, upos
);
22077 mangle_chr_shiftl (out
, out_len
, upos
);
22080 case RULE_OP_MANGLE_CHR_SHIFTR
:
22081 NEXT_RULEPOS (rule_pos
);
22082 NEXT_RPTOI (rule
, rule_pos
, upos
);
22083 mangle_chr_shiftr (out
, out_len
, upos
);
22086 case RULE_OP_MANGLE_CHR_INCR
:
22087 NEXT_RULEPOS (rule_pos
);
22088 NEXT_RPTOI (rule
, rule_pos
, upos
);
22089 mangle_chr_incr (out
, out_len
, upos
);
22092 case RULE_OP_MANGLE_CHR_DECR
:
22093 NEXT_RULEPOS (rule_pos
);
22094 NEXT_RPTOI (rule
, rule_pos
, upos
);
22095 mangle_chr_decr (out
, out_len
, upos
);
22098 case RULE_OP_MANGLE_REPLACE_NP1
:
22099 NEXT_RULEPOS (rule_pos
);
22100 NEXT_RPTOI (rule
, rule_pos
, upos
);
22101 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
22104 case RULE_OP_MANGLE_REPLACE_NM1
:
22105 NEXT_RULEPOS (rule_pos
);
22106 NEXT_RPTOI (rule
, rule_pos
, upos
);
22107 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
22110 case RULE_OP_MANGLE_TITLE
:
22111 out_len
= mangle_title (out
, out_len
);
22114 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
22115 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22116 NEXT_RULEPOS (rule_pos
);
22117 NEXT_RPTOI (rule
, rule_pos
, upos
);
22118 NEXT_RULEPOS (rule_pos
);
22119 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22120 NEXT_RULEPOS (rule_pos
);
22121 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22122 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
22125 case RULE_OP_MANGLE_APPEND_MEMORY
:
22126 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22127 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22128 memcpy (out
+ out_len
, mem
, mem_len
);
22129 out_len
+= mem_len
;
22132 case RULE_OP_MANGLE_PREPEND_MEMORY
:
22133 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22134 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22135 memcpy (mem
+ mem_len
, out
, out_len
);
22136 out_len
+= mem_len
;
22137 memcpy (out
, mem
, out_len
);
22140 case RULE_OP_MEMORIZE_WORD
:
22141 memcpy (mem
, out
, out_len
);
22145 case RULE_OP_REJECT_LESS
:
22146 NEXT_RULEPOS (rule_pos
);
22147 NEXT_RPTOI (rule
, rule_pos
, upos
);
22148 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
22151 case RULE_OP_REJECT_GREATER
:
22152 NEXT_RULEPOS (rule_pos
);
22153 NEXT_RPTOI (rule
, rule_pos
, upos
);
22154 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
22157 case RULE_OP_REJECT_CONTAIN
:
22158 NEXT_RULEPOS (rule_pos
);
22159 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
22162 case RULE_OP_REJECT_NOT_CONTAIN
:
22163 NEXT_RULEPOS (rule_pos
);
22164 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
22167 case RULE_OP_REJECT_EQUAL_FIRST
:
22168 NEXT_RULEPOS (rule_pos
);
22169 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22172 case RULE_OP_REJECT_EQUAL_LAST
:
22173 NEXT_RULEPOS (rule_pos
);
22174 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22177 case RULE_OP_REJECT_EQUAL_AT
:
22178 NEXT_RULEPOS (rule_pos
);
22179 NEXT_RPTOI (rule
, rule_pos
, upos
);
22180 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22181 NEXT_RULEPOS (rule_pos
);
22182 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22185 case RULE_OP_REJECT_CONTAINS
:
22186 NEXT_RULEPOS (rule_pos
);
22187 NEXT_RPTOI (rule
, rule_pos
, upos
);
22188 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22189 NEXT_RULEPOS (rule_pos
);
22190 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
22191 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
22194 case RULE_OP_REJECT_MEMORY
:
22195 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
22199 return (RULE_RC_SYNTAX_ERROR
);
22204 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);