2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
20 u32
is_power_of_2(u32 v
)
22 return (v
&& !(v
& (v
- 1)));
25 u32
rotl32 (const u32 a
, const u32 n
)
27 return ((a
<< n
) | (a
>> (32 - n
)));
30 u32
rotr32 (const u32 a
, const u32 n
)
32 return ((a
>> n
) | (a
<< (32 - n
)));
35 u64
rotl64 (const u64 a
, const u64 n
)
37 return ((a
<< n
) | (a
>> (64 - n
)));
40 u64
rotr64 (const u64 a
, const u64 n
)
42 return ((a
>> n
) | (a
<< (64 - n
)));
45 u32
byte_swap_32 (const u32 n
)
47 return (n
& 0xff000000) >> 24
48 | (n
& 0x00ff0000) >> 8
49 | (n
& 0x0000ff00) << 8
50 | (n
& 0x000000ff) << 24;
53 u64
byte_swap_64 (const u64 n
)
55 return (n
& 0xff00000000000000ULL
) >> 56
56 | (n
& 0x00ff000000000000ULL
) >> 40
57 | (n
& 0x0000ff0000000000ULL
) >> 24
58 | (n
& 0x000000ff00000000ULL
) >> 8
59 | (n
& 0x00000000ff000000ULL
) << 8
60 | (n
& 0x0000000000ff0000ULL
) << 24
61 | (n
& 0x000000000000ff00ULL
) << 40
62 | (n
& 0x00000000000000ffULL
) << 56;
66 * ciphers for use on cpu
73 * hashes for use on cpu
78 #include "cpu-sha256.c"
86 void log_final (FILE *fp
, const char *fmt
, va_list ap
)
92 for (int i
= 0; i
< last_len
; i
++)
100 char s
[4096] = { 0 };
102 int max_len
= (int) sizeof (s
);
104 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
106 if (len
> max_len
) len
= max_len
;
108 fwrite (s
, len
, 1, fp
);
115 void log_out_nn (FILE *fp
, const char *fmt
, ...)
117 if (SUPPRESS_OUTPUT
) return;
123 log_final (fp
, fmt
, ap
);
128 void log_info_nn (const char *fmt
, ...)
130 if (SUPPRESS_OUTPUT
) return;
136 log_final (stdout
, fmt
, ap
);
141 void log_error_nn (const char *fmt
, ...)
143 if (SUPPRESS_OUTPUT
) return;
149 log_final (stderr
, fmt
, ap
);
154 void log_out (FILE *fp
, const char *fmt
, ...)
156 if (SUPPRESS_OUTPUT
) return;
162 log_final (fp
, fmt
, ap
);
171 void log_info (const char *fmt
, ...)
173 if (SUPPRESS_OUTPUT
) return;
179 log_final (stdout
, fmt
, ap
);
183 fputc ('\n', stdout
);
188 void log_error (const char *fmt
, ...)
190 if (SUPPRESS_OUTPUT
) return;
192 fputc ('\n', stderr
);
193 fputc ('\n', stderr
);
199 log_final (stderr
, fmt
, ap
);
203 fputc ('\n', stderr
);
204 fputc ('\n', stderr
);
213 u8
int_to_base32 (const u8 c
)
215 static const u8 tbl
[0x20] =
217 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
218 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
224 u8
base32_to_int (const u8 c
)
226 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
227 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
232 u8
int_to_itoa32 (const u8 c
)
234 static const u8 tbl
[0x20] =
236 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
237 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
243 u8
itoa32_to_int (const u8 c
)
245 if ((c
>= '0') && (c
<= '9')) return c
- '0';
246 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
251 u8
int_to_itoa64 (const u8 c
)
253 static const u8 tbl
[0x40] =
255 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
256 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
257 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
258 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
264 u8
itoa64_to_int (const u8 c
)
266 static const u8 tbl
[0x100] =
268 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
269 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
270 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
271 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
272 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
273 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
274 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
275 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
276 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
277 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
278 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
279 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
280 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
281 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
282 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
283 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
289 u8
int_to_base64 (const u8 c
)
291 static const u8 tbl
[0x40] =
293 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
294 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
295 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
296 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
302 u8
base64_to_int (const u8 c
)
304 static const u8 tbl
[0x100] =
306 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
307 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
308 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
309 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
310 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
311 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
312 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
313 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
314 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
315 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
316 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
317 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
318 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
319 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
320 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
321 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
327 u8
int_to_bf64 (const u8 c
)
329 static const u8 tbl
[0x40] =
331 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
332 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
333 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
334 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
340 u8
bf64_to_int (const u8 c
)
342 static const u8 tbl
[0x100] =
344 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
345 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
346 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
347 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
348 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
349 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
350 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
351 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
352 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
353 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
354 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
355 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
356 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
357 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
358 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
359 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
365 u8
int_to_lotus64 (const u8 c
)
367 if (c
< 10) return '0' + c
;
368 else if (c
< 36) return 'A' + c
- 10;
369 else if (c
< 62) return 'a' + c
- 36;
370 else if (c
== 62) return '+';
371 else if (c
== 63) return '/';
376 u8
lotus64_to_int (const u8 c
)
378 if ((c
>= '0') && (c
<= '9')) return c
- '0';
379 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
380 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
381 else if (c
== '+') return 62;
382 else if (c
== '/') return 63;
388 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
390 const u8
*in_ptr
= in_buf
;
392 u8
*out_ptr
= out_buf
;
394 for (int i
= 0; i
< in_len
; i
+= 8)
396 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
397 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
398 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
399 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
400 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
401 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
402 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
403 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
405 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
406 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
407 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
408 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
409 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
415 for (int i
= 0; i
< in_len
; i
++)
417 if (in_buf
[i
] != '=') continue;
422 int out_len
= (in_len
* 5) / 8;
427 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
429 const u8
*in_ptr
= in_buf
;
431 u8
*out_ptr
= out_buf
;
433 for (int i
= 0; i
< in_len
; i
+= 5)
435 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
436 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
437 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
438 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
439 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
440 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
441 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
442 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
444 out_ptr
[0] = out_val0
& 0x7f;
445 out_ptr
[1] = out_val1
& 0x7f;
446 out_ptr
[2] = out_val2
& 0x7f;
447 out_ptr
[3] = out_val3
& 0x7f;
448 out_ptr
[4] = out_val4
& 0x7f;
449 out_ptr
[5] = out_val5
& 0x7f;
450 out_ptr
[6] = out_val6
& 0x7f;
451 out_ptr
[7] = out_val7
& 0x7f;
457 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
461 out_buf
[out_len
] = '=';
469 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
471 const u8
*in_ptr
= in_buf
;
473 u8
*out_ptr
= out_buf
;
475 for (int i
= 0; i
< in_len
; i
+= 4)
477 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
478 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
479 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
480 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
482 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
483 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
484 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
490 for (int i
= 0; i
< in_len
; i
++)
492 if (in_buf
[i
] != '=') continue;
497 int out_len
= (in_len
* 6) / 8;
502 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
504 const u8
*in_ptr
= in_buf
;
506 u8
*out_ptr
= out_buf
;
508 for (int i
= 0; i
< in_len
; i
+= 3)
510 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
511 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
512 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
513 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
515 out_ptr
[0] = out_val0
& 0x7f;
516 out_ptr
[1] = out_val1
& 0x7f;
517 out_ptr
[2] = out_val2
& 0x7f;
518 out_ptr
[3] = out_val3
& 0x7f;
524 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
528 out_buf
[out_len
] = '=';
536 int is_valid_hex_char (const u8 c
)
538 if ((c
>= '0') && (c
<= '9')) return 1;
539 if ((c
>= 'A') && (c
<= 'F')) return 1;
540 if ((c
>= 'a') && (c
<= 'f')) return 1;
545 u8
hex_convert (const u8 c
)
547 return (c
& 15) + (c
>> 6) * 9;
550 u8
hex_to_u8 (const u8 hex
[2])
554 v
|= (hex_convert (hex
[1]) << 0);
555 v
|= (hex_convert (hex
[0]) << 4);
560 u32
hex_to_u32 (const u8 hex
[8])
564 v
|= ((u32
) hex_convert (hex
[7])) << 0;
565 v
|= ((u32
) hex_convert (hex
[6])) << 4;
566 v
|= ((u32
) hex_convert (hex
[5])) << 8;
567 v
|= ((u32
) hex_convert (hex
[4])) << 12;
568 v
|= ((u32
) hex_convert (hex
[3])) << 16;
569 v
|= ((u32
) hex_convert (hex
[2])) << 20;
570 v
|= ((u32
) hex_convert (hex
[1])) << 24;
571 v
|= ((u32
) hex_convert (hex
[0])) << 28;
576 u64
hex_to_u64 (const u8 hex
[16])
580 v
|= ((u64
) hex_convert (hex
[15]) << 0);
581 v
|= ((u64
) hex_convert (hex
[14]) << 4);
582 v
|= ((u64
) hex_convert (hex
[13]) << 8);
583 v
|= ((u64
) hex_convert (hex
[12]) << 12);
584 v
|= ((u64
) hex_convert (hex
[11]) << 16);
585 v
|= ((u64
) hex_convert (hex
[10]) << 20);
586 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
587 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
588 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
589 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
590 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
591 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
592 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
593 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
594 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
595 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
600 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
602 hex
[0] = v
>> 28 & 15;
603 hex
[1] = v
>> 24 & 15;
604 hex
[2] = v
>> 20 & 15;
605 hex
[3] = v
>> 16 & 15;
606 hex
[4] = v
>> 12 & 15;
607 hex
[5] = v
>> 8 & 15;
608 hex
[6] = v
>> 4 & 15;
609 hex
[7] = v
>> 0 & 15;
613 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
614 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
615 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
616 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
617 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
618 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
619 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
620 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
627 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
631 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
640 for (int i
= 0; i
< 16; i
+= 4)
650 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
657 out
[i
+ 0] = _out
[0];
658 out
[i
+ 1] = _out
[1];
659 out
[i
+ 2] = _out
[2];
660 out
[i
+ 3] = _out
[3];
669 static void juniper_decrypt_hash (char *in
, char *out
)
673 u8 base64_buf
[100] = { 0 };
675 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
679 u32 juniper_iv
[4] = { 0 };
681 memcpy (juniper_iv
, base64_buf
, 12);
683 memcpy (out
, juniper_iv
, 12);
687 u32 juniper_key
[4] = { 0 };
689 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
690 juniper_key
[1] = byte_swap_32 (0x8df91059);
691 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
692 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
696 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
697 u32
*out_ptr
= (u32
*) (out
+ 12);
699 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
702 void phpass_decode (u8 digest
[16], u8 buf
[22])
706 l
= itoa64_to_int (buf
[ 0]) << 0;
707 l
|= itoa64_to_int (buf
[ 1]) << 6;
708 l
|= itoa64_to_int (buf
[ 2]) << 12;
709 l
|= itoa64_to_int (buf
[ 3]) << 18;
711 digest
[ 0] = (l
>> 0) & 0xff;
712 digest
[ 1] = (l
>> 8) & 0xff;
713 digest
[ 2] = (l
>> 16) & 0xff;
715 l
= itoa64_to_int (buf
[ 4]) << 0;
716 l
|= itoa64_to_int (buf
[ 5]) << 6;
717 l
|= itoa64_to_int (buf
[ 6]) << 12;
718 l
|= itoa64_to_int (buf
[ 7]) << 18;
720 digest
[ 3] = (l
>> 0) & 0xff;
721 digest
[ 4] = (l
>> 8) & 0xff;
722 digest
[ 5] = (l
>> 16) & 0xff;
724 l
= itoa64_to_int (buf
[ 8]) << 0;
725 l
|= itoa64_to_int (buf
[ 9]) << 6;
726 l
|= itoa64_to_int (buf
[10]) << 12;
727 l
|= itoa64_to_int (buf
[11]) << 18;
729 digest
[ 6] = (l
>> 0) & 0xff;
730 digest
[ 7] = (l
>> 8) & 0xff;
731 digest
[ 8] = (l
>> 16) & 0xff;
733 l
= itoa64_to_int (buf
[12]) << 0;
734 l
|= itoa64_to_int (buf
[13]) << 6;
735 l
|= itoa64_to_int (buf
[14]) << 12;
736 l
|= itoa64_to_int (buf
[15]) << 18;
738 digest
[ 9] = (l
>> 0) & 0xff;
739 digest
[10] = (l
>> 8) & 0xff;
740 digest
[11] = (l
>> 16) & 0xff;
742 l
= itoa64_to_int (buf
[16]) << 0;
743 l
|= itoa64_to_int (buf
[17]) << 6;
744 l
|= itoa64_to_int (buf
[18]) << 12;
745 l
|= itoa64_to_int (buf
[19]) << 18;
747 digest
[12] = (l
>> 0) & 0xff;
748 digest
[13] = (l
>> 8) & 0xff;
749 digest
[14] = (l
>> 16) & 0xff;
751 l
= itoa64_to_int (buf
[20]) << 0;
752 l
|= itoa64_to_int (buf
[21]) << 6;
754 digest
[15] = (l
>> 0) & 0xff;
757 void phpass_encode (u8 digest
[16], u8 buf
[22])
761 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
763 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
764 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
765 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
766 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
768 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
770 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
771 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
772 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
773 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
775 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
777 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
778 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
779 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
780 buf
[11] = int_to_itoa64 (l
& 0x3f);
782 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
784 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
785 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
786 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
787 buf
[15] = int_to_itoa64 (l
& 0x3f);
789 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
791 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
792 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
793 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
794 buf
[19] = int_to_itoa64 (l
& 0x3f);
796 l
= (digest
[15] << 0);
798 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
799 buf
[21] = int_to_itoa64 (l
& 0x3f);
802 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
806 l
= itoa64_to_int (buf
[ 0]) << 0;
807 l
|= itoa64_to_int (buf
[ 1]) << 6;
808 l
|= itoa64_to_int (buf
[ 2]) << 12;
809 l
|= itoa64_to_int (buf
[ 3]) << 18;
811 digest
[ 0] = (l
>> 16) & 0xff;
812 digest
[ 6] = (l
>> 8) & 0xff;
813 digest
[12] = (l
>> 0) & 0xff;
815 l
= itoa64_to_int (buf
[ 4]) << 0;
816 l
|= itoa64_to_int (buf
[ 5]) << 6;
817 l
|= itoa64_to_int (buf
[ 6]) << 12;
818 l
|= itoa64_to_int (buf
[ 7]) << 18;
820 digest
[ 1] = (l
>> 16) & 0xff;
821 digest
[ 7] = (l
>> 8) & 0xff;
822 digest
[13] = (l
>> 0) & 0xff;
824 l
= itoa64_to_int (buf
[ 8]) << 0;
825 l
|= itoa64_to_int (buf
[ 9]) << 6;
826 l
|= itoa64_to_int (buf
[10]) << 12;
827 l
|= itoa64_to_int (buf
[11]) << 18;
829 digest
[ 2] = (l
>> 16) & 0xff;
830 digest
[ 8] = (l
>> 8) & 0xff;
831 digest
[14] = (l
>> 0) & 0xff;
833 l
= itoa64_to_int (buf
[12]) << 0;
834 l
|= itoa64_to_int (buf
[13]) << 6;
835 l
|= itoa64_to_int (buf
[14]) << 12;
836 l
|= itoa64_to_int (buf
[15]) << 18;
838 digest
[ 3] = (l
>> 16) & 0xff;
839 digest
[ 9] = (l
>> 8) & 0xff;
840 digest
[15] = (l
>> 0) & 0xff;
842 l
= itoa64_to_int (buf
[16]) << 0;
843 l
|= itoa64_to_int (buf
[17]) << 6;
844 l
|= itoa64_to_int (buf
[18]) << 12;
845 l
|= itoa64_to_int (buf
[19]) << 18;
847 digest
[ 4] = (l
>> 16) & 0xff;
848 digest
[10] = (l
>> 8) & 0xff;
849 digest
[ 5] = (l
>> 0) & 0xff;
851 l
= itoa64_to_int (buf
[20]) << 0;
852 l
|= itoa64_to_int (buf
[21]) << 6;
854 digest
[11] = (l
>> 0) & 0xff;
857 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
861 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
863 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
864 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
865 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
866 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
868 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
870 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
871 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
872 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
873 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
875 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
877 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
879 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
880 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
882 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
884 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
886 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
887 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
889 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
891 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
893 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
894 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
896 l
= (digest
[11] << 0);
898 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
899 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
902 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
906 l
= itoa64_to_int (buf
[ 0]) << 0;
907 l
|= itoa64_to_int (buf
[ 1]) << 6;
908 l
|= itoa64_to_int (buf
[ 2]) << 12;
909 l
|= itoa64_to_int (buf
[ 3]) << 18;
911 digest
[ 0] = (l
>> 16) & 0xff;
912 digest
[21] = (l
>> 8) & 0xff;
913 digest
[42] = (l
>> 0) & 0xff;
915 l
= itoa64_to_int (buf
[ 4]) << 0;
916 l
|= itoa64_to_int (buf
[ 5]) << 6;
917 l
|= itoa64_to_int (buf
[ 6]) << 12;
918 l
|= itoa64_to_int (buf
[ 7]) << 18;
920 digest
[22] = (l
>> 16) & 0xff;
921 digest
[43] = (l
>> 8) & 0xff;
922 digest
[ 1] = (l
>> 0) & 0xff;
924 l
= itoa64_to_int (buf
[ 8]) << 0;
925 l
|= itoa64_to_int (buf
[ 9]) << 6;
926 l
|= itoa64_to_int (buf
[10]) << 12;
927 l
|= itoa64_to_int (buf
[11]) << 18;
929 digest
[44] = (l
>> 16) & 0xff;
930 digest
[ 2] = (l
>> 8) & 0xff;
931 digest
[23] = (l
>> 0) & 0xff;
933 l
= itoa64_to_int (buf
[12]) << 0;
934 l
|= itoa64_to_int (buf
[13]) << 6;
935 l
|= itoa64_to_int (buf
[14]) << 12;
936 l
|= itoa64_to_int (buf
[15]) << 18;
938 digest
[ 3] = (l
>> 16) & 0xff;
939 digest
[24] = (l
>> 8) & 0xff;
940 digest
[45] = (l
>> 0) & 0xff;
942 l
= itoa64_to_int (buf
[16]) << 0;
943 l
|= itoa64_to_int (buf
[17]) << 6;
944 l
|= itoa64_to_int (buf
[18]) << 12;
945 l
|= itoa64_to_int (buf
[19]) << 18;
947 digest
[25] = (l
>> 16) & 0xff;
948 digest
[46] = (l
>> 8) & 0xff;
949 digest
[ 4] = (l
>> 0) & 0xff;
951 l
= itoa64_to_int (buf
[20]) << 0;
952 l
|= itoa64_to_int (buf
[21]) << 6;
953 l
|= itoa64_to_int (buf
[22]) << 12;
954 l
|= itoa64_to_int (buf
[23]) << 18;
956 digest
[47] = (l
>> 16) & 0xff;
957 digest
[ 5] = (l
>> 8) & 0xff;
958 digest
[26] = (l
>> 0) & 0xff;
960 l
= itoa64_to_int (buf
[24]) << 0;
961 l
|= itoa64_to_int (buf
[25]) << 6;
962 l
|= itoa64_to_int (buf
[26]) << 12;
963 l
|= itoa64_to_int (buf
[27]) << 18;
965 digest
[ 6] = (l
>> 16) & 0xff;
966 digest
[27] = (l
>> 8) & 0xff;
967 digest
[48] = (l
>> 0) & 0xff;
969 l
= itoa64_to_int (buf
[28]) << 0;
970 l
|= itoa64_to_int (buf
[29]) << 6;
971 l
|= itoa64_to_int (buf
[30]) << 12;
972 l
|= itoa64_to_int (buf
[31]) << 18;
974 digest
[28] = (l
>> 16) & 0xff;
975 digest
[49] = (l
>> 8) & 0xff;
976 digest
[ 7] = (l
>> 0) & 0xff;
978 l
= itoa64_to_int (buf
[32]) << 0;
979 l
|= itoa64_to_int (buf
[33]) << 6;
980 l
|= itoa64_to_int (buf
[34]) << 12;
981 l
|= itoa64_to_int (buf
[35]) << 18;
983 digest
[50] = (l
>> 16) & 0xff;
984 digest
[ 8] = (l
>> 8) & 0xff;
985 digest
[29] = (l
>> 0) & 0xff;
987 l
= itoa64_to_int (buf
[36]) << 0;
988 l
|= itoa64_to_int (buf
[37]) << 6;
989 l
|= itoa64_to_int (buf
[38]) << 12;
990 l
|= itoa64_to_int (buf
[39]) << 18;
992 digest
[ 9] = (l
>> 16) & 0xff;
993 digest
[30] = (l
>> 8) & 0xff;
994 digest
[51] = (l
>> 0) & 0xff;
996 l
= itoa64_to_int (buf
[40]) << 0;
997 l
|= itoa64_to_int (buf
[41]) << 6;
998 l
|= itoa64_to_int (buf
[42]) << 12;
999 l
|= itoa64_to_int (buf
[43]) << 18;
1001 digest
[31] = (l
>> 16) & 0xff;
1002 digest
[52] = (l
>> 8) & 0xff;
1003 digest
[10] = (l
>> 0) & 0xff;
1005 l
= itoa64_to_int (buf
[44]) << 0;
1006 l
|= itoa64_to_int (buf
[45]) << 6;
1007 l
|= itoa64_to_int (buf
[46]) << 12;
1008 l
|= itoa64_to_int (buf
[47]) << 18;
1010 digest
[53] = (l
>> 16) & 0xff;
1011 digest
[11] = (l
>> 8) & 0xff;
1012 digest
[32] = (l
>> 0) & 0xff;
1014 l
= itoa64_to_int (buf
[48]) << 0;
1015 l
|= itoa64_to_int (buf
[49]) << 6;
1016 l
|= itoa64_to_int (buf
[50]) << 12;
1017 l
|= itoa64_to_int (buf
[51]) << 18;
1019 digest
[12] = (l
>> 16) & 0xff;
1020 digest
[33] = (l
>> 8) & 0xff;
1021 digest
[54] = (l
>> 0) & 0xff;
1023 l
= itoa64_to_int (buf
[52]) << 0;
1024 l
|= itoa64_to_int (buf
[53]) << 6;
1025 l
|= itoa64_to_int (buf
[54]) << 12;
1026 l
|= itoa64_to_int (buf
[55]) << 18;
1028 digest
[34] = (l
>> 16) & 0xff;
1029 digest
[55] = (l
>> 8) & 0xff;
1030 digest
[13] = (l
>> 0) & 0xff;
1032 l
= itoa64_to_int (buf
[56]) << 0;
1033 l
|= itoa64_to_int (buf
[57]) << 6;
1034 l
|= itoa64_to_int (buf
[58]) << 12;
1035 l
|= itoa64_to_int (buf
[59]) << 18;
1037 digest
[56] = (l
>> 16) & 0xff;
1038 digest
[14] = (l
>> 8) & 0xff;
1039 digest
[35] = (l
>> 0) & 0xff;
1041 l
= itoa64_to_int (buf
[60]) << 0;
1042 l
|= itoa64_to_int (buf
[61]) << 6;
1043 l
|= itoa64_to_int (buf
[62]) << 12;
1044 l
|= itoa64_to_int (buf
[63]) << 18;
1046 digest
[15] = (l
>> 16) & 0xff;
1047 digest
[36] = (l
>> 8) & 0xff;
1048 digest
[57] = (l
>> 0) & 0xff;
1050 l
= itoa64_to_int (buf
[64]) << 0;
1051 l
|= itoa64_to_int (buf
[65]) << 6;
1052 l
|= itoa64_to_int (buf
[66]) << 12;
1053 l
|= itoa64_to_int (buf
[67]) << 18;
1055 digest
[37] = (l
>> 16) & 0xff;
1056 digest
[58] = (l
>> 8) & 0xff;
1057 digest
[16] = (l
>> 0) & 0xff;
1059 l
= itoa64_to_int (buf
[68]) << 0;
1060 l
|= itoa64_to_int (buf
[69]) << 6;
1061 l
|= itoa64_to_int (buf
[70]) << 12;
1062 l
|= itoa64_to_int (buf
[71]) << 18;
1064 digest
[59] = (l
>> 16) & 0xff;
1065 digest
[17] = (l
>> 8) & 0xff;
1066 digest
[38] = (l
>> 0) & 0xff;
1068 l
= itoa64_to_int (buf
[72]) << 0;
1069 l
|= itoa64_to_int (buf
[73]) << 6;
1070 l
|= itoa64_to_int (buf
[74]) << 12;
1071 l
|= itoa64_to_int (buf
[75]) << 18;
1073 digest
[18] = (l
>> 16) & 0xff;
1074 digest
[39] = (l
>> 8) & 0xff;
1075 digest
[60] = (l
>> 0) & 0xff;
1077 l
= itoa64_to_int (buf
[76]) << 0;
1078 l
|= itoa64_to_int (buf
[77]) << 6;
1079 l
|= itoa64_to_int (buf
[78]) << 12;
1080 l
|= itoa64_to_int (buf
[79]) << 18;
1082 digest
[40] = (l
>> 16) & 0xff;
1083 digest
[61] = (l
>> 8) & 0xff;
1084 digest
[19] = (l
>> 0) & 0xff;
1086 l
= itoa64_to_int (buf
[80]) << 0;
1087 l
|= itoa64_to_int (buf
[81]) << 6;
1088 l
|= itoa64_to_int (buf
[82]) << 12;
1089 l
|= itoa64_to_int (buf
[83]) << 18;
1091 digest
[62] = (l
>> 16) & 0xff;
1092 digest
[20] = (l
>> 8) & 0xff;
1093 digest
[41] = (l
>> 0) & 0xff;
1095 l
= itoa64_to_int (buf
[84]) << 0;
1096 l
|= itoa64_to_int (buf
[85]) << 6;
1098 digest
[63] = (l
>> 0) & 0xff;
1101 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1105 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1107 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1108 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1109 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1110 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1112 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1114 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1115 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1116 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1117 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1119 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1121 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1123 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1124 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1126 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1128 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1130 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1131 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1133 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1135 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1137 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1138 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1140 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1142 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1144 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1145 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1147 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1149 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1151 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1152 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1154 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1156 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1158 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1159 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1161 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1163 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1165 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1166 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1168 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1170 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1172 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1173 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1175 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1177 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1179 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1180 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1182 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1184 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1186 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1187 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1189 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1191 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1193 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1194 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1196 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1198 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1200 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1201 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1203 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1205 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1207 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1208 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1210 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1212 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1214 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1215 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1217 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1219 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1221 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1222 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1224 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1226 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1228 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1229 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1231 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1233 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1235 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1236 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1238 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1240 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1242 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1243 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1245 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1247 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1249 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1250 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1252 l
= 0 | 0 | (digest
[63] << 0);
1254 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1255 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1258 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1262 l
= itoa64_to_int (buf
[ 0]) << 0;
1263 l
|= itoa64_to_int (buf
[ 1]) << 6;
1264 l
|= itoa64_to_int (buf
[ 2]) << 12;
1265 l
|= itoa64_to_int (buf
[ 3]) << 18;
1267 digest
[ 2] = (l
>> 0) & 0xff;
1268 digest
[ 1] = (l
>> 8) & 0xff;
1269 digest
[ 0] = (l
>> 16) & 0xff;
1271 l
= itoa64_to_int (buf
[ 4]) << 0;
1272 l
|= itoa64_to_int (buf
[ 5]) << 6;
1273 l
|= itoa64_to_int (buf
[ 6]) << 12;
1274 l
|= itoa64_to_int (buf
[ 7]) << 18;
1276 digest
[ 5] = (l
>> 0) & 0xff;
1277 digest
[ 4] = (l
>> 8) & 0xff;
1278 digest
[ 3] = (l
>> 16) & 0xff;
1280 l
= itoa64_to_int (buf
[ 8]) << 0;
1281 l
|= itoa64_to_int (buf
[ 9]) << 6;
1282 l
|= itoa64_to_int (buf
[10]) << 12;
1283 l
|= itoa64_to_int (buf
[11]) << 18;
1285 digest
[ 8] = (l
>> 0) & 0xff;
1286 digest
[ 7] = (l
>> 8) & 0xff;
1287 digest
[ 6] = (l
>> 16) & 0xff;
1289 l
= itoa64_to_int (buf
[12]) << 0;
1290 l
|= itoa64_to_int (buf
[13]) << 6;
1291 l
|= itoa64_to_int (buf
[14]) << 12;
1292 l
|= itoa64_to_int (buf
[15]) << 18;
1294 digest
[11] = (l
>> 0) & 0xff;
1295 digest
[10] = (l
>> 8) & 0xff;
1296 digest
[ 9] = (l
>> 16) & 0xff;
1298 l
= itoa64_to_int (buf
[16]) << 0;
1299 l
|= itoa64_to_int (buf
[17]) << 6;
1300 l
|= itoa64_to_int (buf
[18]) << 12;
1301 l
|= itoa64_to_int (buf
[19]) << 18;
1303 digest
[14] = (l
>> 0) & 0xff;
1304 digest
[13] = (l
>> 8) & 0xff;
1305 digest
[12] = (l
>> 16) & 0xff;
1307 l
= itoa64_to_int (buf
[20]) << 0;
1308 l
|= itoa64_to_int (buf
[21]) << 6;
1309 l
|= itoa64_to_int (buf
[22]) << 12;
1310 l
|= itoa64_to_int (buf
[23]) << 18;
1312 digest
[17] = (l
>> 0) & 0xff;
1313 digest
[16] = (l
>> 8) & 0xff;
1314 digest
[15] = (l
>> 16) & 0xff;
1316 l
= itoa64_to_int (buf
[24]) << 0;
1317 l
|= itoa64_to_int (buf
[25]) << 6;
1318 l
|= itoa64_to_int (buf
[26]) << 12;
1320 digest
[19] = (l
>> 8) & 0xff;
1321 digest
[18] = (l
>> 16) & 0xff;
1324 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1328 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1330 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1331 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1332 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1333 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1335 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1337 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1338 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1339 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1340 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1342 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1344 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1345 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1346 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1347 buf
[11] = int_to_itoa64 (l
& 0x3f);
1349 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1351 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1352 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1353 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1354 buf
[15] = int_to_itoa64 (l
& 0x3f);
1356 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1358 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1359 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1360 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1361 buf
[19] = int_to_itoa64 (l
& 0x3f);
1363 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1365 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1366 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1367 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1368 buf
[23] = int_to_itoa64 (l
& 0x3f);
1370 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1372 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1373 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1374 buf
[26] = int_to_itoa64 (l
& 0x3f);
1377 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1381 l
= itoa64_to_int (buf
[ 0]) << 0;
1382 l
|= itoa64_to_int (buf
[ 1]) << 6;
1383 l
|= itoa64_to_int (buf
[ 2]) << 12;
1384 l
|= itoa64_to_int (buf
[ 3]) << 18;
1386 digest
[ 2] = (l
>> 0) & 0xff;
1387 digest
[ 1] = (l
>> 8) & 0xff;
1388 digest
[ 0] = (l
>> 16) & 0xff;
1390 l
= itoa64_to_int (buf
[ 4]) << 0;
1391 l
|= itoa64_to_int (buf
[ 5]) << 6;
1392 l
|= itoa64_to_int (buf
[ 6]) << 12;
1393 l
|= itoa64_to_int (buf
[ 7]) << 18;
1395 digest
[ 5] = (l
>> 0) & 0xff;
1396 digest
[ 4] = (l
>> 8) & 0xff;
1397 digest
[ 3] = (l
>> 16) & 0xff;
1399 l
= itoa64_to_int (buf
[ 8]) << 0;
1400 l
|= itoa64_to_int (buf
[ 9]) << 6;
1401 l
|= itoa64_to_int (buf
[10]) << 12;
1402 l
|= itoa64_to_int (buf
[11]) << 18;
1404 digest
[ 8] = (l
>> 0) & 0xff;
1405 digest
[ 7] = (l
>> 8) & 0xff;
1406 digest
[ 6] = (l
>> 16) & 0xff;
1408 l
= itoa64_to_int (buf
[12]) << 0;
1409 l
|= itoa64_to_int (buf
[13]) << 6;
1410 l
|= itoa64_to_int (buf
[14]) << 12;
1411 l
|= itoa64_to_int (buf
[15]) << 18;
1413 digest
[11] = (l
>> 0) & 0xff;
1414 digest
[10] = (l
>> 8) & 0xff;
1415 digest
[ 9] = (l
>> 16) & 0xff;
1417 l
= itoa64_to_int (buf
[16]) << 0;
1418 l
|= itoa64_to_int (buf
[17]) << 6;
1419 l
|= itoa64_to_int (buf
[18]) << 12;
1420 l
|= itoa64_to_int (buf
[19]) << 18;
1422 digest
[14] = (l
>> 0) & 0xff;
1423 digest
[13] = (l
>> 8) & 0xff;
1424 digest
[12] = (l
>> 16) & 0xff;
1426 l
= itoa64_to_int (buf
[20]) << 0;
1427 l
|= itoa64_to_int (buf
[21]) << 6;
1428 l
|= itoa64_to_int (buf
[22]) << 12;
1429 l
|= itoa64_to_int (buf
[23]) << 18;
1431 digest
[17] = (l
>> 0) & 0xff;
1432 digest
[16] = (l
>> 8) & 0xff;
1433 digest
[15] = (l
>> 16) & 0xff;
1435 l
= itoa64_to_int (buf
[24]) << 0;
1436 l
|= itoa64_to_int (buf
[25]) << 6;
1437 l
|= itoa64_to_int (buf
[26]) << 12;
1438 l
|= itoa64_to_int (buf
[27]) << 18;
1440 digest
[20] = (l
>> 0) & 0xff;
1441 digest
[19] = (l
>> 8) & 0xff;
1442 digest
[18] = (l
>> 16) & 0xff;
1444 l
= itoa64_to_int (buf
[28]) << 0;
1445 l
|= itoa64_to_int (buf
[29]) << 6;
1446 l
|= itoa64_to_int (buf
[30]) << 12;
1447 l
|= itoa64_to_int (buf
[31]) << 18;
1449 digest
[23] = (l
>> 0) & 0xff;
1450 digest
[22] = (l
>> 8) & 0xff;
1451 digest
[21] = (l
>> 16) & 0xff;
1453 l
= itoa64_to_int (buf
[32]) << 0;
1454 l
|= itoa64_to_int (buf
[33]) << 6;
1455 l
|= itoa64_to_int (buf
[34]) << 12;
1456 l
|= itoa64_to_int (buf
[35]) << 18;
1458 digest
[26] = (l
>> 0) & 0xff;
1459 digest
[25] = (l
>> 8) & 0xff;
1460 digest
[24] = (l
>> 16) & 0xff;
1462 l
= itoa64_to_int (buf
[36]) << 0;
1463 l
|= itoa64_to_int (buf
[37]) << 6;
1464 l
|= itoa64_to_int (buf
[38]) << 12;
1465 l
|= itoa64_to_int (buf
[39]) << 18;
1467 digest
[29] = (l
>> 0) & 0xff;
1468 digest
[28] = (l
>> 8) & 0xff;
1469 digest
[27] = (l
>> 16) & 0xff;
1471 l
= itoa64_to_int (buf
[40]) << 0;
1472 l
|= itoa64_to_int (buf
[41]) << 6;
1473 l
|= itoa64_to_int (buf
[42]) << 12;
1475 //digest[32] = (l >> 0) & 0xff;
1476 digest
[31] = (l
>> 8) & 0xff;
1477 digest
[30] = (l
>> 16) & 0xff;
1480 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1484 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1486 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1487 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1488 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1489 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1491 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1493 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1494 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1495 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1496 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1498 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1500 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1501 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1502 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1503 buf
[11] = int_to_itoa64 (l
& 0x3f);
1505 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1507 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1508 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1509 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1510 buf
[15] = int_to_itoa64 (l
& 0x3f);
1512 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1514 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1515 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1516 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1517 buf
[19] = int_to_itoa64 (l
& 0x3f);
1519 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1521 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1522 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1523 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1524 buf
[23] = int_to_itoa64 (l
& 0x3f);
1526 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1528 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1529 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1530 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1531 buf
[27] = int_to_itoa64 (l
& 0x3f);
1533 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1535 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1536 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1537 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1538 buf
[31] = int_to_itoa64 (l
& 0x3f);
1540 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1542 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1543 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1544 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1545 buf
[35] = int_to_itoa64 (l
& 0x3f);
1547 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1549 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1550 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1551 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1552 buf
[39] = int_to_itoa64 (l
& 0x3f);
1554 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1556 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1557 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1558 buf
[42] = int_to_itoa64 (l
& 0x3f);
1561 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1565 l
= itoa64_to_int (buf
[ 0]) << 0;
1566 l
|= itoa64_to_int (buf
[ 1]) << 6;
1567 l
|= itoa64_to_int (buf
[ 2]) << 12;
1568 l
|= itoa64_to_int (buf
[ 3]) << 18;
1570 digest
[ 2] = (l
>> 0) & 0xff;
1571 digest
[ 1] = (l
>> 8) & 0xff;
1572 digest
[ 0] = (l
>> 16) & 0xff;
1574 l
= itoa64_to_int (buf
[ 4]) << 0;
1575 l
|= itoa64_to_int (buf
[ 5]) << 6;
1576 l
|= itoa64_to_int (buf
[ 6]) << 12;
1577 l
|= itoa64_to_int (buf
[ 7]) << 18;
1579 digest
[ 5] = (l
>> 0) & 0xff;
1580 digest
[ 4] = (l
>> 8) & 0xff;
1581 digest
[ 3] = (l
>> 16) & 0xff;
1583 l
= itoa64_to_int (buf
[ 8]) << 0;
1584 l
|= itoa64_to_int (buf
[ 9]) << 6;
1585 l
|= itoa64_to_int (buf
[10]) << 12;
1586 l
|= itoa64_to_int (buf
[11]) << 18;
1588 digest
[ 8] = (l
>> 0) & 0xff;
1589 digest
[ 7] = (l
>> 8) & 0xff;
1590 digest
[ 6] = (l
>> 16) & 0xff;
1592 l
= itoa64_to_int (buf
[12]) << 0;
1593 l
|= itoa64_to_int (buf
[13]) << 6;
1594 l
|= itoa64_to_int (buf
[14]) << 12;
1595 l
|= itoa64_to_int (buf
[15]) << 18;
1597 digest
[11] = (l
>> 0) & 0xff;
1598 digest
[10] = (l
>> 8) & 0xff;
1599 digest
[ 9] = (l
>> 16) & 0xff;
1601 l
= itoa64_to_int (buf
[16]) << 0;
1602 l
|= itoa64_to_int (buf
[17]) << 6;
1603 l
|= itoa64_to_int (buf
[18]) << 12;
1604 l
|= itoa64_to_int (buf
[19]) << 18;
1606 digest
[14] = (l
>> 0) & 0xff;
1607 digest
[13] = (l
>> 8) & 0xff;
1608 digest
[12] = (l
>> 16) & 0xff;
1610 l
= itoa64_to_int (buf
[20]) << 0;
1611 l
|= itoa64_to_int (buf
[21]) << 6;
1612 l
|= itoa64_to_int (buf
[22]) << 12;
1613 l
|= itoa64_to_int (buf
[23]) << 18;
1615 digest
[17] = (l
>> 0) & 0xff;
1616 digest
[16] = (l
>> 8) & 0xff;
1617 digest
[15] = (l
>> 16) & 0xff;
1619 l
= itoa64_to_int (buf
[24]) << 0;
1620 l
|= itoa64_to_int (buf
[25]) << 6;
1621 l
|= itoa64_to_int (buf
[26]) << 12;
1622 l
|= itoa64_to_int (buf
[27]) << 18;
1624 digest
[20] = (l
>> 0) & 0xff;
1625 digest
[19] = (l
>> 8) & 0xff;
1626 digest
[18] = (l
>> 16) & 0xff;
1628 l
= itoa64_to_int (buf
[28]) << 0;
1629 l
|= itoa64_to_int (buf
[29]) << 6;
1630 l
|= itoa64_to_int (buf
[30]) << 12;
1631 l
|= itoa64_to_int (buf
[31]) << 18;
1633 digest
[23] = (l
>> 0) & 0xff;
1634 digest
[22] = (l
>> 8) & 0xff;
1635 digest
[21] = (l
>> 16) & 0xff;
1637 l
= itoa64_to_int (buf
[32]) << 0;
1638 l
|= itoa64_to_int (buf
[33]) << 6;
1639 l
|= itoa64_to_int (buf
[34]) << 12;
1640 l
|= itoa64_to_int (buf
[35]) << 18;
1642 digest
[26] = (l
>> 0) & 0xff;
1643 digest
[25] = (l
>> 8) & 0xff;
1644 digest
[24] = (l
>> 16) & 0xff;
1646 l
= itoa64_to_int (buf
[36]) << 0;
1647 l
|= itoa64_to_int (buf
[37]) << 6;
1648 l
|= itoa64_to_int (buf
[38]) << 12;
1649 l
|= itoa64_to_int (buf
[39]) << 18;
1651 digest
[29] = (l
>> 0) & 0xff;
1652 digest
[28] = (l
>> 8) & 0xff;
1653 digest
[27] = (l
>> 16) & 0xff;
1655 l
= itoa64_to_int (buf
[40]) << 0;
1656 l
|= itoa64_to_int (buf
[41]) << 6;
1657 l
|= itoa64_to_int (buf
[42]) << 12;
1658 l
|= itoa64_to_int (buf
[43]) << 18;
1660 digest
[32] = (l
>> 0) & 0xff;
1661 digest
[31] = (l
>> 8) & 0xff;
1662 digest
[30] = (l
>> 16) & 0xff;
1664 l
= itoa64_to_int (buf
[44]) << 0;
1665 l
|= itoa64_to_int (buf
[45]) << 6;
1666 l
|= itoa64_to_int (buf
[46]) << 12;
1667 l
|= itoa64_to_int (buf
[47]) << 18;
1669 digest
[35] = (l
>> 0) & 0xff;
1670 digest
[34] = (l
>> 8) & 0xff;
1671 digest
[33] = (l
>> 16) & 0xff;
1673 l
= itoa64_to_int (buf
[48]) << 0;
1674 l
|= itoa64_to_int (buf
[49]) << 6;
1675 l
|= itoa64_to_int (buf
[50]) << 12;
1676 l
|= itoa64_to_int (buf
[51]) << 18;
1678 digest
[38] = (l
>> 0) & 0xff;
1679 digest
[37] = (l
>> 8) & 0xff;
1680 digest
[36] = (l
>> 16) & 0xff;
1682 l
= itoa64_to_int (buf
[52]) << 0;
1683 l
|= itoa64_to_int (buf
[53]) << 6;
1684 l
|= itoa64_to_int (buf
[54]) << 12;
1685 l
|= itoa64_to_int (buf
[55]) << 18;
1687 digest
[41] = (l
>> 0) & 0xff;
1688 digest
[40] = (l
>> 8) & 0xff;
1689 digest
[39] = (l
>> 16) & 0xff;
1691 l
= itoa64_to_int (buf
[56]) << 0;
1692 l
|= itoa64_to_int (buf
[57]) << 6;
1693 l
|= itoa64_to_int (buf
[58]) << 12;
1694 l
|= itoa64_to_int (buf
[59]) << 18;
1696 digest
[44] = (l
>> 0) & 0xff;
1697 digest
[43] = (l
>> 8) & 0xff;
1698 digest
[42] = (l
>> 16) & 0xff;
1700 l
= itoa64_to_int (buf
[60]) << 0;
1701 l
|= itoa64_to_int (buf
[61]) << 6;
1702 l
|= itoa64_to_int (buf
[62]) << 12;
1703 l
|= itoa64_to_int (buf
[63]) << 18;
1705 digest
[47] = (l
>> 0) & 0xff;
1706 digest
[46] = (l
>> 8) & 0xff;
1707 digest
[45] = (l
>> 16) & 0xff;
1709 l
= itoa64_to_int (buf
[64]) << 0;
1710 l
|= itoa64_to_int (buf
[65]) << 6;
1711 l
|= itoa64_to_int (buf
[66]) << 12;
1712 l
|= itoa64_to_int (buf
[67]) << 18;
1714 digest
[50] = (l
>> 0) & 0xff;
1715 digest
[49] = (l
>> 8) & 0xff;
1716 digest
[48] = (l
>> 16) & 0xff;
1718 l
= itoa64_to_int (buf
[68]) << 0;
1719 l
|= itoa64_to_int (buf
[69]) << 6;
1720 l
|= itoa64_to_int (buf
[70]) << 12;
1721 l
|= itoa64_to_int (buf
[71]) << 18;
1723 digest
[53] = (l
>> 0) & 0xff;
1724 digest
[52] = (l
>> 8) & 0xff;
1725 digest
[51] = (l
>> 16) & 0xff;
1727 l
= itoa64_to_int (buf
[72]) << 0;
1728 l
|= itoa64_to_int (buf
[73]) << 6;
1729 l
|= itoa64_to_int (buf
[74]) << 12;
1730 l
|= itoa64_to_int (buf
[75]) << 18;
1732 digest
[56] = (l
>> 0) & 0xff;
1733 digest
[55] = (l
>> 8) & 0xff;
1734 digest
[54] = (l
>> 16) & 0xff;
1736 l
= itoa64_to_int (buf
[76]) << 0;
1737 l
|= itoa64_to_int (buf
[77]) << 6;
1738 l
|= itoa64_to_int (buf
[78]) << 12;
1739 l
|= itoa64_to_int (buf
[79]) << 18;
1741 digest
[59] = (l
>> 0) & 0xff;
1742 digest
[58] = (l
>> 8) & 0xff;
1743 digest
[57] = (l
>> 16) & 0xff;
1745 l
= itoa64_to_int (buf
[80]) << 0;
1746 l
|= itoa64_to_int (buf
[81]) << 6;
1747 l
|= itoa64_to_int (buf
[82]) << 12;
1748 l
|= itoa64_to_int (buf
[83]) << 18;
1750 digest
[62] = (l
>> 0) & 0xff;
1751 digest
[61] = (l
>> 8) & 0xff;
1752 digest
[60] = (l
>> 16) & 0xff;
1754 l
= itoa64_to_int (buf
[84]) << 0;
1755 l
|= itoa64_to_int (buf
[85]) << 6;
1757 digest
[63] = (l
>> 16) & 0xff;
1760 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1764 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1766 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1767 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1768 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1769 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1771 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1773 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1774 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1775 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1776 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1778 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1780 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1781 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1782 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1783 buf
[11] = int_to_itoa64 (l
& 0x3f);
1785 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1787 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1788 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1789 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1790 buf
[15] = int_to_itoa64 (l
& 0x3f);
1792 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1794 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1795 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1796 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1797 buf
[19] = int_to_itoa64 (l
& 0x3f);
1799 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1801 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1802 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1803 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1804 buf
[23] = int_to_itoa64 (l
& 0x3f);
1806 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1808 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1809 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1810 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1811 buf
[27] = int_to_itoa64 (l
& 0x3f);
1813 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1815 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1816 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1817 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1818 buf
[31] = int_to_itoa64 (l
& 0x3f);
1820 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1822 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1823 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1824 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1825 buf
[35] = int_to_itoa64 (l
& 0x3f);
1827 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1829 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1830 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1831 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1832 buf
[39] = int_to_itoa64 (l
& 0x3f);
1834 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1836 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1837 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1838 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1839 buf
[43] = int_to_itoa64 (l
& 0x3f);
1841 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1843 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1844 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1845 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1846 buf
[47] = int_to_itoa64 (l
& 0x3f);
1848 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1850 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1851 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1852 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1853 buf
[51] = int_to_itoa64 (l
& 0x3f);
1855 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1857 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1858 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1859 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1860 buf
[55] = int_to_itoa64 (l
& 0x3f);
1862 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1864 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1865 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1866 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1867 buf
[59] = int_to_itoa64 (l
& 0x3f);
1869 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1871 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1872 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1873 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1874 buf
[63] = int_to_itoa64 (l
& 0x3f);
1876 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1878 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1879 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1880 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1881 buf
[67] = int_to_itoa64 (l
& 0x3f);
1883 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1885 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1886 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1887 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1888 buf
[71] = int_to_itoa64 (l
& 0x3f);
1890 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1892 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1893 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1894 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1895 buf
[75] = int_to_itoa64 (l
& 0x3f);
1897 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1899 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1900 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1901 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1902 buf
[79] = int_to_itoa64 (l
& 0x3f);
1904 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1906 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1907 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1908 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1909 buf
[83] = int_to_itoa64 (l
& 0x3f);
1911 l
= 0 | 0 | (digest
[63] << 16);
1913 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1914 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1917 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1921 l
= itoa64_to_int (buf
[ 0]) << 0;
1922 l
|= itoa64_to_int (buf
[ 1]) << 6;
1923 l
|= itoa64_to_int (buf
[ 2]) << 12;
1924 l
|= itoa64_to_int (buf
[ 3]) << 18;
1926 digest
[ 0] = (l
>> 16) & 0xff;
1927 digest
[10] = (l
>> 8) & 0xff;
1928 digest
[20] = (l
>> 0) & 0xff;
1930 l
= itoa64_to_int (buf
[ 4]) << 0;
1931 l
|= itoa64_to_int (buf
[ 5]) << 6;
1932 l
|= itoa64_to_int (buf
[ 6]) << 12;
1933 l
|= itoa64_to_int (buf
[ 7]) << 18;
1935 digest
[21] = (l
>> 16) & 0xff;
1936 digest
[ 1] = (l
>> 8) & 0xff;
1937 digest
[11] = (l
>> 0) & 0xff;
1939 l
= itoa64_to_int (buf
[ 8]) << 0;
1940 l
|= itoa64_to_int (buf
[ 9]) << 6;
1941 l
|= itoa64_to_int (buf
[10]) << 12;
1942 l
|= itoa64_to_int (buf
[11]) << 18;
1944 digest
[12] = (l
>> 16) & 0xff;
1945 digest
[22] = (l
>> 8) & 0xff;
1946 digest
[ 2] = (l
>> 0) & 0xff;
1948 l
= itoa64_to_int (buf
[12]) << 0;
1949 l
|= itoa64_to_int (buf
[13]) << 6;
1950 l
|= itoa64_to_int (buf
[14]) << 12;
1951 l
|= itoa64_to_int (buf
[15]) << 18;
1953 digest
[ 3] = (l
>> 16) & 0xff;
1954 digest
[13] = (l
>> 8) & 0xff;
1955 digest
[23] = (l
>> 0) & 0xff;
1957 l
= itoa64_to_int (buf
[16]) << 0;
1958 l
|= itoa64_to_int (buf
[17]) << 6;
1959 l
|= itoa64_to_int (buf
[18]) << 12;
1960 l
|= itoa64_to_int (buf
[19]) << 18;
1962 digest
[24] = (l
>> 16) & 0xff;
1963 digest
[ 4] = (l
>> 8) & 0xff;
1964 digest
[14] = (l
>> 0) & 0xff;
1966 l
= itoa64_to_int (buf
[20]) << 0;
1967 l
|= itoa64_to_int (buf
[21]) << 6;
1968 l
|= itoa64_to_int (buf
[22]) << 12;
1969 l
|= itoa64_to_int (buf
[23]) << 18;
1971 digest
[15] = (l
>> 16) & 0xff;
1972 digest
[25] = (l
>> 8) & 0xff;
1973 digest
[ 5] = (l
>> 0) & 0xff;
1975 l
= itoa64_to_int (buf
[24]) << 0;
1976 l
|= itoa64_to_int (buf
[25]) << 6;
1977 l
|= itoa64_to_int (buf
[26]) << 12;
1978 l
|= itoa64_to_int (buf
[27]) << 18;
1980 digest
[ 6] = (l
>> 16) & 0xff;
1981 digest
[16] = (l
>> 8) & 0xff;
1982 digest
[26] = (l
>> 0) & 0xff;
1984 l
= itoa64_to_int (buf
[28]) << 0;
1985 l
|= itoa64_to_int (buf
[29]) << 6;
1986 l
|= itoa64_to_int (buf
[30]) << 12;
1987 l
|= itoa64_to_int (buf
[31]) << 18;
1989 digest
[27] = (l
>> 16) & 0xff;
1990 digest
[ 7] = (l
>> 8) & 0xff;
1991 digest
[17] = (l
>> 0) & 0xff;
1993 l
= itoa64_to_int (buf
[32]) << 0;
1994 l
|= itoa64_to_int (buf
[33]) << 6;
1995 l
|= itoa64_to_int (buf
[34]) << 12;
1996 l
|= itoa64_to_int (buf
[35]) << 18;
1998 digest
[18] = (l
>> 16) & 0xff;
1999 digest
[28] = (l
>> 8) & 0xff;
2000 digest
[ 8] = (l
>> 0) & 0xff;
2002 l
= itoa64_to_int (buf
[36]) << 0;
2003 l
|= itoa64_to_int (buf
[37]) << 6;
2004 l
|= itoa64_to_int (buf
[38]) << 12;
2005 l
|= itoa64_to_int (buf
[39]) << 18;
2007 digest
[ 9] = (l
>> 16) & 0xff;
2008 digest
[19] = (l
>> 8) & 0xff;
2009 digest
[29] = (l
>> 0) & 0xff;
2011 l
= itoa64_to_int (buf
[40]) << 0;
2012 l
|= itoa64_to_int (buf
[41]) << 6;
2013 l
|= itoa64_to_int (buf
[42]) << 12;
2015 digest
[31] = (l
>> 8) & 0xff;
2016 digest
[30] = (l
>> 0) & 0xff;
2019 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2023 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2025 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2026 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2027 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2028 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2030 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2032 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2033 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2034 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2035 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2037 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2039 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2041 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2042 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2044 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2046 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2048 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2049 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2051 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2053 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2055 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2056 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2058 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2060 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2062 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2063 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2065 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2067 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2069 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2070 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2072 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2074 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2076 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2077 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2079 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2081 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2083 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2084 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2086 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2088 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2090 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2091 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2093 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2095 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2096 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2097 buf
[42] = int_to_itoa64 (l
& 0x3f);
2100 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2104 l
= itoa64_to_int (buf
[ 0]) << 0;
2105 l
|= itoa64_to_int (buf
[ 1]) << 6;
2106 l
|= itoa64_to_int (buf
[ 2]) << 12;
2107 l
|= itoa64_to_int (buf
[ 3]) << 18;
2109 digest
[ 0] = (l
>> 0) & 0xff;
2110 digest
[ 1] = (l
>> 8) & 0xff;
2111 digest
[ 2] = (l
>> 16) & 0xff;
2113 l
= itoa64_to_int (buf
[ 4]) << 0;
2114 l
|= itoa64_to_int (buf
[ 5]) << 6;
2115 l
|= itoa64_to_int (buf
[ 6]) << 12;
2116 l
|= itoa64_to_int (buf
[ 7]) << 18;
2118 digest
[ 3] = (l
>> 0) & 0xff;
2119 digest
[ 4] = (l
>> 8) & 0xff;
2120 digest
[ 5] = (l
>> 16) & 0xff;
2122 l
= itoa64_to_int (buf
[ 8]) << 0;
2123 l
|= itoa64_to_int (buf
[ 9]) << 6;
2124 l
|= itoa64_to_int (buf
[10]) << 12;
2125 l
|= itoa64_to_int (buf
[11]) << 18;
2127 digest
[ 6] = (l
>> 0) & 0xff;
2128 digest
[ 7] = (l
>> 8) & 0xff;
2129 digest
[ 8] = (l
>> 16) & 0xff;
2131 l
= itoa64_to_int (buf
[12]) << 0;
2132 l
|= itoa64_to_int (buf
[13]) << 6;
2133 l
|= itoa64_to_int (buf
[14]) << 12;
2134 l
|= itoa64_to_int (buf
[15]) << 18;
2136 digest
[ 9] = (l
>> 0) & 0xff;
2137 digest
[10] = (l
>> 8) & 0xff;
2138 digest
[11] = (l
>> 16) & 0xff;
2140 l
= itoa64_to_int (buf
[16]) << 0;
2141 l
|= itoa64_to_int (buf
[17]) << 6;
2142 l
|= itoa64_to_int (buf
[18]) << 12;
2143 l
|= itoa64_to_int (buf
[19]) << 18;
2145 digest
[12] = (l
>> 0) & 0xff;
2146 digest
[13] = (l
>> 8) & 0xff;
2147 digest
[14] = (l
>> 16) & 0xff;
2149 l
= itoa64_to_int (buf
[20]) << 0;
2150 l
|= itoa64_to_int (buf
[21]) << 6;
2151 l
|= itoa64_to_int (buf
[22]) << 12;
2152 l
|= itoa64_to_int (buf
[23]) << 18;
2154 digest
[15] = (l
>> 0) & 0xff;
2155 digest
[16] = (l
>> 8) & 0xff;
2156 digest
[17] = (l
>> 16) & 0xff;
2158 l
= itoa64_to_int (buf
[24]) << 0;
2159 l
|= itoa64_to_int (buf
[25]) << 6;
2160 l
|= itoa64_to_int (buf
[26]) << 12;
2161 l
|= itoa64_to_int (buf
[27]) << 18;
2163 digest
[18] = (l
>> 0) & 0xff;
2164 digest
[19] = (l
>> 8) & 0xff;
2165 digest
[20] = (l
>> 16) & 0xff;
2167 l
= itoa64_to_int (buf
[28]) << 0;
2168 l
|= itoa64_to_int (buf
[29]) << 6;
2169 l
|= itoa64_to_int (buf
[30]) << 12;
2170 l
|= itoa64_to_int (buf
[31]) << 18;
2172 digest
[21] = (l
>> 0) & 0xff;
2173 digest
[22] = (l
>> 8) & 0xff;
2174 digest
[23] = (l
>> 16) & 0xff;
2176 l
= itoa64_to_int (buf
[32]) << 0;
2177 l
|= itoa64_to_int (buf
[33]) << 6;
2178 l
|= itoa64_to_int (buf
[34]) << 12;
2179 l
|= itoa64_to_int (buf
[35]) << 18;
2181 digest
[24] = (l
>> 0) & 0xff;
2182 digest
[25] = (l
>> 8) & 0xff;
2183 digest
[26] = (l
>> 16) & 0xff;
2185 l
= itoa64_to_int (buf
[36]) << 0;
2186 l
|= itoa64_to_int (buf
[37]) << 6;
2187 l
|= itoa64_to_int (buf
[38]) << 12;
2188 l
|= itoa64_to_int (buf
[39]) << 18;
2190 digest
[27] = (l
>> 0) & 0xff;
2191 digest
[28] = (l
>> 8) & 0xff;
2192 digest
[29] = (l
>> 16) & 0xff;
2194 l
= itoa64_to_int (buf
[40]) << 0;
2195 l
|= itoa64_to_int (buf
[41]) << 6;
2196 l
|= itoa64_to_int (buf
[42]) << 12;
2197 l
|= itoa64_to_int (buf
[43]) << 18;
2199 digest
[30] = (l
>> 0) & 0xff;
2200 digest
[31] = (l
>> 8) & 0xff;
2201 digest
[32] = (l
>> 16) & 0xff;
2236 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2240 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2242 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2243 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2244 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2245 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2247 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2249 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2250 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2251 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2252 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2254 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2256 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2257 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2258 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2259 buf
[11] = int_to_itoa64 (l
& 0x3f);
2261 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2263 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2264 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2265 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2266 buf
[15] = int_to_itoa64 (l
& 0x3f);
2268 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2270 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2271 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2272 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2273 buf
[19] = int_to_itoa64 (l
& 0x3f);
2275 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2277 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2278 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2279 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2280 buf
[23] = int_to_itoa64 (l
& 0x3f);
2282 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2284 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2285 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2286 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2287 buf
[27] = int_to_itoa64 (l
& 0x3f);
2289 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2291 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2292 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2293 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2294 buf
[31] = int_to_itoa64 (l
& 0x3f);
2296 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2298 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2299 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2300 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2301 buf
[35] = int_to_itoa64 (l
& 0x3f);
2303 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2305 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2306 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2307 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2308 buf
[39] = int_to_itoa64 (l
& 0x3f);
2310 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2312 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2313 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2314 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2315 //buf[43] = int_to_itoa64 (l & 0x3f);
2323 static struct termio savemodes
;
2324 static int havemodes
= 0;
2328 struct termio modmodes
;
2330 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2334 modmodes
= savemodes
;
2335 modmodes
.c_lflag
&= ~ICANON
;
2336 modmodes
.c_cc
[VMIN
] = 1;
2337 modmodes
.c_cc
[VTIME
] = 0;
2339 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2348 FD_SET (fileno (stdin
), &rfds
);
2355 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2357 if (retval
== 0) return 0;
2358 if (retval
== -1) return -1;
2365 if (!havemodes
) return 0;
2367 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2372 static struct termios savemodes
;
2373 static int havemodes
= 0;
2377 struct termios modmodes
;
2379 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2383 modmodes
= savemodes
;
2384 modmodes
.c_lflag
&= ~ICANON
;
2385 modmodes
.c_cc
[VMIN
] = 1;
2386 modmodes
.c_cc
[VTIME
] = 0;
2388 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2397 FD_SET (fileno (stdin
), &rfds
);
2404 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2406 if (retval
== 0) return 0;
2407 if (retval
== -1) return -1;
2414 if (!havemodes
) return 0;
2416 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2421 static DWORD saveMode
= 0;
2425 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2427 GetConsoleMode (stdinHandle
, &saveMode
);
2428 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2435 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2437 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2439 if (rc
== WAIT_TIMEOUT
) return 0;
2440 if (rc
== WAIT_ABANDONED
) return -1;
2441 if (rc
== WAIT_FAILED
) return -1;
2443 // The whole ReadConsoleInput () part is a workaround.
2444 // For some unknown reason, maybe a mingw bug, a random signal
2445 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2446 // Then it wants to read with getche () a keyboard input
2447 // which has never been made.
2449 INPUT_RECORD buf
[100];
2453 memset (buf
, 0, sizeof (buf
));
2455 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2457 FlushConsoleInputBuffer (stdinHandle
);
2459 for (uint i
= 0; i
< num
; i
++)
2461 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2463 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2465 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2467 return KeyEvent
.uChar
.AsciiChar
;
2475 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2477 SetConsoleMode (stdinHandle
, saveMode
);
2487 #define MSG_ENOMEM "Insufficient memory available"
2489 void *mycalloc (size_t nmemb
, size_t size
)
2491 void *p
= calloc (nmemb
, size
);
2495 log_error ("ERROR: %s", MSG_ENOMEM
);
2503 void *mymalloc (size_t size
)
2505 void *p
= malloc (size
);
2509 log_error ("ERROR: %s", MSG_ENOMEM
);
2514 memset (p
, 0, size
);
2519 void myfree (void *ptr
)
2521 if (ptr
== NULL
) return;
2526 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2528 void *p
= realloc (ptr
, oldsz
+ add
);
2532 log_error ("ERROR: %s", MSG_ENOMEM
);
2537 memset ((char *) p
+ oldsz
, 0, add
);
2542 char *mystrdup (const char *s
)
2544 const size_t len
= strlen (s
);
2546 char *b
= (char *) mymalloc (len
+ 1);
2553 FILE *logfile_open (char *logfile
)
2555 FILE *fp
= fopen (logfile
, "ab");
2565 void logfile_close (FILE *fp
)
2567 if (fp
== stdout
) return;
2572 void logfile_append (const char *fmt
, ...)
2574 if (data
.logfile_disable
== 1) return;
2576 FILE *fp
= logfile_open (data
.logfile
);
2582 vfprintf (fp
, fmt
, ap
);
2593 int logfile_generate_id ()
2595 const int n
= rand ();
2604 char *logfile_generate_topid ()
2606 const int id
= logfile_generate_id ();
2608 char *topid
= (char *) mymalloc (1 + 16 + 1);
2610 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2615 char *logfile_generate_subid ()
2617 const int id
= logfile_generate_id ();
2619 char *subid
= (char *) mymalloc (1 + 16 + 1);
2621 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2631 void lock_file (FILE *fp
)
2635 memset (&lock
, 0, sizeof (struct flock
));
2637 lock
.l_type
= F_WRLCK
;
2638 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2642 log_error ("ERROR: failed acquiring write lock: %s", strerror (errno
));
2649 void unlock_file (FILE *fp
)
2653 memset (&lock
, 0, sizeof (struct flock
));
2655 lock
.l_type
= F_UNLCK
;
2656 fcntl(fileno(fp
), F_SETLK
, &lock
);
2663 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2665 FlushFileBuffers (h
);
2675 int get_adapters_num_adl (void *adl
, int *iNumberAdapters
)
2677 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2679 if (iNumberAdapters
== 0)
2681 log_info ("WARN: No ADL adapters found.");
2690 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2692 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2693 ADLODParameters lpOdParameters;
2695 lpOdParameters.iSize = sizeof (ADLODParameters);
2696 size_t plevels_size = 0;
2698 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2700 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2701 __func__, iAdapterIndex,
2702 lpOdParameters.iNumberOfPerformanceLevels,
2703 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2704 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2706 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2708 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2710 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2712 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2714 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2715 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2716 __func__, iAdapterIndex, j,
2717 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2719 myfree (lpOdPerformanceLevels);
2725 LPAdapterInfo
hm_get_adapter_info_adl (void *adl
, int iNumberAdapters
)
2727 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2729 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2731 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2733 return lpAdapterInfo
;
2736 int hm_get_adapter_index_nvapi (HM_ADAPTER_NVAPI nvapiGPUHandle
[DEVICES_MAX
])
2740 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nvapi
, nvapiGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2744 log_info ("WARN: No NvAPI adapters found");
2752 int hm_get_adapter_index_nvml (HM_ADAPTER_NVML nvmlGPUHandle
[DEVICES_MAX
])
2756 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2758 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nvml
, 1, i
, &nvmlGPUHandle
[i
]) != NVML_SUCCESS
) break;
2760 // can be used to determine if the device by index matches the cuda device by index
2761 // char name[100]; memset (name, 0, sizeof (name));
2762 // hm_NVML_nvmlDeviceGetName (data.hm_nvml, nvGPUHandle[i], name, sizeof (name) - 1);
2769 log_info ("WARN: No NVML adapters found");
2779 // does not help at all, since ADL does not assign different bus id, device id when we have multi GPU setups
2782 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2786 for (uint i = 0; i < num_adl_adapters; i++)
2788 int opencl_bus_num = hm_device[i].busid;
2789 int opencl_dev_num = hm_device[i].devid;
2791 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2799 if (idx >= DEVICES_MAX) return -1;
2804 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2806 for (uint i = 0; i < opencl_num_devices; i++)
2808 cl_device_topology_amd device_topology;
2810 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2812 hm_device[i].busid = device_topology.pcie.bus;
2813 hm_device[i].devid = device_topology.pcie.device;
2818 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2820 // basically bubble sort
2822 for (int i
= 0; i
< num_adl_adapters
; i
++)
2824 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2826 // get info of adapter [x]
2828 u32 adapter_index_x
= valid_adl_device_list
[j
];
2829 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2831 u32 bus_num_x
= info_x
.iBusNumber
;
2832 u32 dev_num_x
= info_x
.iDeviceNumber
;
2834 // get info of adapter [y]
2836 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2837 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2839 u32 bus_num_y
= info_y
.iBusNumber
;
2840 u32 dev_num_y
= info_y
.iDeviceNumber
;
2844 if (bus_num_y
< bus_num_x
)
2848 else if (bus_num_y
== bus_num_x
)
2850 if (dev_num_y
< dev_num_x
)
2858 u32 temp
= valid_adl_device_list
[j
+ 1];
2860 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2861 valid_adl_device_list
[j
+ 0] = temp
;
2867 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2869 *num_adl_adapters
= 0;
2871 u32
*adl_adapters
= NULL
;
2873 int *bus_numbers
= NULL
;
2874 int *device_numbers
= NULL
;
2876 for (int i
= 0; i
< iNumberAdapters
; i
++)
2878 AdapterInfo info
= lpAdapterInfo
[i
];
2880 if (strlen (info
.strUDID
) < 1) continue;
2883 if (info
.iVendorID
!= 1002) continue;
2885 if (info
.iVendorID
!= 0x1002) continue;
2888 if (info
.iBusNumber
< 0) continue;
2889 if (info
.iDeviceNumber
< 0) continue;
2893 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2895 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2902 if (found
) continue;
2904 // add it to the list
2906 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2908 adl_adapters
[*num_adl_adapters
] = i
;
2910 // rest is just bookkeeping
2912 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2913 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2915 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2916 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2918 (*num_adl_adapters
)++;
2921 myfree (bus_numbers
);
2922 myfree (device_numbers
);
2924 // sort the list by increasing bus id, device id number
2926 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2928 return adl_adapters
;
2931 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2933 // loop through all valid devices
2935 for (int i
= 0; i
< num_adl_adapters
; i
++)
2937 u32 adapter_index
= valid_adl_device_list
[i
];
2941 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2943 // unfortunately this doesn't work since bus id and dev id are not unique
2944 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2945 // if (opencl_device_index == -1) continue;
2947 int opencl_device_index
= i
;
2949 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2951 // get fanspeed info
2953 if (hm_device
[opencl_device_index
].od_version
== 5)
2955 ADLFanSpeedInfo FanSpeedInfo
;
2957 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2959 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2961 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2963 // check read and write capability in fanspeedinfo
2965 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2966 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2968 hm_device
[opencl_device_index
].fan_get_supported
= 1;
2972 hm_device
[opencl_device_index
].fan_get_supported
= 0;
2975 else // od_version == 6
2977 ADLOD6FanSpeedInfo faninfo
;
2979 memset (&faninfo
, 0, sizeof (faninfo
));
2981 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2983 // check read capability in fanspeedinfo
2985 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2987 hm_device
[opencl_device_index
].fan_get_supported
= 1;
2991 hm_device
[opencl_device_index
].fan_get_supported
= 0;
2999 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3001 for (int i
= 0; i
< num_adl_adapters
; i
++)
3003 u32 adapter_index
= valid_adl_device_list
[i
];
3007 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3009 // get overdrive version
3011 int od_supported
= 0;
3015 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3017 // store the overdrive version in hm_device
3019 // unfortunately this doesn't work since bus id and dev id are not unique
3020 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3021 // if (opencl_device_index == -1) continue;
3023 int opencl_device_index
= i
;
3025 hm_device
[opencl_device_index
].od_version
= od_version
;
3031 int hm_get_adapter_index_adl (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3033 for (int i
= 0; i
< num_adl_adapters
; i
++)
3035 u32 adapter_index
= valid_adl_device_list
[i
];
3039 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3041 // store the iAdapterIndex in hm_device
3043 // unfortunately this doesn't work since bus id and dev id are not unique
3044 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3045 // if (opencl_device_index == -1) continue;
3047 int opencl_device_index
= i
;
3049 hm_device
[opencl_device_index
].adl
= info
.iAdapterIndex
;
3052 return num_adl_adapters
;
3055 int hm_get_threshold_slowdown_with_device_id (const uint device_id
)
3057 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3059 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3063 if (data
.hm_device
[device_id
].od_version
== 5)
3067 else if (data
.hm_device
[device_id
].od_version
== 6)
3069 int CurrentValue
= 0;
3070 int DefaultValue
= 0;
3072 if (hm_ADL_Overdrive6_TargetTemperatureData_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &CurrentValue
, &DefaultValue
) != ADL_OK
) return -1;
3074 // the return value has never been tested since hm_ADL_Overdrive6_TargetTemperatureData_Get() never worked on any system. expect problems.
3076 return DefaultValue
;
3081 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3085 if (hm_NVML_nvmlDeviceGetTemperatureThreshold (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_THRESHOLD_SLOWDOWN
, (unsigned int *) &target
) != NVML_SUCCESS
) return -1;
3093 int hm_get_threshold_shutdown_with_device_id (const uint device_id
)
3095 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3097 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3101 if (data
.hm_device
[device_id
].od_version
== 5)
3105 else if (data
.hm_device
[device_id
].od_version
== 6)
3112 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3116 if (hm_NVML_nvmlDeviceGetTemperatureThreshold (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_THRESHOLD_SHUTDOWN
, (unsigned int *) &target
) != NVML_SUCCESS
) return -1;
3124 int hm_get_temperature_with_device_id (const uint device_id
)
3126 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3128 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3132 if (data
.hm_device
[device_id
].od_version
== 5)
3134 ADLTemperature Temperature
;
3136 Temperature
.iSize
= sizeof (ADLTemperature
);
3138 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &Temperature
) != ADL_OK
) return -1;
3140 return Temperature
.iTemperature
/ 1000;
3142 else if (data
.hm_device
[device_id
].od_version
== 6)
3144 int Temperature
= 0;
3146 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &Temperature
) != ADL_OK
) return -1;
3148 return Temperature
/ 1000;
3153 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3155 int temperature
= 0;
3157 if (hm_NVML_nvmlDeviceGetTemperature (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
) != NVML_SUCCESS
) return -1;
3165 int hm_get_fanpolicy_with_device_id (const uint device_id
)
3167 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3169 if (data
.hm_device
[device_id
].fan_get_supported
== 1)
3171 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3175 if (data
.hm_device
[device_id
].od_version
== 5)
3177 ADLFanSpeedValue lpFanSpeedValue
;
3179 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3181 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3182 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3184 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3186 return (lpFanSpeedValue
.iFanSpeed
& ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
) ? 0 : 1;
3188 else // od_version == 6
3195 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3204 int hm_get_fanspeed_with_device_id (const uint device_id
)
3206 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3208 if (data
.hm_device
[device_id
].fan_get_supported
== 1)
3210 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3214 if (data
.hm_device
[device_id
].od_version
== 5)
3216 ADLFanSpeedValue lpFanSpeedValue
;
3218 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3220 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3221 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3222 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3224 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3226 return lpFanSpeedValue
.iFanSpeed
;
3228 else // od_version == 6
3230 ADLOD6FanSpeedInfo faninfo
;
3232 memset (&faninfo
, 0, sizeof (faninfo
));
3234 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &faninfo
) != ADL_OK
) return -1;
3236 return faninfo
.iFanSpeedPercent
;
3241 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3245 if (hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nvml
, 0, data
.hm_device
[device_id
].nvml
, (uint
*) &speed
) != NVML_SUCCESS
) return -1;
3254 int hm_get_buslanes_with_device_id (const uint device_id
)
3256 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3258 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3262 ADLPMActivity PMActivity
;
3264 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3266 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3268 return PMActivity
.iCurrentBusLanes
;
3272 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3274 unsigned int currLinkWidth
;
3276 if (hm_NVML_nvmlDeviceGetCurrPcieLinkWidth (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &currLinkWidth
) != NVML_SUCCESS
) return -1;
3278 return currLinkWidth
;
3284 int hm_get_utilization_with_device_id (const uint device_id
)
3286 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3288 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3292 ADLPMActivity PMActivity
;
3294 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3296 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3298 return PMActivity
.iActivityPercent
;
3302 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3304 nvmlUtilization_t utilization
;
3306 if (hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &utilization
) != NVML_SUCCESS
) return -1;
3308 return utilization
.gpu
;
3314 int hm_get_memoryspeed_with_device_id (const uint device_id
)
3316 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3318 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3322 ADLPMActivity PMActivity
;
3324 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3326 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3328 return PMActivity
.iMemoryClock
/ 100;
3332 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3336 if (hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_CLOCK_MEM
, &clock
) != NVML_SUCCESS
) return -1;
3344 int hm_get_corespeed_with_device_id (const uint device_id
)
3346 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3348 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3352 ADLPMActivity PMActivity
;
3354 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3356 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3358 return PMActivity
.iEngineClock
/ 100;
3362 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3366 if (hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_CLOCK_SM
, &clock
) != NVML_SUCCESS
) return -1;
3374 int hm_get_throttle_with_device_id (const uint device_id
)
3376 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3378 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3383 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3385 unsigned long long clocksThrottleReasons
= 0;
3386 unsigned long long supportedThrottleReasons
= 0;
3388 if (hm_NVML_nvmlDeviceGetCurrentClocksThrottleReasons (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &clocksThrottleReasons
) != NVML_SUCCESS
) return -1;
3389 if (hm_NVML_nvmlDeviceGetSupportedClocksThrottleReasons (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &supportedThrottleReasons
) != NVML_SUCCESS
) return -1;
3391 clocksThrottleReasons
&= supportedThrottleReasons
;
3393 clocksThrottleReasons
&= ~nvmlClocksThrottleReasonUnknown
;
3395 return (clocksThrottleReasons
> 0);
3401 int hm_set_fanspeed_with_device_id_xnvctrl (const uint device_id
, const int fanspeed
)
3403 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3405 if (data
.hm_xnvctrl
)
3407 if (set_fan_speed_target (data
.hm_xnvctrl
, data
.hm_device
[device_id
].xnvctrl
, fanspeed
) != 0) return -1;
3416 int hm_set_fanspeed_with_device_id_adl (const uint device_id
, const int fanspeed
, const int fanpolicy
)
3418 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3422 if (data
.hm_device
[device_id
].od_version
== 5)
3424 ADLFanSpeedValue lpFanSpeedValue
;
3426 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3428 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3429 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3430 lpFanSpeedValue
.iFlags
= (fanpolicy
== 1) ? ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
: 0;
3431 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3433 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3437 else // od_version == 6
3439 ADLOD6FanSpeedValue fan_speed_value
;
3441 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3443 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3444 fan_speed_value
.iFanSpeed
= fanspeed
;
3446 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &fan_speed_value
) != ADL_OK
) return -1;
3456 #endif // HAVE_HWMON
3462 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3464 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3466 if (css_cnt
> SP_PW_MAX
)
3468 log_error ("ERROR: mask length is too long");
3473 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3475 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3477 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3478 uint cs_len
= css
[css_pos
].cs_len
;
3480 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3482 uint c
= cs_buf
[cs_pos
] & 0xff;
3489 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3491 cs_t
*cs
= &css
[css_cnt
];
3493 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3495 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3499 for (i
= 0; i
< cs
->cs_len
; i
++)
3501 const uint u
= cs
->cs_buf
[i
];
3506 for (i
= 0; i
< in_len
; i
++)
3508 uint u
= in_buf
[i
] & 0xff;
3510 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3512 if (css_uniq
[u
] == 1) continue;
3516 cs
->cs_buf
[cs
->cs_len
] = u
;
3524 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3528 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3530 uint p0
= in_buf
[in_pos
] & 0xff;
3532 if (interpret
== 1 && p0
== '?')
3536 if (in_pos
== in_len
) break;
3538 uint p1
= in_buf
[in_pos
] & 0xff;
3542 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3544 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3546 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3548 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3550 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3552 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3554 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3555 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3557 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3558 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3560 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3561 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3563 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3564 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3566 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3568 default: log_error ("Syntax error: %s", in_buf
);
3574 if (data
.hex_charset
)
3578 if (in_pos
== in_len
)
3580 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3585 uint p1
= in_buf
[in_pos
] & 0xff;
3587 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3589 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3596 chr
= hex_convert (p1
) << 0;
3597 chr
|= hex_convert (p0
) << 4;
3599 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3605 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3611 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3615 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3617 sum
*= css
[css_pos
].cs_len
;
3623 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3625 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3630 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3632 char p0
= mask_buf
[mask_pos
];
3638 if (mask_pos
== mask_len
) break;
3640 char p1
= mask_buf
[mask_pos
];
3646 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3648 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3650 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3652 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3654 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3656 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3658 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3659 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3661 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3662 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3664 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3665 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3667 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3668 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3670 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3672 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3678 if (data
.hex_charset
)
3682 // if there is no 2nd hex character, show an error:
3684 if (mask_pos
== mask_len
)
3686 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3691 char p1
= mask_buf
[mask_pos
];
3693 // if they are not valid hex character, show an error:
3695 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3697 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3704 chr
|= hex_convert (p1
) << 0;
3705 chr
|= hex_convert (p0
) << 4;
3707 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3713 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3720 log_error ("ERROR: invalid mask length (0)");
3730 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3732 for (int i
= 0; i
< css_cnt
; i
++)
3734 uint len
= css
[i
].cs_len
;
3735 u64 next
= val
/ len
;
3736 uint pos
= val
% len
;
3737 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3742 void mp_cut_at (char *mask
, uint max
)
3746 uint mask_len
= strlen (mask
);
3748 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3750 if (mask
[i
] == '?') i
++;
3756 void mp_setup_sys (cs_t
*mp_sys
)
3760 uint donec
[CHARSIZ
] = { 0 };
3762 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3763 mp_sys
[0].cs_buf
[pos
++] = chr
;
3764 mp_sys
[0].cs_len
= pos
; }
3766 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3767 mp_sys
[1].cs_buf
[pos
++] = chr
;
3768 mp_sys
[1].cs_len
= pos
; }
3770 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3771 mp_sys
[2].cs_buf
[pos
++] = chr
;
3772 mp_sys
[2].cs_len
= pos
; }
3774 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3775 mp_sys
[3].cs_buf
[pos
++] = chr
;
3776 mp_sys
[3].cs_len
= pos
; }
3778 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3779 mp_sys
[4].cs_len
= pos
; }
3781 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3782 mp_sys
[5].cs_len
= pos
; }
3785 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3787 FILE *fp
= fopen (buf
, "rb");
3789 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3791 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3795 char mp_file
[1024] = { 0 };
3797 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3801 len
= in_superchop (mp_file
);
3805 log_info ("WARNING: charset file corrupted");
3807 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3811 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3816 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3818 mp_usr
[index
].cs_len
= 0;
3820 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3823 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3825 char *new_mask_buf
= (char *) mymalloc (256);
3831 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3833 if (css_pos
== len
) break;
3835 char p0
= mask_buf
[mask_pos
];
3837 new_mask_buf
[mask_pos
] = p0
;
3843 if (mask_pos
== mask_len
) break;
3845 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3849 if (data
.hex_charset
)
3853 if (mask_pos
== mask_len
)
3855 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3860 char p1
= mask_buf
[mask_pos
];
3862 // if they are not valid hex character, show an error:
3864 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3866 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3871 new_mask_buf
[mask_pos
] = p1
;
3876 if (css_pos
== len
) return (new_mask_buf
);
3878 myfree (new_mask_buf
);
3887 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3893 for (i
= start
; i
< stop
; i
++)
3895 sum
*= root_css_buf
[i
].cs_len
;
3901 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3905 cs_t
*cs
= &root_css_buf
[start
];
3909 for (i
= start
; i
< stop
; i
++)
3911 const u64 m
= v
% cs
->cs_len
;
3912 const u64 d
= v
/ cs
->cs_len
;
3916 const uint k
= cs
->cs_buf
[m
];
3918 pw_buf
[i
- start
] = (char) k
;
3920 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3924 int sp_comp_val (const void *p1
, const void *p2
)
3926 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3927 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3929 return b2
->val
- b1
->val
;
3932 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
)
3939 * Initialize hcstats
3942 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3944 u64
*root_stats_ptr
= root_stats_buf
;
3946 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3948 for (i
= 0; i
< SP_PW_MAX
; i
++)
3950 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3952 root_stats_ptr
+= CHARSIZ
;
3955 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3957 u64
*markov_stats_ptr
= markov_stats_buf
;
3959 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3961 for (i
= 0; i
< SP_PW_MAX
; i
++)
3963 for (j
= 0; j
< CHARSIZ
; j
++)
3965 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3967 markov_stats_ptr
+= CHARSIZ
;
3977 char hcstat_tmp
[256] = { 0 };
3979 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3981 hcstat
= hcstat_tmp
;
3984 FILE *fd
= fopen (hcstat
, "rb");
3988 log_error ("%s: %s", hcstat
, strerror (errno
));
3993 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3995 log_error ("%s: Could not load data", hcstat
);
4002 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
4004 log_error ("%s: Could not load data", hcstat
);
4014 * Markov modifier of hcstat_table on user request
4019 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
4020 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
4025 /* Add all stats to first position */
4027 for (i
= 1; i
< SP_PW_MAX
; i
++)
4029 u64
*out
= root_stats_buf_by_pos
[0];
4030 u64
*in
= root_stats_buf_by_pos
[i
];
4032 for (j
= 0; j
< CHARSIZ
; j
++)
4038 for (i
= 1; i
< SP_PW_MAX
; i
++)
4040 u64
*out
= markov_stats_buf_by_key
[0][0];
4041 u64
*in
= markov_stats_buf_by_key
[i
][0];
4043 for (j
= 0; j
< CHARSIZ
; j
++)
4045 for (k
= 0; k
< CHARSIZ
; k
++)
4052 /* copy them to all pw_positions */
4054 for (i
= 1; i
< SP_PW_MAX
; i
++)
4056 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
4059 for (i
= 1; i
< SP_PW_MAX
; i
++)
4061 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
4069 hcstat_table_t
*root_table_ptr
= root_table_buf
;
4071 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
4073 for (i
= 0; i
< SP_PW_MAX
; i
++)
4075 root_table_buf_by_pos
[i
] = root_table_ptr
;
4077 root_table_ptr
+= CHARSIZ
;
4080 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
4082 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4084 for (i
= 0; i
< SP_PW_MAX
; i
++)
4086 for (j
= 0; j
< CHARSIZ
; j
++)
4088 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
4090 markov_table_ptr
+= CHARSIZ
;
4095 * Convert hcstat to tables
4098 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
4100 uint key
= i
% CHARSIZ
;
4102 root_table_buf
[i
].key
= key
;
4103 root_table_buf
[i
].val
= root_stats_buf
[i
];
4106 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
4108 uint key
= i
% CHARSIZ
;
4110 markov_table_buf
[i
].key
= key
;
4111 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
4114 myfree (root_stats_buf
);
4115 myfree (markov_stats_buf
);
4121 for (i
= 0; i
< SP_PW_MAX
; i
++)
4123 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4126 for (i
= 0; i
< SP_PW_MAX
; i
++)
4128 for (j
= 0; j
< CHARSIZ
; j
++)
4130 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4135 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
])
4138 * Convert tables to css
4141 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
4143 uint pw_pos
= i
/ CHARSIZ
;
4145 cs_t
*cs
= &root_css_buf
[pw_pos
];
4147 if (cs
->cs_len
== threshold
) continue;
4149 uint key
= root_table_buf
[i
].key
;
4151 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
4153 cs
->cs_buf
[cs
->cs_len
] = key
;
4159 * Convert table to css
4162 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4164 uint c
= i
/ CHARSIZ
;
4166 cs_t
*cs
= &markov_css_buf
[c
];
4168 if (cs
->cs_len
== threshold
) continue;
4170 uint pw_pos
= c
/ CHARSIZ
;
4172 uint key
= markov_table_buf
[i
].key
;
4174 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4176 cs
->cs_buf
[cs
->cs_len
] = key
;
4182 for (uint i = 0; i < 8; i++)
4184 for (uint j = 0x20; j < 0x80; j++)
4186 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4188 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4190 for (uint k = 0; k < 10; k++)
4192 printf (" %u\n", ptr->cs_buf[k]);
4199 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4201 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4203 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4213 for (uint j
= 1; j
< CHARSIZ
; j
++)
4223 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4225 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4227 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4229 out
+= CHARSIZ
* CHARSIZ
;
4230 in
+= CHARSIZ
* CHARSIZ
;
4232 for (uint j
= 0; j
< CHARSIZ
; j
++)
4239 for (uint k
= 1; k
< CHARSIZ
; k
++)
4251 * mixed shared functions
4254 void dump_hex (const u8
*s
, const int sz
)
4256 for (int i
= 0; i
< sz
; i
++)
4258 log_info_nn ("%02x ", s
[i
]);
4264 void usage_mini_print (const char *progname
)
4266 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4269 void usage_big_print (const char *progname
)
4271 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4274 char *get_exec_path ()
4276 int exec_path_len
= 1024;
4278 char *exec_path
= (char *) mymalloc (exec_path_len
);
4282 char tmp
[32] = { 0 };
4284 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4286 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4290 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4294 uint size
= exec_path_len
;
4296 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4298 log_error("! executable path buffer too small\n");
4303 const int len
= strlen (exec_path
);
4306 #error Your Operating System is not supported or detected
4314 char *get_install_dir (const char *progname
)
4316 char *install_dir
= mystrdup (progname
);
4317 char *last_slash
= NULL
;
4319 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4323 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4329 install_dir
[0] = '.';
4333 return (install_dir
);
4336 char *get_profile_dir (const char *homedir
)
4338 #define DOT_HASHCAT ".hashcat"
4340 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4342 char *profile_dir
= (char *) mymalloc (len
+ 1);
4344 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4349 char *get_session_dir (const char *profile_dir
)
4351 #define SESSIONS_FOLDER "sessions"
4353 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4355 char *session_dir
= (char *) mymalloc (len
+ 1);
4357 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4362 uint
count_lines (FILE *fd
)
4366 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4372 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4374 if (nread
< 1) continue;
4378 for (i
= 0; i
< nread
; i
++)
4380 if (prev
== '\n') cnt
++;
4391 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4395 FILE *fd
= fopen (filename
, "rb");
4399 log_error ("%s: %s", filename
, strerror (errno
));
4404 #define MAX_KEY_SIZE (1024 * 1024)
4406 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4408 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4414 for (int fpos
= 0; fpos
< nread
; fpos
++)
4416 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4418 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4419 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4420 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4421 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4423 if (kpos
>= 64) kpos
= 0;
4430 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4434 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4435 if (CPU_ISSET(core
, cpu_set
)) break;
4437 thread_affinity_policy_data_t policy
= { core
};
4439 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4441 if (data
.quiet
== 0)
4443 if (rc
!= KERN_SUCCESS
)
4445 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4453 void set_cpu_affinity (char *cpu_affinity
)
4456 DWORD_PTR aff_mask
= 0;
4464 char *devices
= strdup (cpu_affinity
);
4466 char *next
= strtok (devices
, ",");
4470 uint cpu_id
= atoi (next
);
4485 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4491 aff_mask
|= 1 << (cpu_id
- 1);
4493 CPU_SET ((cpu_id
- 1), &cpuset
);
4496 } while ((next
= strtok (NULL
, ",")) != NULL
);
4502 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4503 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4505 pthread_t thread
= pthread_self ();
4506 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4510 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4512 char *element
, *end
;
4514 end
= (char *) base
+ nmemb
* size
;
4516 for (element
= (char *) base
; element
< end
; element
+= size
)
4517 if (!compar (element
, key
))
4523 int sort_by_u32 (const void *v1
, const void *v2
)
4525 const u32
*s1
= (const u32
*) v1
;
4526 const u32
*s2
= (const u32
*) v2
;
4531 int sort_by_salt (const void *v1
, const void *v2
)
4533 const salt_t
*s1
= (const salt_t
*) v1
;
4534 const salt_t
*s2
= (const salt_t
*) v2
;
4536 const int res1
= s1
->salt_len
- s2
->salt_len
;
4538 if (res1
!= 0) return (res1
);
4540 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4542 if (res2
!= 0) return (res2
);
4550 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4551 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4558 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4559 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4565 int sort_by_salt_buf (const void *v1
, const void *v2
)
4567 const pot_t
*p1
= (const pot_t
*) v1
;
4568 const pot_t
*p2
= (const pot_t
*) v2
;
4570 const hash_t
*h1
= &p1
->hash
;
4571 const hash_t
*h2
= &p2
->hash
;
4573 const salt_t
*s1
= h1
->salt
;
4574 const salt_t
*s2
= h2
->salt
;
4580 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4581 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4587 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4589 const hash_t
*h1
= (const hash_t
*) v1
;
4590 const hash_t
*h2
= (const hash_t
*) v2
;
4592 const salt_t
*s1
= h1
->salt
;
4593 const salt_t
*s2
= h2
->salt
;
4595 // testphase: this should work
4600 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4601 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4604 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4605 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4606 if (s1->salt_len > s2->salt_len) return ( 1);
4607 if (s1->salt_len < s2->salt_len) return (-1);
4609 uint n = s1->salt_len;
4613 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4614 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4621 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4623 const hash_t
*h1
= (const hash_t
*) v1
;
4624 const hash_t
*h2
= (const hash_t
*) v2
;
4626 const salt_t
*s1
= h1
->salt
;
4627 const salt_t
*s2
= h2
->salt
;
4629 // 16 - 2 (since last 2 uints contain the digest)
4634 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4635 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4641 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4643 const hash_t
*h1
= (const hash_t
*) v1
;
4644 const hash_t
*h2
= (const hash_t
*) v2
;
4646 const void *d1
= h1
->digest
;
4647 const void *d2
= h2
->digest
;
4649 return data
.sort_by_digest (d1
, d2
);
4652 int sort_by_hash (const void *v1
, const void *v2
)
4654 const hash_t
*h1
= (const hash_t
*) v1
;
4655 const hash_t
*h2
= (const hash_t
*) v2
;
4659 const salt_t
*s1
= h1
->salt
;
4660 const salt_t
*s2
= h2
->salt
;
4662 int res
= sort_by_salt (s1
, s2
);
4664 if (res
!= 0) return (res
);
4667 const void *d1
= h1
->digest
;
4668 const void *d2
= h2
->digest
;
4670 return data
.sort_by_digest (d1
, d2
);
4673 int sort_by_pot (const void *v1
, const void *v2
)
4675 const pot_t
*p1
= (const pot_t
*) v1
;
4676 const pot_t
*p2
= (const pot_t
*) v2
;
4678 const hash_t
*h1
= &p1
->hash
;
4679 const hash_t
*h2
= &p2
->hash
;
4681 return sort_by_hash (h1
, h2
);
4684 int sort_by_mtime (const void *p1
, const void *p2
)
4686 const char **f1
= (const char **) p1
;
4687 const char **f2
= (const char **) p2
;
4689 struct stat s1
; stat (*f1
, &s1
);
4690 struct stat s2
; stat (*f2
, &s2
);
4692 return s2
.st_mtime
- s1
.st_mtime
;
4695 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4697 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4698 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4700 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4703 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4705 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4706 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4708 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4711 int sort_by_stringptr (const void *p1
, const void *p2
)
4713 const char **s1
= (const char **) p1
;
4714 const char **s2
= (const char **) p2
;
4716 return strcmp (*s1
, *s2
);
4719 int sort_by_dictstat (const void *s1
, const void *s2
)
4721 dictstat_t
*d1
= (dictstat_t
*) s1
;
4722 dictstat_t
*d2
= (dictstat_t
*) s2
;
4725 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4727 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4730 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4733 int sort_by_bitmap (const void *p1
, const void *p2
)
4735 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4736 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4738 return b1
->collisions
- b2
->collisions
;
4741 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4743 const u32
*d1
= (const u32
*) v1
;
4744 const u32
*d2
= (const u32
*) v2
;
4750 if (d1
[n
] > d2
[n
]) return ( 1);
4751 if (d1
[n
] < d2
[n
]) return (-1);
4757 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4759 const u32
*d1
= (const u32
*) v1
;
4760 const u32
*d2
= (const u32
*) v2
;
4766 if (d1
[n
] > d2
[n
]) return ( 1);
4767 if (d1
[n
] < d2
[n
]) return (-1);
4773 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4775 const u32
*d1
= (const u32
*) v1
;
4776 const u32
*d2
= (const u32
*) v2
;
4782 if (d1
[n
] > d2
[n
]) return ( 1);
4783 if (d1
[n
] < d2
[n
]) return (-1);
4789 int sort_by_digest_4_6 (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_8 (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_16 (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_32 (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_64 (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_8_8 (const void *v1
, const void *v2
)
4871 const u64
*d1
= (const u64
*) v1
;
4872 const u64
*d2
= (const u64
*) v2
;
4878 if (d1
[n
] > d2
[n
]) return ( 1);
4879 if (d1
[n
] < d2
[n
]) return (-1);
4885 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4887 const u64
*d1
= (const u64
*) v1
;
4888 const u64
*d2
= (const u64
*) v2
;
4894 if (d1
[n
] > d2
[n
]) return ( 1);
4895 if (d1
[n
] < d2
[n
]) return (-1);
4901 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4903 const u64
*d1
= (const u64
*) v1
;
4904 const u64
*d2
= (const u64
*) v2
;
4910 if (d1
[n
] > d2
[n
]) return ( 1);
4911 if (d1
[n
] < d2
[n
]) return (-1);
4917 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4919 const u32
*d1
= (const u32
*) v1
;
4920 const u32
*d2
= (const u32
*) v2
;
4922 const uint dgst_pos0
= data
.dgst_pos0
;
4923 const uint dgst_pos1
= data
.dgst_pos1
;
4924 const uint dgst_pos2
= data
.dgst_pos2
;
4925 const uint dgst_pos3
= data
.dgst_pos3
;
4927 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4928 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4929 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4930 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4931 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4932 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4933 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4934 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4939 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4941 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4942 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4944 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4946 if (res1
!= 0) return (res1
);
4951 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4953 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4954 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4956 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4958 if (res1
!= 0) return (res1
);
4960 const int res2
= t1
->attack_mode
4963 if (res2
!= 0) return (res2
);
4965 const int res3
= t1
->hash_type
4968 if (res3
!= 0) return (res3
);
4973 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
)
4975 uint outfile_autohex
= data
.outfile_autohex
;
4977 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4979 FILE *debug_fp
= NULL
;
4981 if (debug_file
!= NULL
)
4983 debug_fp
= fopen (debug_file
, "ab");
4985 lock_file (debug_fp
);
4992 if (debug_fp
== NULL
)
4994 log_info ("WARNING: Could not open debug-file for writing");
4998 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
5000 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
5002 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
5005 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
5007 if (debug_mode
== 4)
5009 fputc (':', debug_fp
);
5011 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
5014 fputc ('\n', debug_fp
);
5016 if (debug_file
!= NULL
) fclose (debug_fp
);
5020 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
5022 int needs_hexify
= 0;
5024 if (outfile_autohex
== 1)
5026 for (uint i
= 0; i
< plain_len
; i
++)
5028 if (plain_ptr
[i
] < 0x20)
5035 if (plain_ptr
[i
] > 0x7f)
5044 if (needs_hexify
== 1)
5046 fprintf (fp
, "$HEX[");
5048 for (uint i
= 0; i
< plain_len
; i
++)
5050 fprintf (fp
, "%02x", plain_ptr
[i
]);
5057 fwrite (plain_ptr
, plain_len
, 1, fp
);
5061 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
)
5063 uint outfile_format
= data
.outfile_format
;
5065 char separator
= data
.separator
;
5067 if (outfile_format
& OUTFILE_FMT_HASH
)
5069 fprintf (out_fp
, "%s", out_buf
);
5071 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5073 fputc (separator
, out_fp
);
5076 else if (data
.username
)
5078 if (username
!= NULL
)
5080 for (uint i
= 0; i
< user_len
; i
++)
5082 fprintf (out_fp
, "%c", username
[i
]);
5085 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5087 fputc (separator
, out_fp
);
5092 if (outfile_format
& OUTFILE_FMT_PLAIN
)
5094 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
5096 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5098 fputc (separator
, out_fp
);
5102 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
5104 for (uint i
= 0; i
< plain_len
; i
++)
5106 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
5109 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
5111 fputc (separator
, out_fp
);
5115 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
5118 __mingw_fprintf (out_fp
, "%llu", crackpos
);
5123 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
5125 fprintf (out_fp
, "%llu", crackpos
);
5130 fputc ('\n', out_fp
);
5133 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
)
5137 pot_key
.hash
.salt
= hashes_buf
->salt
;
5138 pot_key
.hash
.digest
= hashes_buf
->digest
;
5140 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5146 input_buf
[input_len
] = 0;
5149 unsigned char *username
= NULL
;
5154 user_t
*user
= hashes_buf
->hash_info
->user
;
5158 username
= (unsigned char *) (user
->user_name
);
5160 user_len
= user
->user_len
;
5164 // do output the line
5165 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5169 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5170 #define LM_MASKED_PLAIN "[notfound]"
5172 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
)
5178 pot_left_key
.hash
.salt
= hash_left
->salt
;
5179 pot_left_key
.hash
.digest
= hash_left
->digest
;
5181 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5185 uint weak_hash_found
= 0;
5187 pot_t pot_right_key
;
5189 pot_right_key
.hash
.salt
= hash_right
->salt
;
5190 pot_right_key
.hash
.digest
= hash_right
->digest
;
5192 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5194 if (pot_right_ptr
== NULL
)
5196 // special case, if "weak hash"
5198 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5200 weak_hash_found
= 1;
5202 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5204 // in theory this is not needed, but we are paranoia:
5206 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5207 pot_right_ptr
->plain_len
= 0;
5211 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5213 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
5218 // at least one half was found:
5222 input_buf
[input_len
] = 0;
5226 unsigned char *username
= NULL
;
5231 user_t
*user
= hash_left
->hash_info
->user
;
5235 username
= (unsigned char *) (user
->user_name
);
5237 user_len
= user
->user_len
;
5241 // mask the part which was not found
5243 uint left_part_masked
= 0;
5244 uint right_part_masked
= 0;
5246 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5248 if (pot_left_ptr
== NULL
)
5250 left_part_masked
= 1;
5252 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5254 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5256 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5257 pot_left_ptr
->plain_len
= mask_plain_len
;
5260 if (pot_right_ptr
== NULL
)
5262 right_part_masked
= 1;
5264 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5266 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5268 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5269 pot_right_ptr
->plain_len
= mask_plain_len
;
5272 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5276 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5278 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5280 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5282 // do output the line
5284 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5286 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5288 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5289 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5292 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
)
5296 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5298 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5300 if (pot_ptr
== NULL
)
5304 input_buf
[input_len
] = 0;
5306 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5310 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
)
5316 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5318 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5322 pot_t pot_right_key
;
5324 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5326 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5328 uint weak_hash_found
= 0;
5330 if (pot_right_ptr
== NULL
)
5332 // special case, if "weak hash"
5334 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5336 weak_hash_found
= 1;
5338 // we just need that pot_right_ptr is not a NULL pointer
5340 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5344 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5346 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5351 // ... at least one part was not cracked
5355 input_buf
[input_len
] = 0;
5357 // only show the hash part which is still not cracked
5359 uint user_len
= input_len
- 32;
5361 char *hash_output
= (char *) mymalloc (33);
5363 memcpy (hash_output
, input_buf
, input_len
);
5365 if (pot_left_ptr
!= NULL
)
5367 // only show right part (because left part was already found)
5369 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5371 hash_output
[user_len
+ 16] = 0;
5374 if (pot_right_ptr
!= NULL
)
5376 // only show left part (because right part was already found)
5378 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5380 hash_output
[user_len
+ 16] = 0;
5383 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5385 myfree (hash_output
);
5387 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5390 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5392 uint opencl_platforms_filter
= 0;
5394 if (opencl_platforms
)
5396 char *platforms
= strdup (opencl_platforms
);
5398 char *next
= strtok (platforms
, ",");
5402 int platform
= atoi (next
);
5404 if (platform
< 1 || platform
> 32)
5406 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5411 opencl_platforms_filter
|= 1 << (platform
- 1);
5413 } while ((next
= strtok (NULL
, ",")) != NULL
);
5419 opencl_platforms_filter
= -1;
5422 return opencl_platforms_filter
;
5425 u32
setup_devices_filter (char *opencl_devices
)
5427 u32 devices_filter
= 0;
5431 char *devices
= strdup (opencl_devices
);
5433 char *next
= strtok (devices
, ",");
5437 int device_id
= atoi (next
);
5439 if (device_id
< 1 || device_id
> 32)
5441 log_error ("ERROR: invalid device_id %u specified", device_id
);
5446 devices_filter
|= 1 << (device_id
- 1);
5448 } while ((next
= strtok (NULL
, ",")) != NULL
);
5454 devices_filter
= -1;
5457 return devices_filter
;
5460 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5462 cl_device_type device_types_filter
= 0;
5464 if (opencl_device_types
)
5466 char *device_types
= strdup (opencl_device_types
);
5468 char *next
= strtok (device_types
, ",");
5472 int device_type
= atoi (next
);
5474 if (device_type
< 1 || device_type
> 3)
5476 log_error ("ERROR: invalid device_type %u specified", device_type
);
5481 device_types_filter
|= 1 << device_type
;
5483 } while ((next
= strtok (NULL
, ",")) != NULL
);
5485 free (device_types
);
5489 // Do not use CPU by default, this often reduces GPU performance because
5490 // the CPU is too busy to handle GPU synchronization
5492 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5495 return device_types_filter
;
5498 u32
get_random_num (const u32 min
, const u32 max
)
5500 if (min
== max
) return (min
);
5502 return ((rand () % (max
- min
)) + min
);
5505 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5507 u32 quotient
= dividend
/ divisor
;
5509 if (dividend
% divisor
) quotient
++;
5514 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5516 u64 quotient
= dividend
/ divisor
;
5518 if (dividend
% divisor
) quotient
++;
5523 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5525 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5526 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5528 if (tm
->tm_year
- 70)
5530 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5531 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5533 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5535 else if (tm
->tm_yday
)
5537 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5538 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5540 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5542 else if (tm
->tm_hour
)
5544 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5545 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5547 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5549 else if (tm
->tm_min
)
5551 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5552 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5554 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5558 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5560 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5564 void format_speed_display (float val
, char *buf
, size_t len
)
5575 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5586 /* generate output */
5590 snprintf (buf
, len
- 1, "%.0f ", val
);
5594 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5598 void lowercase (u8
*buf
, int len
)
5600 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5603 void uppercase (u8
*buf
, int len
)
5605 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5608 int fgetl (FILE *fp
, char *line_buf
)
5614 const int c
= fgetc (fp
);
5616 if (c
== EOF
) break;
5618 line_buf
[line_len
] = (char) c
;
5622 if (line_len
== HCBUFSIZ
) line_len
--;
5624 if (c
== '\n') break;
5627 if (line_len
== 0) return 0;
5629 if (line_buf
[line_len
- 1] == '\n')
5633 line_buf
[line_len
] = 0;
5636 if (line_len
== 0) return 0;
5638 if (line_buf
[line_len
- 1] == '\r')
5642 line_buf
[line_len
] = 0;
5648 int in_superchop (char *buf
)
5650 int len
= strlen (buf
);
5654 if (buf
[len
- 1] == '\n')
5661 if (buf
[len
- 1] == '\r')
5676 char **scan_directory (const char *path
)
5678 char *tmp_path
= mystrdup (path
);
5680 size_t tmp_path_len
= strlen (tmp_path
);
5682 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5684 tmp_path
[tmp_path_len
- 1] = 0;
5686 tmp_path_len
= strlen (tmp_path
);
5689 char **files
= NULL
;
5695 if ((d
= opendir (tmp_path
)) != NULL
)
5701 memset (&e
, 0, sizeof (e
));
5702 struct dirent
*de
= NULL
;
5704 if (readdir_r (d
, &e
, &de
) != 0)
5706 log_error ("ERROR: readdir_r() failed");
5711 if (de
== NULL
) break;
5715 while ((de
= readdir (d
)) != NULL
)
5718 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5720 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5722 char *path_file
= (char *) mymalloc (path_size
+ 1);
5724 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5726 path_file
[path_size
] = 0;
5730 if ((d_test
= opendir (path_file
)) != NULL
)
5738 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5742 files
[num_files
- 1] = path_file
;
5748 else if (errno
== ENOTDIR
)
5750 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5754 files
[num_files
- 1] = mystrdup (path
);
5757 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5761 files
[num_files
- 1] = NULL
;
5768 int count_dictionaries (char **dictionary_files
)
5770 if (dictionary_files
== NULL
) return 0;
5774 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5782 char *stroptitype (const uint opti_type
)
5786 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5787 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5788 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5789 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5790 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5791 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5792 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5793 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5794 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5795 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5796 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5797 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5798 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5799 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5800 case OPTI_TYPE_SLOW_HASH_SIMD
: return ((char *) OPTI_STR_SLOW_HASH_SIMD
); break;
5801 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5802 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5803 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5804 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5810 char *strparser (const uint parser_status
)
5812 switch (parser_status
)
5814 case PARSER_OK
: return ((char *) PA_000
); break;
5815 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5816 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5817 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5818 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5819 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5820 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5821 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5822 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5823 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5824 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5825 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5826 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5827 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5828 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5829 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5830 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5833 return ((char *) PA_255
);
5836 char *strhashtype (const uint hash_mode
)
5840 case 0: return ((char *) HT_00000
); break;
5841 case 10: return ((char *) HT_00010
); break;
5842 case 11: return ((char *) HT_00011
); break;
5843 case 12: return ((char *) HT_00012
); break;
5844 case 20: return ((char *) HT_00020
); break;
5845 case 21: return ((char *) HT_00021
); break;
5846 case 22: return ((char *) HT_00022
); break;
5847 case 23: return ((char *) HT_00023
); break;
5848 case 30: return ((char *) HT_00030
); break;
5849 case 40: return ((char *) HT_00040
); break;
5850 case 50: return ((char *) HT_00050
); break;
5851 case 60: return ((char *) HT_00060
); break;
5852 case 100: return ((char *) HT_00100
); break;
5853 case 101: return ((char *) HT_00101
); break;
5854 case 110: return ((char *) HT_00110
); break;
5855 case 111: return ((char *) HT_00111
); break;
5856 case 112: return ((char *) HT_00112
); break;
5857 case 120: return ((char *) HT_00120
); break;
5858 case 121: return ((char *) HT_00121
); break;
5859 case 122: return ((char *) HT_00122
); break;
5860 case 124: return ((char *) HT_00124
); break;
5861 case 125: return ((char *) HT_00125
); break;
5862 case 130: return ((char *) HT_00130
); break;
5863 case 131: return ((char *) HT_00131
); break;
5864 case 132: return ((char *) HT_00132
); break;
5865 case 133: return ((char *) HT_00133
); break;
5866 case 140: return ((char *) HT_00140
); break;
5867 case 141: return ((char *) HT_00141
); break;
5868 case 150: return ((char *) HT_00150
); break;
5869 case 160: return ((char *) HT_00160
); break;
5870 case 190: return ((char *) HT_00190
); break;
5871 case 200: return ((char *) HT_00200
); break;
5872 case 300: return ((char *) HT_00300
); break;
5873 case 400: return ((char *) HT_00400
); break;
5874 case 500: return ((char *) HT_00500
); break;
5875 case 501: return ((char *) HT_00501
); break;
5876 case 900: return ((char *) HT_00900
); break;
5877 case 910: return ((char *) HT_00910
); break;
5878 case 1000: return ((char *) HT_01000
); break;
5879 case 1100: return ((char *) HT_01100
); break;
5880 case 1400: return ((char *) HT_01400
); break;
5881 case 1410: return ((char *) HT_01410
); break;
5882 case 1420: return ((char *) HT_01420
); break;
5883 case 1421: return ((char *) HT_01421
); break;
5884 case 1430: return ((char *) HT_01430
); break;
5885 case 1440: return ((char *) HT_01440
); break;
5886 case 1441: return ((char *) HT_01441
); break;
5887 case 1450: return ((char *) HT_01450
); break;
5888 case 1460: return ((char *) HT_01460
); break;
5889 case 1500: return ((char *) HT_01500
); break;
5890 case 1600: return ((char *) HT_01600
); break;
5891 case 1700: return ((char *) HT_01700
); break;
5892 case 1710: return ((char *) HT_01710
); break;
5893 case 1711: return ((char *) HT_01711
); break;
5894 case 1720: return ((char *) HT_01720
); break;
5895 case 1722: return ((char *) HT_01722
); break;
5896 case 1730: return ((char *) HT_01730
); break;
5897 case 1731: return ((char *) HT_01731
); break;
5898 case 1740: return ((char *) HT_01740
); break;
5899 case 1750: return ((char *) HT_01750
); break;
5900 case 1760: return ((char *) HT_01760
); break;
5901 case 1800: return ((char *) HT_01800
); break;
5902 case 2100: return ((char *) HT_02100
); break;
5903 case 2400: return ((char *) HT_02400
); break;
5904 case 2410: return ((char *) HT_02410
); break;
5905 case 2500: return ((char *) HT_02500
); break;
5906 case 2600: return ((char *) HT_02600
); break;
5907 case 2611: return ((char *) HT_02611
); break;
5908 case 2612: return ((char *) HT_02612
); break;
5909 case 2711: return ((char *) HT_02711
); break;
5910 case 2811: return ((char *) HT_02811
); break;
5911 case 3000: return ((char *) HT_03000
); break;
5912 case 3100: return ((char *) HT_03100
); break;
5913 case 3200: return ((char *) HT_03200
); break;
5914 case 3710: return ((char *) HT_03710
); break;
5915 case 3711: return ((char *) HT_03711
); break;
5916 case 3800: return ((char *) HT_03800
); break;
5917 case 4300: return ((char *) HT_04300
); break;
5918 case 4400: return ((char *) HT_04400
); break;
5919 case 4500: return ((char *) HT_04500
); break;
5920 case 4700: return ((char *) HT_04700
); break;
5921 case 4800: return ((char *) HT_04800
); break;
5922 case 4900: return ((char *) HT_04900
); break;
5923 case 5000: return ((char *) HT_05000
); break;
5924 case 5100: return ((char *) HT_05100
); break;
5925 case 5200: return ((char *) HT_05200
); break;
5926 case 5300: return ((char *) HT_05300
); break;
5927 case 5400: return ((char *) HT_05400
); break;
5928 case 5500: return ((char *) HT_05500
); break;
5929 case 5600: return ((char *) HT_05600
); break;
5930 case 5700: return ((char *) HT_05700
); break;
5931 case 5800: return ((char *) HT_05800
); break;
5932 case 6000: return ((char *) HT_06000
); break;
5933 case 6100: return ((char *) HT_06100
); break;
5934 case 6211: return ((char *) HT_06211
); break;
5935 case 6212: return ((char *) HT_06212
); break;
5936 case 6213: return ((char *) HT_06213
); break;
5937 case 6221: return ((char *) HT_06221
); break;
5938 case 6222: return ((char *) HT_06222
); break;
5939 case 6223: return ((char *) HT_06223
); break;
5940 case 6231: return ((char *) HT_06231
); break;
5941 case 6232: return ((char *) HT_06232
); break;
5942 case 6233: return ((char *) HT_06233
); break;
5943 case 6241: return ((char *) HT_06241
); break;
5944 case 6242: return ((char *) HT_06242
); break;
5945 case 6243: return ((char *) HT_06243
); break;
5946 case 6300: return ((char *) HT_06300
); break;
5947 case 6400: return ((char *) HT_06400
); break;
5948 case 6500: return ((char *) HT_06500
); break;
5949 case 6600: return ((char *) HT_06600
); break;
5950 case 6700: return ((char *) HT_06700
); break;
5951 case 6800: return ((char *) HT_06800
); break;
5952 case 6900: return ((char *) HT_06900
); break;
5953 case 7100: return ((char *) HT_07100
); break;
5954 case 7200: return ((char *) HT_07200
); break;
5955 case 7300: return ((char *) HT_07300
); break;
5956 case 7400: return ((char *) HT_07400
); break;
5957 case 7500: return ((char *) HT_07500
); break;
5958 case 7600: return ((char *) HT_07600
); break;
5959 case 7700: return ((char *) HT_07700
); break;
5960 case 7800: return ((char *) HT_07800
); break;
5961 case 7900: return ((char *) HT_07900
); break;
5962 case 8000: return ((char *) HT_08000
); break;
5963 case 8100: return ((char *) HT_08100
); break;
5964 case 8200: return ((char *) HT_08200
); break;
5965 case 8300: return ((char *) HT_08300
); break;
5966 case 8400: return ((char *) HT_08400
); break;
5967 case 8500: return ((char *) HT_08500
); break;
5968 case 8600: return ((char *) HT_08600
); break;
5969 case 8700: return ((char *) HT_08700
); break;
5970 case 8800: return ((char *) HT_08800
); break;
5971 case 8900: return ((char *) HT_08900
); break;
5972 case 9000: return ((char *) HT_09000
); break;
5973 case 9100: return ((char *) HT_09100
); break;
5974 case 9200: return ((char *) HT_09200
); break;
5975 case 9300: return ((char *) HT_09300
); break;
5976 case 9400: return ((char *) HT_09400
); break;
5977 case 9500: return ((char *) HT_09500
); break;
5978 case 9600: return ((char *) HT_09600
); break;
5979 case 9700: return ((char *) HT_09700
); break;
5980 case 9710: return ((char *) HT_09710
); break;
5981 case 9720: return ((char *) HT_09720
); break;
5982 case 9800: return ((char *) HT_09800
); break;
5983 case 9810: return ((char *) HT_09810
); break;
5984 case 9820: return ((char *) HT_09820
); break;
5985 case 9900: return ((char *) HT_09900
); break;
5986 case 10000: return ((char *) HT_10000
); break;
5987 case 10100: return ((char *) HT_10100
); break;
5988 case 10200: return ((char *) HT_10200
); break;
5989 case 10300: return ((char *) HT_10300
); break;
5990 case 10400: return ((char *) HT_10400
); break;
5991 case 10410: return ((char *) HT_10410
); break;
5992 case 10420: return ((char *) HT_10420
); break;
5993 case 10500: return ((char *) HT_10500
); break;
5994 case 10600: return ((char *) HT_10600
); break;
5995 case 10700: return ((char *) HT_10700
); break;
5996 case 10800: return ((char *) HT_10800
); break;
5997 case 10900: return ((char *) HT_10900
); break;
5998 case 11000: return ((char *) HT_11000
); break;
5999 case 11100: return ((char *) HT_11100
); break;
6000 case 11200: return ((char *) HT_11200
); break;
6001 case 11300: return ((char *) HT_11300
); break;
6002 case 11400: return ((char *) HT_11400
); break;
6003 case 11500: return ((char *) HT_11500
); break;
6004 case 11600: return ((char *) HT_11600
); break;
6005 case 11700: return ((char *) HT_11700
); break;
6006 case 11800: return ((char *) HT_11800
); break;
6007 case 11900: return ((char *) HT_11900
); break;
6008 case 12000: return ((char *) HT_12000
); break;
6009 case 12100: return ((char *) HT_12100
); break;
6010 case 12200: return ((char *) HT_12200
); break;
6011 case 12300: return ((char *) HT_12300
); break;
6012 case 12400: return ((char *) HT_12400
); break;
6013 case 12500: return ((char *) HT_12500
); break;
6014 case 12600: return ((char *) HT_12600
); break;
6015 case 12700: return ((char *) HT_12700
); break;
6016 case 12800: return ((char *) HT_12800
); break;
6017 case 12900: return ((char *) HT_12900
); break;
6018 case 13000: return ((char *) HT_13000
); break;
6019 case 13100: return ((char *) HT_13100
); break;
6020 case 13200: return ((char *) HT_13200
); break;
6021 case 13300: return ((char *) HT_13300
); break;
6022 case 13400: return ((char *) HT_13400
); break;
6023 case 13500: return ((char *) HT_13500
); break;
6024 case 13600: return ((char *) HT_13600
); break;
6025 case 13711: return ((char *) HT_13711
); break;
6026 case 13712: return ((char *) HT_13712
); break;
6027 case 13713: return ((char *) HT_13713
); break;
6028 case 13721: return ((char *) HT_13721
); break;
6029 case 13722: return ((char *) HT_13722
); break;
6030 case 13723: return ((char *) HT_13723
); break;
6031 case 13731: return ((char *) HT_13731
); break;
6032 case 13732: return ((char *) HT_13732
); break;
6033 case 13733: return ((char *) HT_13733
); break;
6034 case 13741: return ((char *) HT_13741
); break;
6035 case 13742: return ((char *) HT_13742
); break;
6036 case 13743: return ((char *) HT_13743
); break;
6037 case 13751: return ((char *) HT_13751
); break;
6038 case 13752: return ((char *) HT_13752
); break;
6039 case 13753: return ((char *) HT_13753
); break;
6040 case 13761: return ((char *) HT_13761
); break;
6041 case 13762: return ((char *) HT_13762
); break;
6042 case 13763: return ((char *) HT_13763
); break;
6043 case 13800: return ((char *) HT_13800
); break;
6046 return ((char *) "Unknown");
6049 char *strstatus (const uint devices_status
)
6051 switch (devices_status
)
6053 case STATUS_INIT
: return ((char *) ST_0000
); break;
6054 case STATUS_STARTING
: return ((char *) ST_0001
); break;
6055 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
6056 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
6057 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
6058 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
6059 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
6060 case STATUS_QUIT
: return ((char *) ST_0007
); break;
6061 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
6062 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
6063 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
6066 return ((char *) "Unknown");
6069 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
6071 uint hash_type
= data
.hash_type
;
6072 uint hash_mode
= data
.hash_mode
;
6073 uint salt_type
= data
.salt_type
;
6074 uint opts_type
= data
.opts_type
;
6075 uint opti_type
= data
.opti_type
;
6076 uint dgst_size
= data
.dgst_size
;
6078 char *hashfile
= data
.hashfile
;
6082 uint digest_buf
[64] = { 0 };
6084 u64
*digest_buf64
= (u64
*) digest_buf
;
6086 char *digests_buf_ptr
= (char *) data
.digests_buf
;
6088 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
6090 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6096 case HASH_TYPE_DESCRYPT
:
6097 FP (digest_buf
[1], digest_buf
[0], tt
);
6100 case HASH_TYPE_DESRACF
:
6101 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6102 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6104 FP (digest_buf
[1], digest_buf
[0], tt
);
6108 FP (digest_buf
[1], digest_buf
[0], tt
);
6111 case HASH_TYPE_NETNTLM
:
6112 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6113 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6114 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
6115 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
6117 FP (digest_buf
[1], digest_buf
[0], tt
);
6118 FP (digest_buf
[3], digest_buf
[2], tt
);
6121 case HASH_TYPE_BSDICRYPT
:
6122 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
6123 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
6125 FP (digest_buf
[1], digest_buf
[0], tt
);
6130 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
6135 digest_buf
[0] += MD4M_A
;
6136 digest_buf
[1] += MD4M_B
;
6137 digest_buf
[2] += MD4M_C
;
6138 digest_buf
[3] += MD4M_D
;
6142 digest_buf
[0] += MD5M_A
;
6143 digest_buf
[1] += MD5M_B
;
6144 digest_buf
[2] += MD5M_C
;
6145 digest_buf
[3] += MD5M_D
;
6148 case HASH_TYPE_SHA1
:
6149 digest_buf
[0] += SHA1M_A
;
6150 digest_buf
[1] += SHA1M_B
;
6151 digest_buf
[2] += SHA1M_C
;
6152 digest_buf
[3] += SHA1M_D
;
6153 digest_buf
[4] += SHA1M_E
;
6156 case HASH_TYPE_SHA256
:
6157 digest_buf
[0] += SHA256M_A
;
6158 digest_buf
[1] += SHA256M_B
;
6159 digest_buf
[2] += SHA256M_C
;
6160 digest_buf
[3] += SHA256M_D
;
6161 digest_buf
[4] += SHA256M_E
;
6162 digest_buf
[5] += SHA256M_F
;
6163 digest_buf
[6] += SHA256M_G
;
6164 digest_buf
[7] += SHA256M_H
;
6167 case HASH_TYPE_SHA384
:
6168 digest_buf64
[0] += SHA384M_A
;
6169 digest_buf64
[1] += SHA384M_B
;
6170 digest_buf64
[2] += SHA384M_C
;
6171 digest_buf64
[3] += SHA384M_D
;
6172 digest_buf64
[4] += SHA384M_E
;
6173 digest_buf64
[5] += SHA384M_F
;
6174 digest_buf64
[6] += 0;
6175 digest_buf64
[7] += 0;
6178 case HASH_TYPE_SHA512
:
6179 digest_buf64
[0] += SHA512M_A
;
6180 digest_buf64
[1] += SHA512M_B
;
6181 digest_buf64
[2] += SHA512M_C
;
6182 digest_buf64
[3] += SHA512M_D
;
6183 digest_buf64
[4] += SHA512M_E
;
6184 digest_buf64
[5] += SHA512M_F
;
6185 digest_buf64
[6] += SHA512M_G
;
6186 digest_buf64
[7] += SHA512M_H
;
6191 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6193 if (dgst_size
== DGST_SIZE_4_2
)
6195 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6197 else if (dgst_size
== DGST_SIZE_4_4
)
6199 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6201 else if (dgst_size
== DGST_SIZE_4_5
)
6203 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6205 else if (dgst_size
== DGST_SIZE_4_6
)
6207 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6209 else if (dgst_size
== DGST_SIZE_4_8
)
6211 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6213 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6215 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6217 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6219 else if (hash_type
== HASH_TYPE_SHA384
)
6221 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6223 else if (hash_type
== HASH_TYPE_SHA512
)
6225 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6227 else if (hash_type
== HASH_TYPE_GOST
)
6229 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6232 else if (dgst_size
== DGST_SIZE_4_64
)
6234 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6236 else if (dgst_size
== DGST_SIZE_8_25
)
6238 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6242 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6243 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6244 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6250 memset (&salt
, 0, sizeof (salt_t
));
6252 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6254 char *ptr
= (char *) salt
.salt_buf
;
6256 uint len
= salt
.salt_len
;
6258 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6264 case HASH_TYPE_NETNTLM
:
6266 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6267 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6269 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6275 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6277 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6285 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6287 uint max
= salt
.salt_len
/ 4;
6291 for (uint i
= 0; i
< max
; i
++)
6293 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6297 if (opts_type
& OPTS_TYPE_ST_HEX
)
6299 char tmp
[64] = { 0 };
6301 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6303 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6308 memcpy (ptr
, tmp
, len
);
6311 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6313 memset (ptr
+ len
, 0, memset_size
);
6315 salt
.salt_len
= len
;
6319 // some modes require special encoding
6322 uint out_buf_plain
[256] = { 0 };
6323 uint out_buf_salt
[256] = { 0 };
6325 char tmp_buf
[1024] = { 0 };
6327 char *ptr_plain
= (char *) out_buf_plain
;
6328 char *ptr_salt
= (char *) out_buf_salt
;
6330 if (hash_mode
== 22)
6332 char username
[30] = { 0 };
6334 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6336 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6338 u16
*ptr
= (u16
*) digest_buf
;
6340 tmp_buf
[ 0] = sig
[0];
6341 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6342 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6343 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6344 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6345 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6346 tmp_buf
[ 6] = sig
[1];
6347 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6348 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6349 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6350 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6351 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6352 tmp_buf
[12] = sig
[2];
6353 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6354 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6355 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6356 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6357 tmp_buf
[17] = sig
[3];
6358 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6359 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6360 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6361 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6362 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6363 tmp_buf
[23] = sig
[4];
6364 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6365 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6366 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6367 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6368 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6369 tmp_buf
[29] = sig
[5];
6371 snprintf (out_buf
, len
-1, "%s:%s",
6375 else if (hash_mode
== 23)
6377 // do not show the skyper part in output
6379 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6381 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6383 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6390 else if (hash_mode
== 101)
6392 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6394 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6395 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6396 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6397 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6398 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6400 memcpy (tmp_buf
, digest_buf
, 20);
6402 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6404 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6406 else if (hash_mode
== 111)
6408 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6410 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6411 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6412 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6413 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6414 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6416 memcpy (tmp_buf
, digest_buf
, 20);
6417 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6419 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6421 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6423 else if ((hash_mode
== 122) || (hash_mode
== 125))
6425 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6426 (char *) salt
.salt_buf
,
6433 else if (hash_mode
== 124)
6435 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6436 (char *) salt
.salt_buf
,
6443 else if (hash_mode
== 131)
6445 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6446 (char *) salt
.salt_buf
,
6454 else if (hash_mode
== 132)
6456 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6457 (char *) salt
.salt_buf
,
6464 else if (hash_mode
== 133)
6466 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6468 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6469 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6470 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6471 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6472 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6474 memcpy (tmp_buf
, digest_buf
, 20);
6476 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6478 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6480 else if (hash_mode
== 141)
6482 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6484 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6486 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6488 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6490 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6491 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6492 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6493 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6494 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6496 memcpy (tmp_buf
, digest_buf
, 20);
6498 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6502 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6504 else if (hash_mode
== 400)
6506 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6508 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6509 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6510 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6511 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6513 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6515 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6517 else if (hash_mode
== 500)
6519 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6521 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6522 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6523 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6524 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6526 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6528 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6530 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6534 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6537 else if (hash_mode
== 501)
6539 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6541 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6542 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6544 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6546 else if (hash_mode
== 1421)
6548 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6550 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6566 else if (hash_mode
== 1441)
6568 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6570 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6572 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6574 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6576 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6577 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6578 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6579 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6580 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6581 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6582 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6583 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6585 memcpy (tmp_buf
, digest_buf
, 32);
6587 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6591 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6593 else if (hash_mode
== 1500)
6595 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6596 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6597 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6598 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6599 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6601 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6603 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6605 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6606 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6608 memcpy (tmp_buf
, digest_buf
, 8);
6610 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6612 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6616 else if (hash_mode
== 1600)
6618 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6620 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6621 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6622 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6623 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6625 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6627 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6629 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6633 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6636 else if (hash_mode
== 1711)
6638 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6640 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6641 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6642 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6643 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6644 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6645 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6646 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6647 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6649 memcpy (tmp_buf
, digest_buf
, 64);
6650 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6652 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6654 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6656 else if (hash_mode
== 1722)
6658 uint
*ptr
= digest_buf
;
6660 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6661 (unsigned char *) salt
.salt_buf
,
6671 else if (hash_mode
== 1731)
6673 uint
*ptr
= digest_buf
;
6675 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6676 (unsigned char *) salt
.salt_buf
,
6686 else if (hash_mode
== 1800)
6690 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6691 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6692 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6693 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6694 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6695 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6696 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6697 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6699 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6701 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6703 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6707 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6710 else if (hash_mode
== 2100)
6714 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6716 salt
.salt_iter
+ 1);
6718 uint signature_len
= strlen (out_buf
);
6720 pos
+= signature_len
;
6721 len
-= signature_len
;
6723 char *salt_ptr
= (char *) salt
.salt_buf
;
6725 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6727 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6728 byte_swap_32 (digest_buf
[0]),
6729 byte_swap_32 (digest_buf
[1]),
6730 byte_swap_32 (digest_buf
[2]),
6731 byte_swap_32 (digest_buf
[3]));
6733 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6735 memcpy (tmp_buf
, digest_buf
, 16);
6737 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6739 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6740 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6741 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6742 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6744 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6745 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6746 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6747 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6749 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6750 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6751 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6752 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6754 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6755 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6756 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6757 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6759 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6760 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6761 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6762 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6766 else if (hash_mode
== 2500)
6768 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6770 wpa_t
*wpa
= &wpas
[salt_pos
];
6772 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6773 (char *) salt
.salt_buf
,
6787 else if (hash_mode
== 4400)
6789 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6790 byte_swap_32 (digest_buf
[0]),
6791 byte_swap_32 (digest_buf
[1]),
6792 byte_swap_32 (digest_buf
[2]),
6793 byte_swap_32 (digest_buf
[3]));
6795 else if (hash_mode
== 4700)
6797 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6798 byte_swap_32 (digest_buf
[0]),
6799 byte_swap_32 (digest_buf
[1]),
6800 byte_swap_32 (digest_buf
[2]),
6801 byte_swap_32 (digest_buf
[3]),
6802 byte_swap_32 (digest_buf
[4]));
6804 else if (hash_mode
== 4800)
6806 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6808 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6813 byte_swap_32 (salt
.salt_buf
[0]),
6814 byte_swap_32 (salt
.salt_buf
[1]),
6815 byte_swap_32 (salt
.salt_buf
[2]),
6816 byte_swap_32 (salt
.salt_buf
[3]),
6819 else if (hash_mode
== 4900)
6821 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6822 byte_swap_32 (digest_buf
[0]),
6823 byte_swap_32 (digest_buf
[1]),
6824 byte_swap_32 (digest_buf
[2]),
6825 byte_swap_32 (digest_buf
[3]),
6826 byte_swap_32 (digest_buf
[4]));
6828 else if (hash_mode
== 5100)
6830 snprintf (out_buf
, len
-1, "%08x%08x",
6834 else if (hash_mode
== 5200)
6836 snprintf (out_buf
, len
-1, "%s", hashfile
);
6838 else if (hash_mode
== 5300)
6840 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6842 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6844 int buf_len
= len
-1;
6848 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6850 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6852 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6854 snprintf (out_buf
, buf_len
, ":");
6860 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6868 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6870 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6872 if ((i
== 0) || (i
== 5))
6874 snprintf (out_buf
, buf_len
, ":");
6880 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6888 for (uint i
= 0; i
< 4; i
++)
6892 snprintf (out_buf
, buf_len
, ":");
6898 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6904 else if (hash_mode
== 5400)
6906 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6908 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6910 int buf_len
= len
-1;
6914 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6916 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6918 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6920 snprintf (out_buf
, buf_len
, ":");
6926 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6934 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6936 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6938 if ((i
== 0) || (i
== 5))
6940 snprintf (out_buf
, buf_len
, ":");
6946 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6954 for (uint i
= 0; i
< 5; i
++)
6958 snprintf (out_buf
, buf_len
, ":");
6964 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6970 else if (hash_mode
== 5500)
6972 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6974 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6976 char user_buf
[64] = { 0 };
6977 char domain_buf
[64] = { 0 };
6978 char srvchall_buf
[1024] = { 0 };
6979 char clichall_buf
[1024] = { 0 };
6981 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6983 char *ptr
= (char *) netntlm
->userdomain_buf
;
6985 user_buf
[i
] = ptr
[j
];
6988 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6990 char *ptr
= (char *) netntlm
->userdomain_buf
;
6992 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6995 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6997 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6999 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7002 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7004 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7006 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7009 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
7017 byte_swap_32 (salt
.salt_buf_pc
[0]),
7018 byte_swap_32 (salt
.salt_buf_pc
[1]),
7021 else if (hash_mode
== 5600)
7023 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7025 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7027 char user_buf
[64] = { 0 };
7028 char domain_buf
[64] = { 0 };
7029 char srvchall_buf
[1024] = { 0 };
7030 char clichall_buf
[1024] = { 0 };
7032 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7034 char *ptr
= (char *) netntlm
->userdomain_buf
;
7036 user_buf
[i
] = ptr
[j
];
7039 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7041 char *ptr
= (char *) netntlm
->userdomain_buf
;
7043 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7046 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7048 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7050 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7053 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7055 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7057 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7060 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
7070 else if (hash_mode
== 5700)
7072 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7074 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7075 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7076 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7077 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7078 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7079 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7080 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7081 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7083 memcpy (tmp_buf
, digest_buf
, 32);
7085 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
7089 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
7091 else if (hash_mode
== 5800)
7093 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7094 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7095 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7096 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7097 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7099 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
7106 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
7108 snprintf (out_buf
, len
-1, "%s", hashfile
);
7110 else if (hash_mode
== 6300)
7112 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7114 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7115 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7116 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7117 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7119 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7121 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7123 else if (hash_mode
== 6400)
7125 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7127 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7129 else if (hash_mode
== 6500)
7131 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7133 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7135 else if (hash_mode
== 6600)
7137 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
7139 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
7141 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7142 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7144 uint buf_len
= len
- 1;
7146 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
7149 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
7151 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
7156 else if (hash_mode
== 6700)
7158 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7160 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7162 else if (hash_mode
== 6800)
7164 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
7166 else if (hash_mode
== 7100)
7168 uint
*ptr
= digest_buf
;
7170 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7172 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7174 uint esalt
[8] = { 0 };
7176 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7177 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7178 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7179 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7180 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7181 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7182 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7183 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7185 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",
7186 SIGNATURE_SHA512OSX
,
7188 esalt
[ 0], esalt
[ 1],
7189 esalt
[ 2], esalt
[ 3],
7190 esalt
[ 4], esalt
[ 5],
7191 esalt
[ 6], esalt
[ 7],
7199 ptr
[15], ptr
[14]);
7201 else if (hash_mode
== 7200)
7203 uint
*ptr
= digest_buf
;
7205 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7207 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7211 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7213 len_used
= strlen (out_buf
);
7215 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7217 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7219 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7222 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",
7230 ptr
[15], ptr
[14]);
7232 else if (hash_mode
== 7300)
7234 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7236 rakp_t
*rakp
= &rakps
[salt_pos
];
7238 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7240 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7243 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7250 else if (hash_mode
== 7400)
7252 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7254 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7255 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7256 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7257 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7258 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7259 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7260 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7261 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7263 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7265 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7267 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7271 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7274 else if (hash_mode
== 7500)
7276 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7278 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7280 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7281 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7283 char data
[128] = { 0 };
7285 char *ptr_data
= data
;
7287 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7289 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7292 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7294 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7299 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7301 (char *) krb5pa
->user
,
7302 (char *) krb5pa
->realm
,
7303 (char *) krb5pa
->salt
,
7306 else if (hash_mode
== 7700)
7308 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7309 (char *) salt
.salt_buf
,
7313 else if (hash_mode
== 7800)
7315 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7316 (char *) salt
.salt_buf
,
7323 else if (hash_mode
== 7900)
7325 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7329 char *tmp
= (char *) salt
.salt_buf_pc
;
7331 ptr_plain
[42] = tmp
[0];
7337 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7339 else if (hash_mode
== 8000)
7341 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7342 (unsigned char *) salt
.salt_buf
,
7352 else if (hash_mode
== 8100)
7354 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7355 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7357 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7358 (unsigned char *) salt
.salt_buf
,
7365 else if (hash_mode
== 8200)
7367 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7369 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7371 char data_buf
[4096] = { 0 };
7373 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7375 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7378 data_buf
[cloudkey
->data_len
* 2] = 0;
7380 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7381 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7382 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7383 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7384 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7385 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7386 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7387 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7389 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7390 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7391 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7392 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7394 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7410 else if (hash_mode
== 8300)
7412 char digest_buf_c
[34] = { 0 };
7414 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7415 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7416 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7417 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7418 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7420 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7422 digest_buf_c
[32] = 0;
7426 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7428 char domain_buf_c
[33] = { 0 };
7430 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7432 for (uint i
= 0; i
< salt_pc_len
; i
++)
7434 const char next
= domain_buf_c
[i
];
7436 domain_buf_c
[i
] = '.';
7441 domain_buf_c
[salt_pc_len
] = 0;
7445 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7447 else if (hash_mode
== 8500)
7449 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7451 else if (hash_mode
== 2612)
7453 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7455 (char *) salt
.salt_buf
,
7461 else if (hash_mode
== 3711)
7463 char *salt_ptr
= (char *) salt
.salt_buf
;
7465 salt_ptr
[salt
.salt_len
- 1] = 0;
7467 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7468 SIGNATURE_MEDIAWIKI_B
,
7475 else if (hash_mode
== 8800)
7477 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7479 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7481 char tmp
[3073] = { 0 };
7483 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7485 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7490 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7491 SIGNATURE_ANDROIDFDE
,
7492 byte_swap_32 (salt
.salt_buf
[0]),
7493 byte_swap_32 (salt
.salt_buf
[1]),
7494 byte_swap_32 (salt
.salt_buf
[2]),
7495 byte_swap_32 (salt
.salt_buf
[3]),
7496 byte_swap_32 (digest_buf
[0]),
7497 byte_swap_32 (digest_buf
[1]),
7498 byte_swap_32 (digest_buf
[2]),
7499 byte_swap_32 (digest_buf
[3]),
7502 else if (hash_mode
== 8900)
7504 uint N
= salt
.scrypt_N
;
7505 uint r
= salt
.scrypt_r
;
7506 uint p
= salt
.scrypt_p
;
7508 char base64_salt
[32] = { 0 };
7510 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7512 memset (tmp_buf
, 0, 46);
7514 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7515 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7516 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7517 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7518 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7519 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7520 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7521 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7522 digest_buf
[8] = 0; // needed for base64_encode ()
7524 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7526 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7534 else if (hash_mode
== 9000)
7536 snprintf (out_buf
, len
-1, "%s", hashfile
);
7538 else if (hash_mode
== 9200)
7542 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7544 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7546 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7550 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7551 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7552 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7553 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7554 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7555 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7556 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7557 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7558 digest_buf
[8] = 0; // needed for base64_encode ()
7560 char tmp_buf
[64] = { 0 };
7562 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7563 tmp_buf
[43] = 0; // cut it here
7567 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7569 else if (hash_mode
== 9300)
7571 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7572 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7573 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7574 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7575 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7576 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7577 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7578 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7579 digest_buf
[8] = 0; // needed for base64_encode ()
7581 char tmp_buf
[64] = { 0 };
7583 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7584 tmp_buf
[43] = 0; // cut it here
7586 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7588 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7590 else if (hash_mode
== 9400)
7592 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7594 office2007_t
*office2007
= &office2007s
[salt_pos
];
7596 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7597 SIGNATURE_OFFICE2007
,
7600 office2007
->keySize
,
7606 office2007
->encryptedVerifier
[0],
7607 office2007
->encryptedVerifier
[1],
7608 office2007
->encryptedVerifier
[2],
7609 office2007
->encryptedVerifier
[3],
7610 office2007
->encryptedVerifierHash
[0],
7611 office2007
->encryptedVerifierHash
[1],
7612 office2007
->encryptedVerifierHash
[2],
7613 office2007
->encryptedVerifierHash
[3],
7614 office2007
->encryptedVerifierHash
[4]);
7616 else if (hash_mode
== 9500)
7618 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7620 office2010_t
*office2010
= &office2010s
[salt_pos
];
7622 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x%08x%08x", SIGNATURE_OFFICE2010
, 2010, 100000, 128, 16,
7628 office2010
->encryptedVerifier
[0],
7629 office2010
->encryptedVerifier
[1],
7630 office2010
->encryptedVerifier
[2],
7631 office2010
->encryptedVerifier
[3],
7632 office2010
->encryptedVerifierHash
[0],
7633 office2010
->encryptedVerifierHash
[1],
7634 office2010
->encryptedVerifierHash
[2],
7635 office2010
->encryptedVerifierHash
[3],
7636 office2010
->encryptedVerifierHash
[4],
7637 office2010
->encryptedVerifierHash
[5],
7638 office2010
->encryptedVerifierHash
[6],
7639 office2010
->encryptedVerifierHash
[7]);
7641 else if (hash_mode
== 9600)
7643 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7645 office2013_t
*office2013
= &office2013s
[salt_pos
];
7647 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,
7653 office2013
->encryptedVerifier
[0],
7654 office2013
->encryptedVerifier
[1],
7655 office2013
->encryptedVerifier
[2],
7656 office2013
->encryptedVerifier
[3],
7657 office2013
->encryptedVerifierHash
[0],
7658 office2013
->encryptedVerifierHash
[1],
7659 office2013
->encryptedVerifierHash
[2],
7660 office2013
->encryptedVerifierHash
[3],
7661 office2013
->encryptedVerifierHash
[4],
7662 office2013
->encryptedVerifierHash
[5],
7663 office2013
->encryptedVerifierHash
[6],
7664 office2013
->encryptedVerifierHash
[7]);
7666 else if (hash_mode
== 9700)
7668 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7670 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7672 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7673 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7674 byte_swap_32 (salt
.salt_buf
[0]),
7675 byte_swap_32 (salt
.salt_buf
[1]),
7676 byte_swap_32 (salt
.salt_buf
[2]),
7677 byte_swap_32 (salt
.salt_buf
[3]),
7678 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7679 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7680 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7681 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7682 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7683 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7684 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7685 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7687 else if (hash_mode
== 9710)
7689 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7691 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7693 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7694 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7695 byte_swap_32 (salt
.salt_buf
[0]),
7696 byte_swap_32 (salt
.salt_buf
[1]),
7697 byte_swap_32 (salt
.salt_buf
[2]),
7698 byte_swap_32 (salt
.salt_buf
[3]),
7699 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7700 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7701 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7702 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7703 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7704 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7705 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7706 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7708 else if (hash_mode
== 9720)
7710 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7712 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7714 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7716 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7717 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7718 byte_swap_32 (salt
.salt_buf
[0]),
7719 byte_swap_32 (salt
.salt_buf
[1]),
7720 byte_swap_32 (salt
.salt_buf
[2]),
7721 byte_swap_32 (salt
.salt_buf
[3]),
7722 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7723 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7724 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7725 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7726 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7727 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7728 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7729 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7736 else if (hash_mode
== 9800)
7738 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7740 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7742 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7743 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7748 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7749 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7750 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7751 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7752 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7753 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7754 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7755 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7756 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7758 else if (hash_mode
== 9810)
7760 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7762 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7764 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7765 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7770 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7771 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7772 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7773 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7774 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7775 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7776 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7777 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7778 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7780 else if (hash_mode
== 9820)
7782 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7784 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7786 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7788 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7789 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7794 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7795 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7796 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7797 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7798 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7799 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7800 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7801 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7802 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7809 else if (hash_mode
== 10000)
7813 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7815 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7817 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7821 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7822 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7823 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7824 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7825 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7826 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7827 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7828 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7829 digest_buf
[8] = 0; // needed for base64_encode ()
7831 char tmp_buf
[64] = { 0 };
7833 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7837 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7839 else if (hash_mode
== 10100)
7841 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7846 byte_swap_32 (salt
.salt_buf
[0]),
7847 byte_swap_32 (salt
.salt_buf
[1]),
7848 byte_swap_32 (salt
.salt_buf
[2]),
7849 byte_swap_32 (salt
.salt_buf
[3]));
7851 else if (hash_mode
== 10200)
7853 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7855 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7859 char challenge
[100] = { 0 };
7861 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7865 char tmp_buf
[100] = { 0 };
7867 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7868 (char *) cram_md5
->user
,
7874 char response
[100] = { 0 };
7876 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7878 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7880 else if (hash_mode
== 10300)
7882 char tmp_buf
[100] = { 0 };
7884 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7885 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7887 uint tmp_len
= 20 + salt
.salt_len
;
7891 char base64_encoded
[100] = { 0 };
7893 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7895 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7897 else if (hash_mode
== 10400)
7899 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7901 pdf_t
*pdf
= &pdfs
[salt_pos
];
7903 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",
7911 byte_swap_32 (pdf
->id_buf
[0]),
7912 byte_swap_32 (pdf
->id_buf
[1]),
7913 byte_swap_32 (pdf
->id_buf
[2]),
7914 byte_swap_32 (pdf
->id_buf
[3]),
7916 byte_swap_32 (pdf
->u_buf
[0]),
7917 byte_swap_32 (pdf
->u_buf
[1]),
7918 byte_swap_32 (pdf
->u_buf
[2]),
7919 byte_swap_32 (pdf
->u_buf
[3]),
7920 byte_swap_32 (pdf
->u_buf
[4]),
7921 byte_swap_32 (pdf
->u_buf
[5]),
7922 byte_swap_32 (pdf
->u_buf
[6]),
7923 byte_swap_32 (pdf
->u_buf
[7]),
7925 byte_swap_32 (pdf
->o_buf
[0]),
7926 byte_swap_32 (pdf
->o_buf
[1]),
7927 byte_swap_32 (pdf
->o_buf
[2]),
7928 byte_swap_32 (pdf
->o_buf
[3]),
7929 byte_swap_32 (pdf
->o_buf
[4]),
7930 byte_swap_32 (pdf
->o_buf
[5]),
7931 byte_swap_32 (pdf
->o_buf
[6]),
7932 byte_swap_32 (pdf
->o_buf
[7])
7935 else if (hash_mode
== 10410)
7937 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7939 pdf_t
*pdf
= &pdfs
[salt_pos
];
7941 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",
7949 byte_swap_32 (pdf
->id_buf
[0]),
7950 byte_swap_32 (pdf
->id_buf
[1]),
7951 byte_swap_32 (pdf
->id_buf
[2]),
7952 byte_swap_32 (pdf
->id_buf
[3]),
7954 byte_swap_32 (pdf
->u_buf
[0]),
7955 byte_swap_32 (pdf
->u_buf
[1]),
7956 byte_swap_32 (pdf
->u_buf
[2]),
7957 byte_swap_32 (pdf
->u_buf
[3]),
7958 byte_swap_32 (pdf
->u_buf
[4]),
7959 byte_swap_32 (pdf
->u_buf
[5]),
7960 byte_swap_32 (pdf
->u_buf
[6]),
7961 byte_swap_32 (pdf
->u_buf
[7]),
7963 byte_swap_32 (pdf
->o_buf
[0]),
7964 byte_swap_32 (pdf
->o_buf
[1]),
7965 byte_swap_32 (pdf
->o_buf
[2]),
7966 byte_swap_32 (pdf
->o_buf
[3]),
7967 byte_swap_32 (pdf
->o_buf
[4]),
7968 byte_swap_32 (pdf
->o_buf
[5]),
7969 byte_swap_32 (pdf
->o_buf
[6]),
7970 byte_swap_32 (pdf
->o_buf
[7])
7973 else if (hash_mode
== 10420)
7975 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7977 pdf_t
*pdf
= &pdfs
[salt_pos
];
7979 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7981 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",
7989 byte_swap_32 (pdf
->id_buf
[0]),
7990 byte_swap_32 (pdf
->id_buf
[1]),
7991 byte_swap_32 (pdf
->id_buf
[2]),
7992 byte_swap_32 (pdf
->id_buf
[3]),
7994 byte_swap_32 (pdf
->u_buf
[0]),
7995 byte_swap_32 (pdf
->u_buf
[1]),
7996 byte_swap_32 (pdf
->u_buf
[2]),
7997 byte_swap_32 (pdf
->u_buf
[3]),
7998 byte_swap_32 (pdf
->u_buf
[4]),
7999 byte_swap_32 (pdf
->u_buf
[5]),
8000 byte_swap_32 (pdf
->u_buf
[6]),
8001 byte_swap_32 (pdf
->u_buf
[7]),
8003 byte_swap_32 (pdf
->o_buf
[0]),
8004 byte_swap_32 (pdf
->o_buf
[1]),
8005 byte_swap_32 (pdf
->o_buf
[2]),
8006 byte_swap_32 (pdf
->o_buf
[3]),
8007 byte_swap_32 (pdf
->o_buf
[4]),
8008 byte_swap_32 (pdf
->o_buf
[5]),
8009 byte_swap_32 (pdf
->o_buf
[6]),
8010 byte_swap_32 (pdf
->o_buf
[7]),
8018 else if (hash_mode
== 10500)
8020 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8022 pdf_t
*pdf
= &pdfs
[salt_pos
];
8024 if (pdf
->id_len
== 32)
8026 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",
8034 byte_swap_32 (pdf
->id_buf
[0]),
8035 byte_swap_32 (pdf
->id_buf
[1]),
8036 byte_swap_32 (pdf
->id_buf
[2]),
8037 byte_swap_32 (pdf
->id_buf
[3]),
8038 byte_swap_32 (pdf
->id_buf
[4]),
8039 byte_swap_32 (pdf
->id_buf
[5]),
8040 byte_swap_32 (pdf
->id_buf
[6]),
8041 byte_swap_32 (pdf
->id_buf
[7]),
8043 byte_swap_32 (pdf
->u_buf
[0]),
8044 byte_swap_32 (pdf
->u_buf
[1]),
8045 byte_swap_32 (pdf
->u_buf
[2]),
8046 byte_swap_32 (pdf
->u_buf
[3]),
8047 byte_swap_32 (pdf
->u_buf
[4]),
8048 byte_swap_32 (pdf
->u_buf
[5]),
8049 byte_swap_32 (pdf
->u_buf
[6]),
8050 byte_swap_32 (pdf
->u_buf
[7]),
8052 byte_swap_32 (pdf
->o_buf
[0]),
8053 byte_swap_32 (pdf
->o_buf
[1]),
8054 byte_swap_32 (pdf
->o_buf
[2]),
8055 byte_swap_32 (pdf
->o_buf
[3]),
8056 byte_swap_32 (pdf
->o_buf
[4]),
8057 byte_swap_32 (pdf
->o_buf
[5]),
8058 byte_swap_32 (pdf
->o_buf
[6]),
8059 byte_swap_32 (pdf
->o_buf
[7])
8064 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",
8072 byte_swap_32 (pdf
->id_buf
[0]),
8073 byte_swap_32 (pdf
->id_buf
[1]),
8074 byte_swap_32 (pdf
->id_buf
[2]),
8075 byte_swap_32 (pdf
->id_buf
[3]),
8077 byte_swap_32 (pdf
->u_buf
[0]),
8078 byte_swap_32 (pdf
->u_buf
[1]),
8079 byte_swap_32 (pdf
->u_buf
[2]),
8080 byte_swap_32 (pdf
->u_buf
[3]),
8081 byte_swap_32 (pdf
->u_buf
[4]),
8082 byte_swap_32 (pdf
->u_buf
[5]),
8083 byte_swap_32 (pdf
->u_buf
[6]),
8084 byte_swap_32 (pdf
->u_buf
[7]),
8086 byte_swap_32 (pdf
->o_buf
[0]),
8087 byte_swap_32 (pdf
->o_buf
[1]),
8088 byte_swap_32 (pdf
->o_buf
[2]),
8089 byte_swap_32 (pdf
->o_buf
[3]),
8090 byte_swap_32 (pdf
->o_buf
[4]),
8091 byte_swap_32 (pdf
->o_buf
[5]),
8092 byte_swap_32 (pdf
->o_buf
[6]),
8093 byte_swap_32 (pdf
->o_buf
[7])
8097 else if (hash_mode
== 10600)
8099 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8101 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8102 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8104 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8106 else if (hash_mode
== 10700)
8108 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8110 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8111 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8113 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8115 else if (hash_mode
== 10900)
8117 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8119 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8120 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8122 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8124 else if (hash_mode
== 11100)
8126 u32 salt_challenge
= salt
.salt_buf
[0];
8128 salt_challenge
= byte_swap_32 (salt_challenge
);
8130 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
8132 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
8133 SIGNATURE_POSTGRESQL_AUTH
,
8141 else if (hash_mode
== 11200)
8143 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
8144 SIGNATURE_MYSQL_AUTH
,
8145 (unsigned char *) salt
.salt_buf
,
8152 else if (hash_mode
== 11300)
8154 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
8156 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
8158 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
8159 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
8160 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
8162 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
8163 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
8164 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
8166 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
8168 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
8170 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
8173 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
8175 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
8177 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8180 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8182 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8184 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8187 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8188 SIGNATURE_BITCOIN_WALLET
,
8192 (unsigned char *) salt
.salt_buf
,
8200 free (cry_master_buf
);
8202 free (public_key_buf
);
8204 else if (hash_mode
== 11400)
8206 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8208 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8209 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8211 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8213 else if (hash_mode
== 11600)
8215 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8217 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8219 const uint data_len
= seven_zip
->data_len
;
8221 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8223 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8225 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8227 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8230 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8231 SIGNATURE_SEVEN_ZIP
,
8235 (char *) seven_zip
->salt_buf
,
8237 seven_zip
->iv_buf
[0],
8238 seven_zip
->iv_buf
[1],
8239 seven_zip
->iv_buf
[2],
8240 seven_zip
->iv_buf
[3],
8242 seven_zip
->data_len
,
8243 seven_zip
->unpack_size
,
8248 else if (hash_mode
== 11700)
8250 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8260 else if (hash_mode
== 11800)
8262 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8280 else if (hash_mode
== 11900)
8282 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8284 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8285 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8287 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8289 else if (hash_mode
== 12000)
8291 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8293 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8294 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8296 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8298 else if (hash_mode
== 12100)
8300 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8302 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8303 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8305 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8307 else if (hash_mode
== 12200)
8309 uint
*ptr_digest
= digest_buf
;
8310 uint
*ptr_salt
= salt
.salt_buf
;
8312 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8319 else if (hash_mode
== 12300)
8321 uint
*ptr_digest
= digest_buf
;
8322 uint
*ptr_salt
= salt
.salt_buf
;
8324 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",
8325 ptr_digest
[ 0], ptr_digest
[ 1],
8326 ptr_digest
[ 2], ptr_digest
[ 3],
8327 ptr_digest
[ 4], ptr_digest
[ 5],
8328 ptr_digest
[ 6], ptr_digest
[ 7],
8329 ptr_digest
[ 8], ptr_digest
[ 9],
8330 ptr_digest
[10], ptr_digest
[11],
8331 ptr_digest
[12], ptr_digest
[13],
8332 ptr_digest
[14], ptr_digest
[15],
8338 else if (hash_mode
== 12400)
8340 // encode iteration count
8342 char salt_iter
[5] = { 0 };
8344 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8345 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8346 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8347 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8352 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8353 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8354 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8355 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8360 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8362 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8363 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8365 memcpy (tmp_buf
, digest_buf
, 8);
8367 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8371 // fill the resulting buffer
8373 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8375 else if (hash_mode
== 12500)
8377 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8379 byte_swap_32 (salt
.salt_buf
[0]),
8380 byte_swap_32 (salt
.salt_buf
[1]),
8386 else if (hash_mode
== 12600)
8388 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8389 digest_buf
[0] + salt
.salt_buf_pc
[0],
8390 digest_buf
[1] + salt
.salt_buf_pc
[1],
8391 digest_buf
[2] + salt
.salt_buf_pc
[2],
8392 digest_buf
[3] + salt
.salt_buf_pc
[3],
8393 digest_buf
[4] + salt
.salt_buf_pc
[4],
8394 digest_buf
[5] + salt
.salt_buf_pc
[5],
8395 digest_buf
[6] + salt
.salt_buf_pc
[6],
8396 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8398 else if (hash_mode
== 12700)
8400 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8402 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8403 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8405 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8407 else if (hash_mode
== 12800)
8409 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8411 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",
8424 byte_swap_32 (digest_buf
[0]),
8425 byte_swap_32 (digest_buf
[1]),
8426 byte_swap_32 (digest_buf
[2]),
8427 byte_swap_32 (digest_buf
[3]),
8428 byte_swap_32 (digest_buf
[4]),
8429 byte_swap_32 (digest_buf
[5]),
8430 byte_swap_32 (digest_buf
[6]),
8431 byte_swap_32 (digest_buf
[7])
8434 else if (hash_mode
== 12900)
8436 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",
8445 byte_swap_32 (digest_buf
[0]),
8446 byte_swap_32 (digest_buf
[1]),
8447 byte_swap_32 (digest_buf
[2]),
8448 byte_swap_32 (digest_buf
[3]),
8449 byte_swap_32 (digest_buf
[4]),
8450 byte_swap_32 (digest_buf
[5]),
8451 byte_swap_32 (digest_buf
[6]),
8452 byte_swap_32 (digest_buf
[7]),
8459 else if (hash_mode
== 13000)
8461 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8463 rar5_t
*rar5
= &rar5s
[salt_pos
];
8465 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8475 byte_swap_32 (digest_buf
[0]),
8476 byte_swap_32 (digest_buf
[1])
8479 else if (hash_mode
== 13100)
8481 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8483 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8485 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8486 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8488 char data
[2560 * 4 * 2] = { 0 };
8490 char *ptr_data
= data
;
8492 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8493 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8498 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8499 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8501 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8503 (char *) krb5tgs
->account_info
,
8507 else if (hash_mode
== 13200)
8509 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8523 else if (hash_mode
== 13300)
8525 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8526 SIGNATURE_AXCRYPT_SHA1
,
8532 else if (hash_mode
== 13400)
8534 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8536 keepass_t
*keepass
= &keepasss
[salt_pos
];
8538 u32 version
= (u32
) keepass
->version
;
8539 u32 rounds
= salt
.salt_iter
;
8540 u32 algorithm
= (u32
) keepass
->algorithm
;
8541 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8543 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8544 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8545 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8546 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8547 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8549 /* specific to version 1 */
8553 /* specific to version 2 */
8554 u32 expected_bytes_len
;
8555 u32
*ptr_expected_bytes
;
8557 u32 final_random_seed_len
;
8558 u32 transf_random_seed_len
;
8560 u32 contents_hash_len
;
8562 transf_random_seed_len
= 8;
8564 contents_hash_len
= 8;
8565 final_random_seed_len
= 8;
8568 final_random_seed_len
= 4;
8570 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8576 char *ptr_data
= out_buf
;
8578 ptr_data
+= strlen(out_buf
);
8583 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8584 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8589 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8590 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8595 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8596 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8603 contents_len
= (u32
) keepass
->contents_len
;
8604 ptr_contents
= (u32
*) keepass
->contents
;
8606 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8607 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8619 char ptr_contents_len
[10] = { 0 };
8621 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8623 sprintf (ptr_data
, "%d", contents_len
);
8625 ptr_data
+= strlen(ptr_contents_len
);
8630 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8631 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8633 else if (version
== 2)
8635 expected_bytes_len
= 8;
8636 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8638 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8639 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8644 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8645 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8659 sprintf (ptr_data
, "%d", keyfile_len
);
8666 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8667 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8670 else if (hash_mode
== 13500)
8672 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8674 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8676 const u32 salt_len
= (pstoken
->salt_len
> 512) ? 512 : pstoken
->salt_len
;
8678 char pstoken_tmp
[1024 + 1] = { 0 };
8680 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8682 const u8
*ptr
= (const u8
*) pstoken
->salt_buf
;
8684 sprintf (pstoken_tmp
+ j
, "%02x", ptr
[i
]);
8687 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8695 else if (hash_mode
== 13600)
8697 zip2_t
*zip2s
= (zip2_t
*) data
.esalts_buf
;
8699 zip2_t
*zip2
= &zip2s
[salt_pos
];
8701 const u32 salt_len
= zip2
->salt_len
;
8703 char salt_tmp
[32 + 1] = { 0 };
8705 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8707 const u8
*ptr
= (const u8
*) zip2
->salt_buf
;
8709 sprintf (salt_tmp
+ j
, "%02x", ptr
[i
]);
8712 const u32 data_len
= zip2
->data_len
;
8714 char data_tmp
[8192 + 1] = { 0 };
8716 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8718 const u8
*ptr
= (const u8
*) zip2
->data_buf
;
8720 sprintf (data_tmp
+ j
, "%02x", ptr
[i
]);
8723 const u32 auth_len
= zip2
->auth_len
;
8725 char auth_tmp
[20 + 1] = { 0 };
8727 for (uint i
= 0, j
= 0; i
< auth_len
; i
+= 1, j
+= 2)
8729 const u8
*ptr
= (const u8
*) zip2
->auth_buf
;
8731 sprintf (auth_tmp
+ j
, "%02x", ptr
[i
]);
8734 snprintf (out_buf
, 255, "%s*%u*%u*%u*%s*%x*%u*%s*%s*%s",
8735 SIGNATURE_ZIP2_START
,
8741 zip2
->compress_length
,
8744 SIGNATURE_ZIP2_STOP
);
8746 else if ((hash_mode
>= 13700) && (hash_mode
<= 13799))
8748 snprintf (out_buf
, len
-1, "%s", hashfile
);
8750 else if (hash_mode
== 13800)
8752 win8phone_t
*esalts
= (win8phone_t
*) data
.esalts_buf
;
8754 win8phone_t
*esalt
= &esalts
[salt_pos
];
8756 char buf
[256 + 1] = { 0 };
8758 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
8760 sprintf (buf
+ j
, "%08x", esalt
->salt_buf
[i
]);
8763 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%s",
8776 if (hash_type
== HASH_TYPE_MD4
)
8778 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8784 else if (hash_type
== HASH_TYPE_MD5
)
8786 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8792 else if (hash_type
== HASH_TYPE_SHA1
)
8794 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8801 else if (hash_type
== HASH_TYPE_SHA256
)
8803 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8813 else if (hash_type
== HASH_TYPE_SHA384
)
8815 uint
*ptr
= digest_buf
;
8817 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8825 else if (hash_type
== HASH_TYPE_SHA512
)
8827 uint
*ptr
= digest_buf
;
8829 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8839 else if (hash_type
== HASH_TYPE_LM
)
8841 snprintf (out_buf
, len
-1, "%08x%08x",
8845 else if (hash_type
== HASH_TYPE_ORACLEH
)
8847 snprintf (out_buf
, len
-1, "%08X%08X",
8851 else if (hash_type
== HASH_TYPE_BCRYPT
)
8853 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8854 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8856 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8858 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8860 else if (hash_type
== HASH_TYPE_KECCAK
)
8862 uint
*ptr
= digest_buf
;
8864 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",
8892 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8894 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8896 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8903 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8905 digest_buf
[ 0] = digest_buf
[ 0];
8906 digest_buf
[ 1] = digest_buf
[ 1];
8907 digest_buf
[ 2] = digest_buf
[ 2];
8908 digest_buf
[ 3] = digest_buf
[ 3];
8909 digest_buf
[ 4] = digest_buf
[ 4];
8910 digest_buf
[ 5] = digest_buf
[ 5];
8911 digest_buf
[ 6] = digest_buf
[ 6];
8912 digest_buf
[ 7] = digest_buf
[ 7];
8913 digest_buf
[ 8] = digest_buf
[ 8];
8914 digest_buf
[ 9] = digest_buf
[ 9];
8915 digest_buf
[10] = digest_buf
[10];
8916 digest_buf
[11] = digest_buf
[11];
8917 digest_buf
[12] = digest_buf
[12];
8918 digest_buf
[13] = digest_buf
[13];
8919 digest_buf
[14] = digest_buf
[14];
8920 digest_buf
[15] = digest_buf
[15];
8922 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8940 else if (hash_type
== HASH_TYPE_GOST
)
8942 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8952 else if (hash_type
== HASH_TYPE_MYSQL
)
8954 snprintf (out_buf
, len
-1, "%08x%08x",
8958 else if (hash_type
== HASH_TYPE_LOTUS5
)
8960 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8966 else if (hash_type
== HASH_TYPE_LOTUS6
)
8968 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8969 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8970 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8971 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8973 char buf
[16] = { 0 };
8975 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8976 memcpy (buf
+ 5, digest_buf
, 9);
8980 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8982 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8985 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8987 else if (hash_type
== HASH_TYPE_LOTUS8
)
8989 char buf
[52] = { 0 };
8993 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8999 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
9003 buf
[26] = salt
.salt_buf_pc
[0];
9004 buf
[27] = salt
.salt_buf_pc
[1];
9008 memcpy (buf
+ 28, digest_buf
, 8);
9010 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
9014 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
9016 else if (hash_type
== HASH_TYPE_CRC32
)
9018 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
9022 if (salt_type
== SALT_TYPE_INTERN
)
9024 size_t pos
= strlen (out_buf
);
9026 out_buf
[pos
] = data
.separator
;
9028 char *ptr
= (char *) salt
.salt_buf
;
9030 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
9032 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
9036 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
9038 memset (hccap
, 0, sizeof (hccap_t
));
9040 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
9042 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
9044 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
9045 wpa_t
*wpa
= &wpas
[salt_pos
];
9047 hccap
->keyver
= wpa
->keyver
;
9049 hccap
->eapol_size
= wpa
->eapol_size
;
9051 if (wpa
->keyver
!= 1)
9053 uint eapol_tmp
[64] = { 0 };
9055 for (uint i
= 0; i
< 64; i
++)
9057 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9060 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
9064 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
9067 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
9068 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
9069 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
9070 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
9072 char *digests_buf_ptr
= (char *) data
.digests_buf
;
9074 uint dgst_size
= data
.dgst_size
;
9076 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
9078 if (wpa
->keyver
!= 1)
9080 uint digest_tmp
[4] = { 0 };
9082 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
9083 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
9084 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
9085 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
9087 memcpy (hccap
->keymic
, digest_tmp
, 16);
9091 memcpy (hccap
->keymic
, digest_ptr
, 16);
9095 void SuspendThreads ()
9097 if (data
.devices_status
== STATUS_RUNNING
)
9099 hc_timer_set (&data
.timer_paused
);
9101 data
.devices_status
= STATUS_PAUSED
;
9103 log_info ("Paused");
9107 void ResumeThreads ()
9109 if (data
.devices_status
== STATUS_PAUSED
)
9113 hc_timer_get (data
.timer_paused
, ms_paused
);
9115 data
.ms_paused
+= ms_paused
;
9117 data
.devices_status
= STATUS_RUNNING
;
9119 log_info ("Resumed");
9125 if (data
.devices_status
!= STATUS_RUNNING
) return;
9127 data
.devices_status
= STATUS_BYPASS
;
9129 log_info ("Next dictionary / mask in queue selected, bypassing current one");
9132 void stop_at_checkpoint ()
9134 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9136 if (data
.devices_status
!= STATUS_RUNNING
) return;
9139 // this feature only makes sense if --restore-disable was not specified
9141 if (data
.restore_disable
== 1)
9143 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
9148 // check if monitoring of Restore Point updates should be enabled or disabled
9150 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9152 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
9154 // save the current restore point value
9156 data
.checkpoint_cur_words
= get_lowest_words_done ();
9158 log_info ("Checkpoint enabled: will quit at next Restore Point update");
9162 data
.devices_status
= STATUS_RUNNING
;
9164 // reset the global value for checkpoint checks
9166 data
.checkpoint_cur_words
= 0;
9168 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
9174 if (data
.devices_status
== STATUS_INIT
) return;
9175 if (data
.devices_status
== STATUS_STARTING
) return;
9177 data
.devices_status
= STATUS_ABORTED
;
9182 if (data
.devices_status
== STATUS_INIT
) return;
9183 if (data
.devices_status
== STATUS_STARTING
) return;
9185 data
.devices_status
= STATUS_QUIT
;
9188 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
9190 FILE *fp
= fopen (kernel_file
, "rb");
9196 memset (&st
, 0, sizeof (st
));
9198 stat (kernel_file
, &st
);
9200 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
9202 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
9204 if (num_read
!= (size_t) st
.st_size
)
9206 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9213 buf
[st
.st_size
] = 0;
9215 for (int i
= 0; i
< num_devices
; i
++)
9217 kernel_lengths
[i
] = (size_t) st
.st_size
;
9219 kernel_sources
[i
] = buf
;
9224 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9232 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
9234 if (binary_size
> 0)
9236 FILE *fp
= fopen (dst
, "wb");
9239 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
9250 restore_data_t
*init_restore (int argc
, char **argv
)
9252 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
9254 if (data
.restore_disable
== 0)
9256 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
9260 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
9264 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
9273 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9275 int pidbin_len
= -1;
9278 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9280 FILE *fd
= fopen (pidbin
, "rb");
9284 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9286 pidbin
[pidbin_len
] = 0;
9290 char *argv0_r
= strrchr (argv
[0], '/');
9292 char *pidbin_r
= strrchr (pidbin
, '/');
9294 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9296 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9298 if (strcmp (argv0_r
, pidbin_r
) == 0)
9300 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
9307 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9309 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9311 int pidbin2_len
= -1;
9313 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9314 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9316 pidbin
[pidbin_len
] = 0;
9317 pidbin2
[pidbin2_len
] = 0;
9321 if (strcmp (pidbin
, pidbin2
) == 0)
9323 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9336 if (rd
->version_bin
< RESTORE_MIN
)
9338 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9345 memset (rd
, 0, sizeof (restore_data_t
));
9347 rd
->version_bin
= VERSION_BIN
;
9350 rd
->pid
= getpid ();
9352 rd
->pid
= GetCurrentProcessId ();
9355 if (getcwd (rd
->cwd
, 255) == NULL
)
9368 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9370 FILE *fp
= fopen (eff_restore_file
, "rb");
9374 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
9379 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9381 log_error ("ERROR: cannot read %s", eff_restore_file
);
9386 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9388 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9390 for (uint i
= 0; i
< rd
->argc
; i
++)
9392 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9394 log_error ("ERROR: cannot read %s", eff_restore_file
);
9399 size_t len
= strlen (buf
);
9401 if (len
) buf
[len
- 1] = 0;
9403 rd
->argv
[i
] = mystrdup (buf
);
9410 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9412 if (chdir (rd
->cwd
))
9414 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9415 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9416 " https://github.com/philsmd/analyze_hc_restore\n"
9417 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9423 u64
get_lowest_words_done ()
9427 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9429 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9431 if (device_param
->skipped
) continue;
9433 const u64 words_done
= device_param
->words_done
;
9435 if (words_done
< words_cur
) words_cur
= words_done
;
9438 // It's possible that a device's workload isn't finished right after a restore-case.
9439 // In that case, this function would return 0 and overwrite the real restore point
9440 // There's also data.words_cur which is set to rd->words_cur but it changes while
9441 // the attack is running therefore we should stick to rd->words_cur.
9442 // Note that -s influences rd->words_cur we should keep a close look on that.
9444 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9449 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9451 u64 words_cur
= get_lowest_words_done ();
9453 rd
->words_cur
= words_cur
;
9455 FILE *fp
= fopen (new_restore_file
, "wb");
9459 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9464 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9466 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9471 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9473 for (uint i
= 0; i
< rd
->argc
; i
++)
9475 fprintf (fp
, "%s", rd
->argv
[i
]);
9481 fsync (fileno (fp
));
9486 void cycle_restore ()
9488 const char *eff_restore_file
= data
.eff_restore_file
;
9489 const char *new_restore_file
= data
.new_restore_file
;
9491 restore_data_t
*rd
= data
.rd
;
9493 write_restore (new_restore_file
, rd
);
9497 memset (&st
, 0, sizeof(st
));
9499 if (stat (eff_restore_file
, &st
) == 0)
9501 if (unlink (eff_restore_file
))
9503 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9507 if (rename (new_restore_file
, eff_restore_file
))
9509 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9513 void check_checkpoint ()
9515 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9517 u64 words_cur
= get_lowest_words_done ();
9519 if (words_cur
!= data
.checkpoint_cur_words
)
9529 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9533 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9535 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9537 myfree (alias
->device_name
);
9538 myfree (alias
->alias_name
);
9541 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9543 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9545 myfree (entry
->device_name
);
9548 myfree (tuning_db
->alias_buf
);
9549 myfree (tuning_db
->entry_buf
);
9554 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9556 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9558 int num_lines
= count_lines (fp
);
9560 // a bit over-allocated
9562 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9563 tuning_db
->alias_cnt
= 0;
9565 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9566 tuning_db
->entry_cnt
= 0;
9571 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9573 FILE *fp
= fopen (tuning_db_file
, "rb");
9577 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9582 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9588 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9592 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9594 if (line_buf
== NULL
) break;
9598 const int line_len
= in_superchop (line_buf
);
9600 if (line_len
== 0) continue;
9602 if (line_buf
[0] == '#') continue;
9606 char *token_ptr
[7] = { NULL
};
9610 char *next
= strtok (line_buf
, "\t ");
9612 token_ptr
[token_cnt
] = next
;
9616 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9618 token_ptr
[token_cnt
] = next
;
9625 char *device_name
= token_ptr
[0];
9626 char *alias_name
= token_ptr
[1];
9628 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9630 alias
->device_name
= mystrdup (device_name
);
9631 alias
->alias_name
= mystrdup (alias_name
);
9633 tuning_db
->alias_cnt
++;
9635 else if (token_cnt
== 6)
9637 if ((token_ptr
[1][0] != '0') &&
9638 (token_ptr
[1][0] != '1') &&
9639 (token_ptr
[1][0] != '3') &&
9640 (token_ptr
[1][0] != '*'))
9642 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9647 if ((token_ptr
[3][0] != '1') &&
9648 (token_ptr
[3][0] != '2') &&
9649 (token_ptr
[3][0] != '4') &&
9650 (token_ptr
[3][0] != '8') &&
9651 (token_ptr
[3][0] != 'N'))
9653 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9658 char *device_name
= token_ptr
[0];
9660 int attack_mode
= -1;
9662 int vector_width
= -1;
9663 int kernel_accel
= -1;
9664 int kernel_loops
= -1;
9666 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9667 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9668 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9670 if (token_ptr
[4][0] != 'A')
9672 kernel_accel
= atoi (token_ptr
[4]);
9674 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9676 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9686 if (token_ptr
[5][0] != 'A')
9688 kernel_loops
= atoi (token_ptr
[5]);
9690 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9692 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9702 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9704 entry
->device_name
= mystrdup (device_name
);
9705 entry
->attack_mode
= attack_mode
;
9706 entry
->hash_type
= hash_type
;
9707 entry
->vector_width
= vector_width
;
9708 entry
->kernel_accel
= kernel_accel
;
9709 entry
->kernel_loops
= kernel_loops
;
9711 tuning_db
->entry_cnt
++;
9715 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9725 // todo: print loaded 'cnt' message
9727 // sort the database
9729 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9730 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9735 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9737 static tuning_db_entry_t s
;
9739 // first we need to convert all spaces in the device_name to underscore
9741 char *device_name_nospace
= strdup (device_param
->device_name
);
9743 int device_name_length
= strlen (device_name_nospace
);
9747 for (i
= 0; i
< device_name_length
; i
++)
9749 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9752 // find out if there's an alias configured
9754 tuning_db_alias_t a
;
9756 a
.device_name
= device_name_nospace
;
9758 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
);
9760 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9762 // attack-mode 6 and 7 are attack-mode 1 basically
9764 if (attack_mode
== 6) attack_mode
= 1;
9765 if (attack_mode
== 7) attack_mode
= 1;
9767 // bsearch is not ideal but fast enough
9769 s
.device_name
= device_name_nospace
;
9770 s
.attack_mode
= attack_mode
;
9771 s
.hash_type
= hash_type
;
9773 tuning_db_entry_t
*entry
= NULL
;
9775 // this will produce all 2^3 combinations required
9777 for (i
= 0; i
< 8; i
++)
9779 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9780 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9781 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9783 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9785 if (entry
!= NULL
) break;
9787 // in non-wildcard mode do some additional checks:
9791 // in case we have an alias-name
9793 if (alias_name
!= NULL
)
9795 s
.device_name
= alias_name
;
9797 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9799 if (entry
!= NULL
) break;
9802 // or by device type
9804 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9806 s
.device_name
= "DEVICE_TYPE_CPU";
9808 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9810 s
.device_name
= "DEVICE_TYPE_GPU";
9812 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9814 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9817 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9819 if (entry
!= NULL
) break;
9823 // free converted device_name
9825 myfree (device_name_nospace
);
9834 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9836 u8 tmp
[256] = { 0 };
9838 if (salt_len
> sizeof (tmp
))
9843 memcpy (tmp
, in
, salt_len
);
9845 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9847 if ((salt_len
% 2) == 0)
9849 u32 new_salt_len
= salt_len
/ 2;
9851 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9856 tmp
[i
] = hex_convert (p1
) << 0;
9857 tmp
[i
] |= hex_convert (p0
) << 4;
9860 salt_len
= new_salt_len
;
9867 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9869 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9872 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9874 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9878 u32
*tmp_uint
= (u32
*) tmp
;
9880 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9881 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9882 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9883 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9884 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9885 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9886 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9887 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9888 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9889 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9891 salt_len
= salt_len
* 2;
9899 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9901 lowercase (tmp
, salt_len
);
9904 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9906 uppercase (tmp
, salt_len
);
9911 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9916 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9921 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9923 u32
*tmp_uint
= (uint
*) tmp
;
9929 for (u32 i
= 0; i
< max
; i
++)
9931 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9934 // Important: we may need to increase the length of memcpy since
9935 // we don't want to "loose" some swapped bytes (could happen if
9936 // they do not perfectly fit in the 4-byte blocks)
9937 // Memcpy does always copy the bytes in the BE order, but since
9938 // we swapped them, some important bytes could be in positions
9939 // we normally skip with the original len
9941 if (len
% 4) len
+= 4 - (len
% 4);
9944 memcpy (out
, tmp
, len
);
9949 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9951 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9953 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9955 u32
*digest
= (u32
*) hash_buf
->digest
;
9957 salt_t
*salt
= hash_buf
->salt
;
9959 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9961 char *iter_pos
= input_buf
+ 4;
9963 salt
->salt_iter
= 1 << atoi (iter_pos
);
9965 char *salt_pos
= strchr (iter_pos
, '$');
9967 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9973 salt
->salt_len
= salt_len
;
9975 u8 tmp_buf
[100] = { 0 };
9977 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9979 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9981 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9983 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9984 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9985 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9986 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9988 char *hash_pos
= salt_pos
+ 22;
9990 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9992 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9994 memcpy (digest
, tmp_buf
, 24);
9996 digest
[0] = byte_swap_32 (digest
[0]);
9997 digest
[1] = byte_swap_32 (digest
[1]);
9998 digest
[2] = byte_swap_32 (digest
[2]);
9999 digest
[3] = byte_swap_32 (digest
[3]);
10000 digest
[4] = byte_swap_32 (digest
[4]);
10001 digest
[5] = byte_swap_32 (digest
[5]);
10003 digest
[5] &= ~0xff; // its just 23 not 24 !
10005 return (PARSER_OK
);
10008 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10010 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
10012 u32
*digest
= (u32
*) hash_buf
->digest
;
10014 u8 tmp_buf
[100] = { 0 };
10016 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
10018 memcpy (digest
, tmp_buf
, 32);
10020 digest
[0] = byte_swap_32 (digest
[0]);
10021 digest
[1] = byte_swap_32 (digest
[1]);
10022 digest
[2] = byte_swap_32 (digest
[2]);
10023 digest
[3] = byte_swap_32 (digest
[3]);
10024 digest
[4] = byte_swap_32 (digest
[4]);
10025 digest
[5] = byte_swap_32 (digest
[5]);
10026 digest
[6] = byte_swap_32 (digest
[6]);
10027 digest
[7] = byte_swap_32 (digest
[7]);
10029 digest
[0] -= SHA256M_A
;
10030 digest
[1] -= SHA256M_B
;
10031 digest
[2] -= SHA256M_C
;
10032 digest
[3] -= SHA256M_D
;
10033 digest
[4] -= SHA256M_E
;
10034 digest
[5] -= SHA256M_F
;
10035 digest
[6] -= SHA256M_G
;
10036 digest
[7] -= SHA256M_H
;
10038 return (PARSER_OK
);
10041 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10043 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
10045 u32
*digest
= (u32
*) hash_buf
->digest
;
10047 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10048 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10050 digest
[0] = byte_swap_32 (digest
[0]);
10051 digest
[1] = byte_swap_32 (digest
[1]);
10055 IP (digest
[0], digest
[1], tt
);
10057 digest
[0] = digest
[0];
10058 digest
[1] = digest
[1];
10062 return (PARSER_OK
);
10065 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10067 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
10069 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
10071 u32
*digest
= (u32
*) hash_buf
->digest
;
10073 salt_t
*salt
= hash_buf
->salt
;
10075 char *hash_pos
= input_buf
+ 10;
10077 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10078 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10079 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10080 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10081 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10083 digest
[0] -= SHA1M_A
;
10084 digest
[1] -= SHA1M_B
;
10085 digest
[2] -= SHA1M_C
;
10086 digest
[3] -= SHA1M_D
;
10087 digest
[4] -= SHA1M_E
;
10089 uint salt_len
= 10;
10091 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10093 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10095 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10097 salt
->salt_len
= salt_len
;
10099 return (PARSER_OK
);
10102 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10104 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
10106 u32
*digest
= (u32
*) hash_buf
->digest
;
10108 salt_t
*salt
= hash_buf
->salt
;
10110 char *hash_pos
= input_buf
+ 8;
10112 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10113 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10114 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10115 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10116 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10118 digest
[0] -= SHA1M_A
;
10119 digest
[1] -= SHA1M_B
;
10120 digest
[2] -= SHA1M_C
;
10121 digest
[3] -= SHA1M_D
;
10122 digest
[4] -= SHA1M_E
;
10126 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10128 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10130 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10132 salt
->salt_len
= salt_len
;
10134 return (PARSER_OK
);
10137 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10139 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
10141 u64
*digest
= (u64
*) hash_buf
->digest
;
10143 salt_t
*salt
= hash_buf
->salt
;
10145 char *hash_pos
= input_buf
+ 8;
10147 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
10148 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
10149 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
10150 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
10151 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
10152 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
10153 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
10154 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
10156 digest
[0] -= SHA512M_A
;
10157 digest
[1] -= SHA512M_B
;
10158 digest
[2] -= SHA512M_C
;
10159 digest
[3] -= SHA512M_D
;
10160 digest
[4] -= SHA512M_E
;
10161 digest
[5] -= SHA512M_F
;
10162 digest
[6] -= SHA512M_G
;
10163 digest
[7] -= SHA512M_H
;
10167 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10169 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10171 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10173 salt
->salt_len
= salt_len
;
10175 return (PARSER_OK
);
10178 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10180 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10182 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
10186 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
10189 u32
*digest
= (u32
*) hash_buf
->digest
;
10191 salt_t
*salt
= hash_buf
->salt
;
10193 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10194 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10195 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10196 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10198 digest
[0] = byte_swap_32 (digest
[0]);
10199 digest
[1] = byte_swap_32 (digest
[1]);
10200 digest
[2] = byte_swap_32 (digest
[2]);
10201 digest
[3] = byte_swap_32 (digest
[3]);
10203 digest
[0] -= MD5M_A
;
10204 digest
[1] -= MD5M_B
;
10205 digest
[2] -= MD5M_C
;
10206 digest
[3] -= MD5M_D
;
10208 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10210 uint salt_len
= input_len
- 32 - 1;
10212 char *salt_buf
= input_buf
+ 32 + 1;
10214 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10216 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10218 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10220 salt
->salt_len
= salt_len
;
10222 return (PARSER_OK
);
10225 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10227 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10229 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
10233 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
10238 char clean_input_buf
[32] = { 0 };
10240 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
10241 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
10243 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
10247 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
10253 clean_input_buf
[k
] = input_buf
[i
];
10261 u32
*digest
= (u32
*) hash_buf
->digest
;
10263 salt_t
*salt
= hash_buf
->salt
;
10265 u32 a
, b
, c
, d
, e
, f
;
10267 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10268 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10269 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10270 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10271 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10272 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10274 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10275 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10277 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10278 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10279 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10280 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10281 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10282 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10284 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10285 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10287 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10288 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10289 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10290 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10291 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10292 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10294 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10295 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10297 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10298 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10299 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10300 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10301 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10302 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10304 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10305 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10307 digest
[0] = byte_swap_32 (digest
[0]);
10308 digest
[1] = byte_swap_32 (digest
[1]);
10309 digest
[2] = byte_swap_32 (digest
[2]);
10310 digest
[3] = byte_swap_32 (digest
[3]);
10312 digest
[0] -= MD5M_A
;
10313 digest
[1] -= MD5M_B
;
10314 digest
[2] -= MD5M_C
;
10315 digest
[3] -= MD5M_D
;
10317 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10319 uint salt_len
= input_len
- 30 - 1;
10321 char *salt_buf
= input_buf
+ 30 + 1;
10323 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10325 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10327 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10328 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10330 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10332 salt
->salt_len
= salt_len
;
10334 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10336 salt
->salt_len
+= 22;
10338 return (PARSER_OK
);
10341 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10343 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10345 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10349 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10352 u32
*digest
= (u32
*) hash_buf
->digest
;
10354 salt_t
*salt
= hash_buf
->salt
;
10356 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10357 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10358 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10359 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10360 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10362 digest
[0] -= SHA1M_A
;
10363 digest
[1] -= SHA1M_B
;
10364 digest
[2] -= SHA1M_C
;
10365 digest
[3] -= SHA1M_D
;
10366 digest
[4] -= SHA1M_E
;
10368 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10370 uint salt_len
= input_len
- 40 - 1;
10372 char *salt_buf
= input_buf
+ 40 + 1;
10374 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10376 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10378 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10380 salt
->salt_len
= salt_len
;
10382 return (PARSER_OK
);
10385 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10387 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10389 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10393 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10396 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10398 char *iter_pos
= input_buf
+ 6;
10400 salt_t
*salt
= hash_buf
->salt
;
10402 uint iter
= atoi (iter_pos
);
10406 iter
= ROUNDS_DCC2
;
10409 salt
->salt_iter
= iter
- 1;
10411 char *salt_pos
= strchr (iter_pos
, '#');
10413 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10417 char *digest_pos
= strchr (salt_pos
, '#');
10419 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10423 uint salt_len
= digest_pos
- salt_pos
- 1;
10425 u32
*digest
= (u32
*) hash_buf
->digest
;
10427 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10428 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10429 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10430 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10432 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10434 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10436 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10438 salt
->salt_len
= salt_len
;
10440 return (PARSER_OK
);
10443 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10445 u32
*digest
= (u32
*) hash_buf
->digest
;
10447 salt_t
*salt
= hash_buf
->salt
;
10449 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10453 memcpy (&in
, input_buf
, input_len
);
10455 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10457 memcpy (digest
, in
.keymic
, 16);
10460 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10461 The phrase "Pairwise key expansion"
10462 Access Point Address (referred to as Authenticator Address AA)
10463 Supplicant Address (referred to as Supplicant Address SA)
10464 Access Point Nonce (referred to as Authenticator Anonce)
10465 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10468 uint salt_len
= strlen (in
.essid
);
10472 log_info ("WARNING: the length of the ESSID is too long. The hccap file may be invalid or corrupted");
10474 return (PARSER_SALT_LENGTH
);
10477 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10479 salt
->salt_len
= salt_len
;
10481 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10483 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10485 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10487 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10489 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10490 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10494 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10495 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10498 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10500 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10501 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10505 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10506 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10509 for (int i
= 0; i
< 25; i
++)
10511 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10514 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10515 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10516 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10517 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10519 wpa
->keyver
= in
.keyver
;
10521 if (wpa
->keyver
> 255)
10523 log_info ("ATTENTION!");
10524 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10525 log_info (" This could be due to a recent aircrack-ng bug.");
10526 log_info (" The key version was automatically reset to a reasonable value.");
10529 wpa
->keyver
&= 0xff;
10532 wpa
->eapol_size
= in
.eapol_size
;
10534 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10536 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10538 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10540 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10542 if (wpa
->keyver
== 1)
10548 digest
[0] = byte_swap_32 (digest
[0]);
10549 digest
[1] = byte_swap_32 (digest
[1]);
10550 digest
[2] = byte_swap_32 (digest
[2]);
10551 digest
[3] = byte_swap_32 (digest
[3]);
10553 for (int i
= 0; i
< 64; i
++)
10555 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10559 uint32_t *p0
= (uint32_t *) in
.essid
;
10563 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10564 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10566 salt
->salt_buf
[10] = c0
;
10567 salt
->salt_buf
[11] = c1
;
10569 return (PARSER_OK
);
10572 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10574 u32
*digest
= (u32
*) hash_buf
->digest
;
10576 salt_t
*salt
= hash_buf
->salt
;
10578 if (input_len
== 0)
10580 log_error ("Password Safe v2 container not specified");
10585 FILE *fp
= fopen (input_buf
, "rb");
10589 log_error ("%s: %s", input_buf
, strerror (errno
));
10596 memset (&buf
, 0, sizeof (psafe2_hdr
));
10598 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10602 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10604 salt
->salt_buf
[0] = buf
.random
[0];
10605 salt
->salt_buf
[1] = buf
.random
[1];
10607 salt
->salt_len
= 8;
10608 salt
->salt_iter
= 1000;
10610 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10611 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10612 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10613 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10614 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10616 return (PARSER_OK
);
10619 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10621 u32
*digest
= (u32
*) hash_buf
->digest
;
10623 salt_t
*salt
= hash_buf
->salt
;
10625 if (input_len
== 0)
10627 log_error (".psafe3 not specified");
10632 FILE *fp
= fopen (input_buf
, "rb");
10636 log_error ("%s: %s", input_buf
, strerror (errno
));
10643 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10647 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10649 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10651 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10653 salt
->salt_iter
= in
.iterations
+ 1;
10655 salt
->salt_buf
[0] = in
.salt_buf
[0];
10656 salt
->salt_buf
[1] = in
.salt_buf
[1];
10657 salt
->salt_buf
[2] = in
.salt_buf
[2];
10658 salt
->salt_buf
[3] = in
.salt_buf
[3];
10659 salt
->salt_buf
[4] = in
.salt_buf
[4];
10660 salt
->salt_buf
[5] = in
.salt_buf
[5];
10661 salt
->salt_buf
[6] = in
.salt_buf
[6];
10662 salt
->salt_buf
[7] = in
.salt_buf
[7];
10664 salt
->salt_len
= 32;
10666 digest
[0] = in
.hash_buf
[0];
10667 digest
[1] = in
.hash_buf
[1];
10668 digest
[2] = in
.hash_buf
[2];
10669 digest
[3] = in
.hash_buf
[3];
10670 digest
[4] = in
.hash_buf
[4];
10671 digest
[5] = in
.hash_buf
[5];
10672 digest
[6] = in
.hash_buf
[6];
10673 digest
[7] = in
.hash_buf
[7];
10675 digest
[0] = byte_swap_32 (digest
[0]);
10676 digest
[1] = byte_swap_32 (digest
[1]);
10677 digest
[2] = byte_swap_32 (digest
[2]);
10678 digest
[3] = byte_swap_32 (digest
[3]);
10679 digest
[4] = byte_swap_32 (digest
[4]);
10680 digest
[5] = byte_swap_32 (digest
[5]);
10681 digest
[6] = byte_swap_32 (digest
[6]);
10682 digest
[7] = byte_swap_32 (digest
[7]);
10684 return (PARSER_OK
);
10687 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10689 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10691 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10693 u32
*digest
= (u32
*) hash_buf
->digest
;
10695 salt_t
*salt
= hash_buf
->salt
;
10697 char *iter_pos
= input_buf
+ 3;
10699 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10701 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10703 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10705 salt
->salt_iter
= salt_iter
;
10707 char *salt_pos
= iter_pos
+ 1;
10711 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10713 salt
->salt_len
= salt_len
;
10715 char *hash_pos
= salt_pos
+ salt_len
;
10717 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10719 return (PARSER_OK
);
10722 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10724 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10726 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10728 u32
*digest
= (u32
*) hash_buf
->digest
;
10730 salt_t
*salt
= hash_buf
->salt
;
10732 char *salt_pos
= input_buf
+ 3;
10734 uint iterations_len
= 0;
10736 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10740 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10742 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10743 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10747 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10751 iterations_len
+= 8;
10755 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10758 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10760 char *hash_pos
= strchr (salt_pos
, '$');
10762 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10764 uint salt_len
= hash_pos
- salt_pos
;
10766 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10768 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10770 salt
->salt_len
= salt_len
;
10774 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10776 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10778 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10780 return (PARSER_OK
);
10783 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10785 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10787 u32
*digest
= (u32
*) hash_buf
->digest
;
10789 salt_t
*salt
= hash_buf
->salt
;
10791 char *salt_pos
= input_buf
+ 6;
10793 uint iterations_len
= 0;
10795 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10799 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10801 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10802 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10806 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10810 iterations_len
+= 8;
10814 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10817 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10819 char *hash_pos
= strchr (salt_pos
, '$');
10821 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10823 uint salt_len
= hash_pos
- salt_pos
;
10825 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10827 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10829 salt
->salt_len
= salt_len
;
10833 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10835 return (PARSER_OK
);
10838 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10840 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10842 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10844 u32
*digest
= (u32
*) hash_buf
->digest
;
10846 salt_t
*salt
= hash_buf
->salt
;
10848 char *salt_pos
= input_buf
+ 14;
10850 char *hash_pos
= strchr (salt_pos
, '*');
10852 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10856 uint salt_len
= hash_pos
- salt_pos
- 1;
10858 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10860 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10862 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10864 salt
->salt_len
= salt_len
;
10866 u8 tmp_buf
[100] = { 0 };
10868 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10870 memcpy (digest
, tmp_buf
, 20);
10872 digest
[0] = byte_swap_32 (digest
[0]);
10873 digest
[1] = byte_swap_32 (digest
[1]);
10874 digest
[2] = byte_swap_32 (digest
[2]);
10875 digest
[3] = byte_swap_32 (digest
[3]);
10876 digest
[4] = byte_swap_32 (digest
[4]);
10878 digest
[0] -= SHA1M_A
;
10879 digest
[1] -= SHA1M_B
;
10880 digest
[2] -= SHA1M_C
;
10881 digest
[3] -= SHA1M_D
;
10882 digest
[4] -= SHA1M_E
;
10884 return (PARSER_OK
);
10887 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10889 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10891 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10893 if (c12
& 3) return (PARSER_HASH_VALUE
);
10895 u32
*digest
= (u32
*) hash_buf
->digest
;
10897 salt_t
*salt
= hash_buf
->salt
;
10899 // for ascii_digest
10900 salt
->salt_sign
[0] = input_buf
[0];
10901 salt
->salt_sign
[1] = input_buf
[1];
10903 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10904 | itoa64_to_int (input_buf
[1]) << 6;
10906 salt
->salt_len
= 2;
10908 u8 tmp_buf
[100] = { 0 };
10910 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10912 memcpy (digest
, tmp_buf
, 8);
10916 IP (digest
[0], digest
[1], tt
);
10921 return (PARSER_OK
);
10924 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10926 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10928 u32
*digest
= (u32
*) hash_buf
->digest
;
10930 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10931 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10932 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10933 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10935 digest
[0] = byte_swap_32 (digest
[0]);
10936 digest
[1] = byte_swap_32 (digest
[1]);
10937 digest
[2] = byte_swap_32 (digest
[2]);
10938 digest
[3] = byte_swap_32 (digest
[3]);
10940 digest
[0] -= MD4M_A
;
10941 digest
[1] -= MD4M_B
;
10942 digest
[2] -= MD4M_C
;
10943 digest
[3] -= MD4M_D
;
10945 return (PARSER_OK
);
10948 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10950 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10952 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10956 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10959 u32
*digest
= (u32
*) hash_buf
->digest
;
10961 salt_t
*salt
= hash_buf
->salt
;
10963 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10964 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10965 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10966 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10968 digest
[0] = byte_swap_32 (digest
[0]);
10969 digest
[1] = byte_swap_32 (digest
[1]);
10970 digest
[2] = byte_swap_32 (digest
[2]);
10971 digest
[3] = byte_swap_32 (digest
[3]);
10973 digest
[0] -= MD4M_A
;
10974 digest
[1] -= MD4M_B
;
10975 digest
[2] -= MD4M_C
;
10976 digest
[3] -= MD4M_D
;
10978 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10980 uint salt_len
= input_len
- 32 - 1;
10982 char *salt_buf
= input_buf
+ 32 + 1;
10984 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10986 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10988 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10990 salt
->salt_len
= salt_len
;
10992 return (PARSER_OK
);
10995 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10997 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10999 u32
*digest
= (u32
*) hash_buf
->digest
;
11001 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11002 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11003 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11004 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11006 digest
[0] = byte_swap_32 (digest
[0]);
11007 digest
[1] = byte_swap_32 (digest
[1]);
11008 digest
[2] = byte_swap_32 (digest
[2]);
11009 digest
[3] = byte_swap_32 (digest
[3]);
11011 digest
[0] -= MD5M_A
;
11012 digest
[1] -= MD5M_B
;
11013 digest
[2] -= MD5M_C
;
11014 digest
[3] -= MD5M_D
;
11016 return (PARSER_OK
);
11019 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11021 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
11023 u32
*digest
= (u32
*) hash_buf
->digest
;
11025 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
11026 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
11030 digest
[0] = byte_swap_32 (digest
[0]);
11031 digest
[1] = byte_swap_32 (digest
[1]);
11033 return (PARSER_OK
);
11036 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11038 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11040 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
11044 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
11047 u32
*digest
= (u32
*) hash_buf
->digest
;
11049 salt_t
*salt
= hash_buf
->salt
;
11051 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11052 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11053 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11054 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11056 digest
[0] = byte_swap_32 (digest
[0]);
11057 digest
[1] = byte_swap_32 (digest
[1]);
11058 digest
[2] = byte_swap_32 (digest
[2]);
11059 digest
[3] = byte_swap_32 (digest
[3]);
11061 digest
[0] -= MD5M_A
;
11062 digest
[1] -= MD5M_B
;
11063 digest
[2] -= MD5M_C
;
11064 digest
[3] -= MD5M_D
;
11066 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11068 uint salt_len
= input_len
- 32 - 1;
11070 char *salt_buf
= input_buf
+ 32 + 1;
11072 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11074 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11076 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11078 salt
->salt_len
= salt_len
;
11080 return (PARSER_OK
);
11083 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11085 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
11087 u32
*digest
= (u32
*) hash_buf
->digest
;
11089 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11090 | itoa64_to_int (input_buf
[ 1]) << 6
11091 | itoa64_to_int (input_buf
[ 2]) << 12
11092 | itoa64_to_int (input_buf
[ 3]) << 18;
11093 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11094 | itoa64_to_int (input_buf
[ 5]) << 6
11095 | itoa64_to_int (input_buf
[ 6]) << 12
11096 | itoa64_to_int (input_buf
[ 7]) << 18;
11097 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11098 | itoa64_to_int (input_buf
[ 9]) << 6
11099 | itoa64_to_int (input_buf
[10]) << 12
11100 | itoa64_to_int (input_buf
[11]) << 18;
11101 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11102 | itoa64_to_int (input_buf
[13]) << 6
11103 | itoa64_to_int (input_buf
[14]) << 12
11104 | itoa64_to_int (input_buf
[15]) << 18;
11106 digest
[0] -= MD5M_A
;
11107 digest
[1] -= MD5M_B
;
11108 digest
[2] -= MD5M_C
;
11109 digest
[3] -= MD5M_D
;
11111 digest
[0] &= 0x00ffffff;
11112 digest
[1] &= 0x00ffffff;
11113 digest
[2] &= 0x00ffffff;
11114 digest
[3] &= 0x00ffffff;
11116 return (PARSER_OK
);
11119 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11121 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11123 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
11127 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
11130 u32
*digest
= (u32
*) hash_buf
->digest
;
11132 salt_t
*salt
= hash_buf
->salt
;
11134 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11135 | itoa64_to_int (input_buf
[ 1]) << 6
11136 | itoa64_to_int (input_buf
[ 2]) << 12
11137 | itoa64_to_int (input_buf
[ 3]) << 18;
11138 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11139 | itoa64_to_int (input_buf
[ 5]) << 6
11140 | itoa64_to_int (input_buf
[ 6]) << 12
11141 | itoa64_to_int (input_buf
[ 7]) << 18;
11142 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11143 | itoa64_to_int (input_buf
[ 9]) << 6
11144 | itoa64_to_int (input_buf
[10]) << 12
11145 | itoa64_to_int (input_buf
[11]) << 18;
11146 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11147 | itoa64_to_int (input_buf
[13]) << 6
11148 | itoa64_to_int (input_buf
[14]) << 12
11149 | itoa64_to_int (input_buf
[15]) << 18;
11151 digest
[0] -= MD5M_A
;
11152 digest
[1] -= MD5M_B
;
11153 digest
[2] -= MD5M_C
;
11154 digest
[3] -= MD5M_D
;
11156 digest
[0] &= 0x00ffffff;
11157 digest
[1] &= 0x00ffffff;
11158 digest
[2] &= 0x00ffffff;
11159 digest
[3] &= 0x00ffffff;
11161 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11163 uint salt_len
= input_len
- 16 - 1;
11165 char *salt_buf
= input_buf
+ 16 + 1;
11167 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11169 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11171 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11173 salt
->salt_len
= salt_len
;
11175 return (PARSER_OK
);
11178 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
11180 key
[0] = (nthash
[0] >> 0);
11181 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
11182 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
11183 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
11184 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
11185 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
11186 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
11187 key
[7] = (nthash
[6] << 1);
11199 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11201 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
11203 u32
*digest
= (u32
*) hash_buf
->digest
;
11205 salt_t
*salt
= hash_buf
->salt
;
11207 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11213 char *user_pos
= input_buf
;
11215 char *unused_pos
= strchr (user_pos
, ':');
11217 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11219 uint user_len
= unused_pos
- user_pos
;
11221 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11225 char *domain_pos
= strchr (unused_pos
, ':');
11227 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11229 uint unused_len
= domain_pos
- unused_pos
;
11231 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11235 char *srvchall_pos
= strchr (domain_pos
, ':');
11237 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11239 uint domain_len
= srvchall_pos
- domain_pos
;
11241 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11245 char *hash_pos
= strchr (srvchall_pos
, ':');
11247 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11249 uint srvchall_len
= hash_pos
- srvchall_pos
;
11251 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
11255 char *clichall_pos
= strchr (hash_pos
, ':');
11257 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11259 uint hash_len
= clichall_pos
- hash_pos
;
11261 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11265 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11267 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11270 * store some data for later use
11273 netntlm
->user_len
= user_len
* 2;
11274 netntlm
->domain_len
= domain_len
* 2;
11275 netntlm
->srvchall_len
= srvchall_len
/ 2;
11276 netntlm
->clichall_len
= clichall_len
/ 2;
11278 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11279 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11282 * handle username and domainname
11285 for (uint i
= 0; i
< user_len
; i
++)
11287 *userdomain_ptr
++ = user_pos
[i
];
11288 *userdomain_ptr
++ = 0;
11291 for (uint i
= 0; i
< domain_len
; i
++)
11293 *userdomain_ptr
++ = domain_pos
[i
];
11294 *userdomain_ptr
++ = 0;
11298 * handle server challenge encoding
11301 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11303 const char p0
= srvchall_pos
[i
+ 0];
11304 const char p1
= srvchall_pos
[i
+ 1];
11306 *chall_ptr
++ = hex_convert (p1
) << 0
11307 | hex_convert (p0
) << 4;
11311 * handle client challenge encoding
11314 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11316 const char p0
= clichall_pos
[i
+ 0];
11317 const char p1
= clichall_pos
[i
+ 1];
11319 *chall_ptr
++ = hex_convert (p1
) << 0
11320 | hex_convert (p0
) << 4;
11327 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11329 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11331 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11333 salt
->salt_len
= salt_len
;
11335 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11336 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11337 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11338 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11340 digest
[0] = byte_swap_32 (digest
[0]);
11341 digest
[1] = byte_swap_32 (digest
[1]);
11342 digest
[2] = byte_swap_32 (digest
[2]);
11343 digest
[3] = byte_swap_32 (digest
[3]);
11345 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11347 uint digest_tmp
[2] = { 0 };
11349 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11350 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11352 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11353 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11355 /* special case 2: ESS */
11357 if (srvchall_len
== 48)
11359 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11361 uint w
[16] = { 0 };
11363 w
[ 0] = netntlm
->chall_buf
[6];
11364 w
[ 1] = netntlm
->chall_buf
[7];
11365 w
[ 2] = netntlm
->chall_buf
[0];
11366 w
[ 3] = netntlm
->chall_buf
[1];
11370 uint dgst
[4] = { 0 };
11379 salt
->salt_buf
[0] = dgst
[0];
11380 salt
->salt_buf
[1] = dgst
[1];
11384 /* precompute netntlmv1 exploit start */
11386 for (uint i
= 0; i
< 0x10000; i
++)
11388 uint key_md4
[2] = { i
, 0 };
11389 uint key_des
[2] = { 0, 0 };
11391 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11393 uint Kc
[16] = { 0 };
11394 uint Kd
[16] = { 0 };
11396 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11398 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11400 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11402 if (data3
[0] != digest_tmp
[0]) continue;
11403 if (data3
[1] != digest_tmp
[1]) continue;
11405 salt
->salt_buf
[2] = i
;
11407 salt
->salt_len
= 24;
11412 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11413 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11415 /* precompute netntlmv1 exploit stop */
11419 IP (digest
[0], digest
[1], tt
);
11420 IP (digest
[2], digest
[3], tt
);
11422 digest
[0] = rotr32 (digest
[0], 29);
11423 digest
[1] = rotr32 (digest
[1], 29);
11424 digest
[2] = rotr32 (digest
[2], 29);
11425 digest
[3] = rotr32 (digest
[3], 29);
11427 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11429 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11430 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11432 return (PARSER_OK
);
11435 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11437 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11439 u32
*digest
= (u32
*) hash_buf
->digest
;
11441 salt_t
*salt
= hash_buf
->salt
;
11443 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11449 char *user_pos
= input_buf
;
11451 char *unused_pos
= strchr (user_pos
, ':');
11453 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11455 uint user_len
= unused_pos
- user_pos
;
11457 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11461 char *domain_pos
= strchr (unused_pos
, ':');
11463 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11465 uint unused_len
= domain_pos
- unused_pos
;
11467 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11471 char *srvchall_pos
= strchr (domain_pos
, ':');
11473 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11475 uint domain_len
= srvchall_pos
- domain_pos
;
11477 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11481 char *hash_pos
= strchr (srvchall_pos
, ':');
11483 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11485 uint srvchall_len
= hash_pos
- srvchall_pos
;
11487 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11491 char *clichall_pos
= strchr (hash_pos
, ':');
11493 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11495 uint hash_len
= clichall_pos
- hash_pos
;
11497 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11501 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11503 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11505 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11508 * store some data for later use
11511 netntlm
->user_len
= user_len
* 2;
11512 netntlm
->domain_len
= domain_len
* 2;
11513 netntlm
->srvchall_len
= srvchall_len
/ 2;
11514 netntlm
->clichall_len
= clichall_len
/ 2;
11516 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11517 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11520 * handle username and domainname
11523 for (uint i
= 0; i
< user_len
; i
++)
11525 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11526 *userdomain_ptr
++ = 0;
11529 for (uint i
= 0; i
< domain_len
; i
++)
11531 *userdomain_ptr
++ = domain_pos
[i
];
11532 *userdomain_ptr
++ = 0;
11535 *userdomain_ptr
++ = 0x80;
11538 * handle server challenge encoding
11541 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11543 const char p0
= srvchall_pos
[i
+ 0];
11544 const char p1
= srvchall_pos
[i
+ 1];
11546 *chall_ptr
++ = hex_convert (p1
) << 0
11547 | hex_convert (p0
) << 4;
11551 * handle client challenge encoding
11554 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11556 const char p0
= clichall_pos
[i
+ 0];
11557 const char p1
= clichall_pos
[i
+ 1];
11559 *chall_ptr
++ = hex_convert (p1
) << 0
11560 | hex_convert (p0
) << 4;
11563 *chall_ptr
++ = 0x80;
11566 * handle hash itself
11569 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11570 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11571 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11572 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11574 digest
[0] = byte_swap_32 (digest
[0]);
11575 digest
[1] = byte_swap_32 (digest
[1]);
11576 digest
[2] = byte_swap_32 (digest
[2]);
11577 digest
[3] = byte_swap_32 (digest
[3]);
11580 * reuse challange data as salt_buf, its the buffer that is most likely unique
11583 salt
->salt_buf
[0] = 0;
11584 salt
->salt_buf
[1] = 0;
11585 salt
->salt_buf
[2] = 0;
11586 salt
->salt_buf
[3] = 0;
11587 salt
->salt_buf
[4] = 0;
11588 salt
->salt_buf
[5] = 0;
11589 salt
->salt_buf
[6] = 0;
11590 salt
->salt_buf
[7] = 0;
11594 uptr
= (uint
*) netntlm
->userdomain_buf
;
11596 for (uint i
= 0; i
< 16; i
+= 16)
11598 md5_64 (uptr
, salt
->salt_buf
);
11601 uptr
= (uint
*) netntlm
->chall_buf
;
11603 for (uint i
= 0; i
< 256; i
+= 16)
11605 md5_64 (uptr
, salt
->salt_buf
);
11608 salt
->salt_len
= 16;
11610 return (PARSER_OK
);
11613 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11615 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11617 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11621 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11624 u32
*digest
= (u32
*) hash_buf
->digest
;
11626 salt_t
*salt
= hash_buf
->salt
;
11628 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11629 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11630 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11631 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11633 digest
[0] = byte_swap_32 (digest
[0]);
11634 digest
[1] = byte_swap_32 (digest
[1]);
11635 digest
[2] = byte_swap_32 (digest
[2]);
11636 digest
[3] = byte_swap_32 (digest
[3]);
11638 digest
[0] -= MD5M_A
;
11639 digest
[1] -= MD5M_B
;
11640 digest
[2] -= MD5M_C
;
11641 digest
[3] -= MD5M_D
;
11643 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11645 uint salt_len
= input_len
- 32 - 1;
11647 char *salt_buf
= input_buf
+ 32 + 1;
11649 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11651 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11653 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11655 salt
->salt_len
= salt_len
;
11657 return (PARSER_OK
);
11660 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11662 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11664 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11668 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11671 u32
*digest
= (u32
*) hash_buf
->digest
;
11673 salt_t
*salt
= hash_buf
->salt
;
11675 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11676 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11677 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11678 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11680 digest
[0] = byte_swap_32 (digest
[0]);
11681 digest
[1] = byte_swap_32 (digest
[1]);
11682 digest
[2] = byte_swap_32 (digest
[2]);
11683 digest
[3] = byte_swap_32 (digest
[3]);
11685 digest
[0] -= MD5M_A
;
11686 digest
[1] -= MD5M_B
;
11687 digest
[2] -= MD5M_C
;
11688 digest
[3] -= MD5M_D
;
11690 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11692 uint salt_len
= input_len
- 32 - 1;
11694 char *salt_buf
= input_buf
+ 32 + 1;
11696 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11698 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11700 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11702 salt
->salt_len
= salt_len
;
11704 return (PARSER_OK
);
11707 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11709 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11711 u32
*digest
= (u32
*) hash_buf
->digest
;
11713 salt_t
*salt
= hash_buf
->salt
;
11715 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11716 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11717 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11718 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11720 digest
[0] = byte_swap_32 (digest
[0]);
11721 digest
[1] = byte_swap_32 (digest
[1]);
11722 digest
[2] = byte_swap_32 (digest
[2]);
11723 digest
[3] = byte_swap_32 (digest
[3]);
11725 digest
[0] -= MD5M_A
;
11726 digest
[1] -= MD5M_B
;
11727 digest
[2] -= MD5M_C
;
11728 digest
[3] -= MD5M_D
;
11731 * This is a virtual salt. While the algorithm is basically not salted
11732 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11733 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11736 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11738 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11740 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11742 salt
->salt_len
= salt_len
;
11744 return (PARSER_OK
);
11747 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11749 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11751 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11755 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11758 u32
*digest
= (u32
*) hash_buf
->digest
;
11760 salt_t
*salt
= hash_buf
->salt
;
11762 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11763 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11764 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11765 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11767 digest
[0] = byte_swap_32 (digest
[0]);
11768 digest
[1] = byte_swap_32 (digest
[1]);
11769 digest
[2] = byte_swap_32 (digest
[2]);
11770 digest
[3] = byte_swap_32 (digest
[3]);
11772 digest
[0] -= MD5M_A
;
11773 digest
[1] -= MD5M_B
;
11774 digest
[2] -= MD5M_C
;
11775 digest
[3] -= MD5M_D
;
11777 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11779 uint salt_len
= input_len
- 32 - 1;
11781 char *salt_buf
= input_buf
+ 32 + 1;
11783 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11785 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11787 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11789 salt
->salt_len
= salt_len
;
11791 return (PARSER_OK
);
11794 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11796 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11798 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11802 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11805 u32
*digest
= (u32
*) hash_buf
->digest
;
11807 salt_t
*salt
= hash_buf
->salt
;
11809 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11810 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11811 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11812 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11814 digest
[0] = byte_swap_32 (digest
[0]);
11815 digest
[1] = byte_swap_32 (digest
[1]);
11816 digest
[2] = byte_swap_32 (digest
[2]);
11817 digest
[3] = byte_swap_32 (digest
[3]);
11819 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11821 uint salt_len
= input_len
- 32 - 1;
11823 char *salt_buf
= input_buf
+ 32 + 1;
11825 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11827 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11829 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11831 salt
->salt_len
= salt_len
;
11833 return (PARSER_OK
);
11836 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11838 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11840 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11844 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11847 u32
*digest
= (u32
*) hash_buf
->digest
;
11849 salt_t
*salt
= hash_buf
->salt
;
11851 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11852 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11853 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11854 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11856 digest
[0] = byte_swap_32 (digest
[0]);
11857 digest
[1] = byte_swap_32 (digest
[1]);
11858 digest
[2] = byte_swap_32 (digest
[2]);
11859 digest
[3] = byte_swap_32 (digest
[3]);
11861 digest
[0] -= MD4M_A
;
11862 digest
[1] -= MD4M_B
;
11863 digest
[2] -= MD4M_C
;
11864 digest
[3] -= MD4M_D
;
11866 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11868 uint salt_len
= input_len
- 32 - 1;
11870 char *salt_buf
= input_buf
+ 32 + 1;
11872 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11874 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11876 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11878 salt
->salt_len
= salt_len
;
11880 return (PARSER_OK
);
11883 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11885 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11887 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11891 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11894 u32
*digest
= (u32
*) hash_buf
->digest
;
11896 salt_t
*salt
= hash_buf
->salt
;
11898 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11899 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11900 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11901 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11903 digest
[0] = byte_swap_32 (digest
[0]);
11904 digest
[1] = byte_swap_32 (digest
[1]);
11905 digest
[2] = byte_swap_32 (digest
[2]);
11906 digest
[3] = byte_swap_32 (digest
[3]);
11908 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11910 uint salt_len
= input_len
- 32 - 1;
11912 char *salt_buf
= input_buf
+ 32 + 1;
11914 uint salt_pc_block
[16] = { 0 };
11916 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11918 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11920 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11922 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11924 salt_pc_block
[14] = salt_len
* 8;
11926 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11928 md5_64 (salt_pc_block
, salt_pc_digest
);
11930 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11931 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11932 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11933 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11935 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11937 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11939 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11941 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11942 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11943 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11944 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11946 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11948 return (PARSER_OK
);
11951 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11953 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11955 u32
*digest
= (u32
*) hash_buf
->digest
;
11957 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11958 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11959 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11960 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11961 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11963 digest
[0] -= SHA1M_A
;
11964 digest
[1] -= SHA1M_B
;
11965 digest
[2] -= SHA1M_C
;
11966 digest
[3] -= SHA1M_D
;
11967 digest
[4] -= SHA1M_E
;
11969 return (PARSER_OK
);
11972 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11974 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11976 u32
*digest
= (u32
*) hash_buf
->digest
;
11978 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11979 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11980 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11981 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11982 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11984 return (PARSER_OK
);
11987 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11989 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
11991 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
11993 u32
*digest
= (u32
*) hash_buf
->digest
;
11997 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11998 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11999 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12000 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12003 return (PARSER_OK
);
12006 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12008 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12010 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
12014 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
12017 u32
*digest
= (u32
*) hash_buf
->digest
;
12019 salt_t
*salt
= hash_buf
->salt
;
12021 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12022 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12023 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12024 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12025 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12027 digest
[0] -= SHA1M_A
;
12028 digest
[1] -= SHA1M_B
;
12029 digest
[2] -= SHA1M_C
;
12030 digest
[3] -= SHA1M_D
;
12031 digest
[4] -= SHA1M_E
;
12033 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12035 uint salt_len
= input_len
- 40 - 1;
12037 char *salt_buf
= input_buf
+ 40 + 1;
12039 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12041 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12043 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12045 salt
->salt_len
= salt_len
;
12047 return (PARSER_OK
);
12050 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12052 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
12054 u32
*digest
= (u32
*) hash_buf
->digest
;
12056 salt_t
*salt
= hash_buf
->salt
;
12058 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
12060 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12061 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12062 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12063 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12064 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12066 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12068 uint salt_len
= input_len
- 40 - 1;
12070 char *salt_buf
= input_buf
+ 40 + 1;
12072 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
12074 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
12076 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
12078 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
12081 pstoken
->salt_len
= salt_len
/ 2;
12083 /* some fake salt for the sorting mechanisms */
12085 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
12086 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
12087 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
12088 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
12089 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
12090 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
12091 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
12092 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
12094 salt
->salt_len
= 32;
12096 /* we need to check if we can precompute some of the data --
12097 this is possible since the scheme is badly designed */
12099 pstoken
->pc_digest
[0] = SHA1M_A
;
12100 pstoken
->pc_digest
[1] = SHA1M_B
;
12101 pstoken
->pc_digest
[2] = SHA1M_C
;
12102 pstoken
->pc_digest
[3] = SHA1M_D
;
12103 pstoken
->pc_digest
[4] = SHA1M_E
;
12105 pstoken
->pc_offset
= 0;
12107 for (int i
= 0; i
< (int) pstoken
->salt_len
- 63; i
+= 64)
12111 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
12112 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
12113 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
12114 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
12115 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
12116 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
12117 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
12118 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
12119 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
12120 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
12121 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
12122 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
12123 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
12124 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
12125 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
12126 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
12128 sha1_64 (w
, pstoken
->pc_digest
);
12130 pstoken
->pc_offset
+= 16;
12133 return (PARSER_OK
);
12136 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12138 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
12140 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
12142 u32
*digest
= (u32
*) hash_buf
->digest
;
12144 u8 tmp_buf
[100] = { 0 };
12146 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
12148 memcpy (digest
, tmp_buf
, 20);
12150 digest
[0] = byte_swap_32 (digest
[0]);
12151 digest
[1] = byte_swap_32 (digest
[1]);
12152 digest
[2] = byte_swap_32 (digest
[2]);
12153 digest
[3] = byte_swap_32 (digest
[3]);
12154 digest
[4] = byte_swap_32 (digest
[4]);
12156 digest
[0] -= SHA1M_A
;
12157 digest
[1] -= SHA1M_B
;
12158 digest
[2] -= SHA1M_C
;
12159 digest
[3] -= SHA1M_D
;
12160 digest
[4] -= SHA1M_E
;
12162 return (PARSER_OK
);
12165 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12167 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
12169 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12171 u32
*digest
= (u32
*) hash_buf
->digest
;
12173 salt_t
*salt
= hash_buf
->salt
;
12175 u8 tmp_buf
[100] = { 0 };
12177 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
12179 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
12181 memcpy (digest
, tmp_buf
, 20);
12183 int salt_len
= tmp_len
- 20;
12185 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
12187 salt
->salt_len
= salt_len
;
12189 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
12191 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12193 char *ptr
= (char *) salt
->salt_buf
;
12195 ptr
[salt
->salt_len
] = 0x80;
12198 digest
[0] = byte_swap_32 (digest
[0]);
12199 digest
[1] = byte_swap_32 (digest
[1]);
12200 digest
[2] = byte_swap_32 (digest
[2]);
12201 digest
[3] = byte_swap_32 (digest
[3]);
12202 digest
[4] = byte_swap_32 (digest
[4]);
12204 digest
[0] -= SHA1M_A
;
12205 digest
[1] -= SHA1M_B
;
12206 digest
[2] -= SHA1M_C
;
12207 digest
[3] -= SHA1M_D
;
12208 digest
[4] -= SHA1M_E
;
12210 return (PARSER_OK
);
12213 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12215 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
12217 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12219 u32
*digest
= (u32
*) hash_buf
->digest
;
12221 salt_t
*salt
= hash_buf
->salt
;
12223 char *salt_buf
= input_buf
+ 6;
12227 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12229 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12231 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12233 salt
->salt_len
= salt_len
;
12235 char *hash_pos
= input_buf
+ 6 + 8 + 40;
12237 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12238 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12239 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12240 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12241 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12243 digest
[0] -= SHA1M_A
;
12244 digest
[1] -= SHA1M_B
;
12245 digest
[2] -= SHA1M_C
;
12246 digest
[3] -= SHA1M_D
;
12247 digest
[4] -= SHA1M_E
;
12249 return (PARSER_OK
);
12252 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12254 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
12256 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12258 u32
*digest
= (u32
*) hash_buf
->digest
;
12260 salt_t
*salt
= hash_buf
->salt
;
12262 char *salt_buf
= input_buf
+ 6;
12266 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12268 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12270 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12272 salt
->salt_len
= salt_len
;
12274 char *hash_pos
= input_buf
+ 6 + 8;
12276 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12277 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12278 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12279 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12280 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12282 digest
[0] -= SHA1M_A
;
12283 digest
[1] -= SHA1M_B
;
12284 digest
[2] -= SHA1M_C
;
12285 digest
[3] -= SHA1M_D
;
12286 digest
[4] -= SHA1M_E
;
12288 return (PARSER_OK
);
12291 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12293 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12295 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12297 u64
*digest
= (u64
*) hash_buf
->digest
;
12299 salt_t
*salt
= hash_buf
->salt
;
12301 char *salt_buf
= input_buf
+ 6;
12305 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12307 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12309 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12311 salt
->salt_len
= salt_len
;
12313 char *hash_pos
= input_buf
+ 6 + 8;
12315 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12316 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12317 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12318 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12319 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12320 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12321 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12322 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12324 digest
[0] -= SHA512M_A
;
12325 digest
[1] -= SHA512M_B
;
12326 digest
[2] -= SHA512M_C
;
12327 digest
[3] -= SHA512M_D
;
12328 digest
[4] -= SHA512M_E
;
12329 digest
[5] -= SHA512M_F
;
12330 digest
[6] -= SHA512M_G
;
12331 digest
[7] -= SHA512M_H
;
12333 return (PARSER_OK
);
12336 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12338 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12340 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12344 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12347 u32
*digest
= (u32
*) hash_buf
->digest
;
12349 salt_t
*salt
= hash_buf
->salt
;
12351 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12352 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12356 digest
[0] = byte_swap_32 (digest
[0]);
12357 digest
[1] = byte_swap_32 (digest
[1]);
12359 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12361 uint salt_len
= input_len
- 16 - 1;
12363 char *salt_buf
= input_buf
+ 16 + 1;
12365 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12367 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12369 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12371 salt
->salt_len
= salt_len
;
12373 return (PARSER_OK
);
12376 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12378 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12380 u32
*digest
= (u32
*) hash_buf
->digest
;
12382 salt_t
*salt
= hash_buf
->salt
;
12384 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12385 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12386 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12387 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12388 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12390 digest
[0] -= SHA1M_A
;
12391 digest
[1] -= SHA1M_B
;
12392 digest
[2] -= SHA1M_C
;
12393 digest
[3] -= SHA1M_D
;
12394 digest
[4] -= SHA1M_E
;
12396 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12398 uint salt_len
= input_len
- 40 - 1;
12400 char *salt_buf
= input_buf
+ 40 + 1;
12402 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12404 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12406 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12408 salt
->salt_len
= salt_len
;
12410 return (PARSER_OK
);
12413 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12415 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12417 u32
*digest
= (u32
*) hash_buf
->digest
;
12419 salt_t
*salt
= hash_buf
->salt
;
12421 char *hash_pos
= input_buf
;
12423 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12424 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12425 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12426 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12427 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12428 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12429 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12430 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12431 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12432 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12433 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12434 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12435 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12436 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12437 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12438 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12440 char *salt_pos
= input_buf
+ 128;
12442 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12443 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12444 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12445 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12447 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12448 salt
->salt_len
= 16;
12450 return (PARSER_OK
);
12453 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12455 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12457 u32
*digest
= (u32
*) hash_buf
->digest
;
12459 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12460 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12461 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12462 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12463 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12464 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12465 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12466 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12468 digest
[0] -= SHA256M_A
;
12469 digest
[1] -= SHA256M_B
;
12470 digest
[2] -= SHA256M_C
;
12471 digest
[3] -= SHA256M_D
;
12472 digest
[4] -= SHA256M_E
;
12473 digest
[5] -= SHA256M_F
;
12474 digest
[6] -= SHA256M_G
;
12475 digest
[7] -= SHA256M_H
;
12477 return (PARSER_OK
);
12480 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12482 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12484 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12488 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12491 u32
*digest
= (u32
*) hash_buf
->digest
;
12493 salt_t
*salt
= hash_buf
->salt
;
12495 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12496 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12497 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12498 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12499 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12500 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12501 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12502 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12504 digest
[0] -= SHA256M_A
;
12505 digest
[1] -= SHA256M_B
;
12506 digest
[2] -= SHA256M_C
;
12507 digest
[3] -= SHA256M_D
;
12508 digest
[4] -= SHA256M_E
;
12509 digest
[5] -= SHA256M_F
;
12510 digest
[6] -= SHA256M_G
;
12511 digest
[7] -= SHA256M_H
;
12513 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12515 uint salt_len
= input_len
- 64 - 1;
12517 char *salt_buf
= input_buf
+ 64 + 1;
12519 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12521 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12523 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12525 salt
->salt_len
= salt_len
;
12527 return (PARSER_OK
);
12530 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12532 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12534 u64
*digest
= (u64
*) hash_buf
->digest
;
12536 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12537 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12538 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12539 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12540 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12541 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12545 digest
[0] -= SHA384M_A
;
12546 digest
[1] -= SHA384M_B
;
12547 digest
[2] -= SHA384M_C
;
12548 digest
[3] -= SHA384M_D
;
12549 digest
[4] -= SHA384M_E
;
12550 digest
[5] -= SHA384M_F
;
12554 return (PARSER_OK
);
12557 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12559 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12561 u64
*digest
= (u64
*) hash_buf
->digest
;
12563 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12564 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12565 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12566 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12567 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12568 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12569 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12570 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12572 digest
[0] -= SHA512M_A
;
12573 digest
[1] -= SHA512M_B
;
12574 digest
[2] -= SHA512M_C
;
12575 digest
[3] -= SHA512M_D
;
12576 digest
[4] -= SHA512M_E
;
12577 digest
[5] -= SHA512M_F
;
12578 digest
[6] -= SHA512M_G
;
12579 digest
[7] -= SHA512M_H
;
12581 return (PARSER_OK
);
12584 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12586 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12588 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12592 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12595 u64
*digest
= (u64
*) hash_buf
->digest
;
12597 salt_t
*salt
= hash_buf
->salt
;
12599 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12600 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12601 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12602 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12603 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12604 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12605 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12606 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12608 digest
[0] -= SHA512M_A
;
12609 digest
[1] -= SHA512M_B
;
12610 digest
[2] -= SHA512M_C
;
12611 digest
[3] -= SHA512M_D
;
12612 digest
[4] -= SHA512M_E
;
12613 digest
[5] -= SHA512M_F
;
12614 digest
[6] -= SHA512M_G
;
12615 digest
[7] -= SHA512M_H
;
12617 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12619 uint salt_len
= input_len
- 128 - 1;
12621 char *salt_buf
= input_buf
+ 128 + 1;
12623 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12625 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12627 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12629 salt
->salt_len
= salt_len
;
12631 return (PARSER_OK
);
12634 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12636 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12638 u64
*digest
= (u64
*) hash_buf
->digest
;
12640 salt_t
*salt
= hash_buf
->salt
;
12642 char *salt_pos
= input_buf
+ 3;
12644 uint iterations_len
= 0;
12646 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12650 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12652 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12653 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12657 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12661 iterations_len
+= 8;
12665 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12668 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12670 char *hash_pos
= strchr (salt_pos
, '$');
12672 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12674 uint salt_len
= hash_pos
- salt_pos
;
12676 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12678 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12680 salt
->salt_len
= salt_len
;
12684 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12686 return (PARSER_OK
);
12689 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12691 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12693 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12695 u64
*digest
= (u64
*) hash_buf
->digest
;
12697 salt_t
*salt
= hash_buf
->salt
;
12699 uint keccak_mdlen
= input_len
/ 2;
12701 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12703 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12705 digest
[i
] = byte_swap_64 (digest
[i
]);
12708 salt
->keccak_mdlen
= keccak_mdlen
;
12710 return (PARSER_OK
);
12713 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12715 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12717 u32
*digest
= (u32
*) hash_buf
->digest
;
12719 salt_t
*salt
= hash_buf
->salt
;
12721 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12724 * Parse that strange long line
12729 size_t in_len
[9] = { 0 };
12731 in_off
[0] = strtok (input_buf
, ":");
12733 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12735 in_len
[0] = strlen (in_off
[0]);
12739 for (i
= 1; i
< 9; i
++)
12741 in_off
[i
] = strtok (NULL
, ":");
12743 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12745 in_len
[i
] = strlen (in_off
[i
]);
12748 char *ptr
= (char *) ikepsk
->msg_buf
;
12750 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12751 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12752 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12753 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12754 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12755 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12759 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12761 ptr
= (char *) ikepsk
->nr_buf
;
12763 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12764 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12768 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12771 * Store to database
12776 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12777 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12778 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12779 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12781 digest
[0] = byte_swap_32 (digest
[0]);
12782 digest
[1] = byte_swap_32 (digest
[1]);
12783 digest
[2] = byte_swap_32 (digest
[2]);
12784 digest
[3] = byte_swap_32 (digest
[3]);
12786 salt
->salt_len
= 32;
12788 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12789 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12790 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12791 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12792 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12793 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12794 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12795 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12797 return (PARSER_OK
);
12800 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12802 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12804 u32
*digest
= (u32
*) hash_buf
->digest
;
12806 salt_t
*salt
= hash_buf
->salt
;
12808 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12811 * Parse that strange long line
12816 size_t in_len
[9] = { 0 };
12818 in_off
[0] = strtok (input_buf
, ":");
12820 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12822 in_len
[0] = strlen (in_off
[0]);
12826 for (i
= 1; i
< 9; i
++)
12828 in_off
[i
] = strtok (NULL
, ":");
12830 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12832 in_len
[i
] = strlen (in_off
[i
]);
12835 char *ptr
= (char *) ikepsk
->msg_buf
;
12837 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12838 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12839 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12840 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12841 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12842 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12846 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12848 ptr
= (char *) ikepsk
->nr_buf
;
12850 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12851 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12855 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12858 * Store to database
12863 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12864 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12865 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12866 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12867 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12869 salt
->salt_len
= 32;
12871 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12872 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12873 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12874 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12875 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12876 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12877 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12878 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12880 return (PARSER_OK
);
12883 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12885 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12887 u32
*digest
= (u32
*) hash_buf
->digest
;
12889 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12890 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12891 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12892 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12893 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12895 digest
[0] = byte_swap_32 (digest
[0]);
12896 digest
[1] = byte_swap_32 (digest
[1]);
12897 digest
[2] = byte_swap_32 (digest
[2]);
12898 digest
[3] = byte_swap_32 (digest
[3]);
12899 digest
[4] = byte_swap_32 (digest
[4]);
12901 return (PARSER_OK
);
12904 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12906 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12908 u32
*digest
= (u32
*) hash_buf
->digest
;
12910 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12911 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12912 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12913 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12914 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12915 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12916 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12917 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12918 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12919 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12920 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12921 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12922 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12923 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12924 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12925 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12927 return (PARSER_OK
);
12930 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12932 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12934 u32
*digest
= (u32
*) hash_buf
->digest
;
12936 salt_t
*salt
= hash_buf
->salt
;
12938 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12939 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12940 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12941 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12942 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12944 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12946 uint salt_len
= input_len
- 40 - 1;
12948 char *salt_buf
= input_buf
+ 40 + 1;
12950 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12952 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12954 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12956 salt
->salt_len
= salt_len
;
12958 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12960 return (PARSER_OK
);
12963 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12965 u32
*digest
= (u32
*) hash_buf
->digest
;
12967 salt_t
*salt
= hash_buf
->salt
;
12969 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12971 if (input_len
== 0)
12973 log_error ("TrueCrypt container not specified");
12978 FILE *fp
= fopen (input_buf
, "rb");
12982 log_error ("%s: %s", input_buf
, strerror (errno
));
12987 char buf
[512] = { 0 };
12989 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12993 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12995 memcpy (tc
->salt_buf
, buf
, 64);
12997 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12999 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13001 salt
->salt_len
= 4;
13003 salt
->salt_iter
= ROUNDS_TRUECRYPT_1K
- 1;
13005 tc
->signature
= 0x45555254; // "TRUE"
13007 digest
[0] = tc
->data_buf
[0];
13009 return (PARSER_OK
);
13012 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13014 u32
*digest
= (u32
*) hash_buf
->digest
;
13016 salt_t
*salt
= hash_buf
->salt
;
13018 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13020 if (input_len
== 0)
13022 log_error ("TrueCrypt container not specified");
13027 FILE *fp
= fopen (input_buf
, "rb");
13031 log_error ("%s: %s", input_buf
, strerror (errno
));
13036 char buf
[512] = { 0 };
13038 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13042 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13044 memcpy (tc
->salt_buf
, buf
, 64);
13046 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13048 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13050 salt
->salt_len
= 4;
13052 salt
->salt_iter
= ROUNDS_TRUECRYPT_2K
- 1;
13054 tc
->signature
= 0x45555254; // "TRUE"
13056 digest
[0] = tc
->data_buf
[0];
13058 return (PARSER_OK
);
13061 int veracrypt_parse_hash_200000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13063 u32
*digest
= (u32
*) hash_buf
->digest
;
13065 salt_t
*salt
= hash_buf
->salt
;
13067 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13069 if (input_len
== 0)
13071 log_error ("VeraCrypt container not specified");
13076 FILE *fp
= fopen (input_buf
, "rb");
13080 log_error ("%s: %s", input_buf
, strerror (errno
));
13085 char buf
[512] = { 0 };
13087 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13091 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13093 memcpy (tc
->salt_buf
, buf
, 64);
13095 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13097 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13099 salt
->salt_len
= 4;
13101 salt
->salt_iter
= ROUNDS_VERACRYPT_200000
- 1;
13103 tc
->signature
= 0x41524556; // "VERA"
13105 digest
[0] = tc
->data_buf
[0];
13107 return (PARSER_OK
);
13110 int veracrypt_parse_hash_500000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13112 u32
*digest
= (u32
*) hash_buf
->digest
;
13114 salt_t
*salt
= hash_buf
->salt
;
13116 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13118 if (input_len
== 0)
13120 log_error ("VeraCrypt container not specified");
13125 FILE *fp
= fopen (input_buf
, "rb");
13129 log_error ("%s: %s", input_buf
, strerror (errno
));
13134 char buf
[512] = { 0 };
13136 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13140 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13142 memcpy (tc
->salt_buf
, buf
, 64);
13144 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13146 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13148 salt
->salt_len
= 4;
13150 salt
->salt_iter
= ROUNDS_VERACRYPT_500000
- 1;
13152 tc
->signature
= 0x41524556; // "VERA"
13154 digest
[0] = tc
->data_buf
[0];
13156 return (PARSER_OK
);
13159 int veracrypt_parse_hash_327661 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13161 u32
*digest
= (u32
*) hash_buf
->digest
;
13163 salt_t
*salt
= hash_buf
->salt
;
13165 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13167 if (input_len
== 0)
13169 log_error ("VeraCrypt container not specified");
13174 FILE *fp
= fopen (input_buf
, "rb");
13178 log_error ("%s: %s", input_buf
, strerror (errno
));
13183 char buf
[512] = { 0 };
13185 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13189 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13191 memcpy (tc
->salt_buf
, buf
, 64);
13193 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13195 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13197 salt
->salt_len
= 4;
13199 salt
->salt_iter
= ROUNDS_VERACRYPT_327661
- 1;
13201 tc
->signature
= 0x41524556; // "VERA"
13203 digest
[0] = tc
->data_buf
[0];
13205 return (PARSER_OK
);
13208 int veracrypt_parse_hash_655331 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13210 u32
*digest
= (u32
*) hash_buf
->digest
;
13212 salt_t
*salt
= hash_buf
->salt
;
13214 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13216 if (input_len
== 0)
13218 log_error ("VeraCrypt container not specified");
13223 FILE *fp
= fopen (input_buf
, "rb");
13227 log_error ("%s: %s", input_buf
, strerror (errno
));
13232 char buf
[512] = { 0 };
13234 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13238 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13240 memcpy (tc
->salt_buf
, buf
, 64);
13242 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13244 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13246 salt
->salt_len
= 4;
13248 salt
->salt_iter
= ROUNDS_VERACRYPT_655331
- 1;
13250 tc
->signature
= 0x41524556; // "VERA"
13252 digest
[0] = tc
->data_buf
[0];
13254 return (PARSER_OK
);
13257 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13259 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
13261 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13263 u32
*digest
= (u32
*) hash_buf
->digest
;
13265 salt_t
*salt
= hash_buf
->salt
;
13267 char *salt_pos
= input_buf
+ 6;
13269 char *hash_pos
= strchr (salt_pos
, '$');
13271 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13273 uint salt_len
= hash_pos
- salt_pos
;
13275 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
13277 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13279 salt
->salt_len
= salt_len
;
13281 salt
->salt_iter
= 1000;
13285 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13287 return (PARSER_OK
);
13290 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13292 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
13294 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
13296 u32
*digest
= (u32
*) hash_buf
->digest
;
13298 salt_t
*salt
= hash_buf
->salt
;
13300 char *iter_pos
= input_buf
+ 7;
13302 char *salt_pos
= strchr (iter_pos
, '$');
13304 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13308 char *hash_pos
= strchr (salt_pos
, '$');
13310 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13312 uint salt_len
= hash_pos
- salt_pos
;
13314 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13316 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13318 salt
->salt_len
= salt_len
;
13320 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13322 salt
->salt_sign
[0] = atoi (salt_iter
);
13324 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13328 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13330 digest
[0] = byte_swap_32 (digest
[0]);
13331 digest
[1] = byte_swap_32 (digest
[1]);
13332 digest
[2] = byte_swap_32 (digest
[2]);
13333 digest
[3] = byte_swap_32 (digest
[3]);
13334 digest
[4] = byte_swap_32 (digest
[4]);
13336 return (PARSER_OK
);
13339 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13341 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
13343 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13345 u32
*digest
= (u32
*) hash_buf
->digest
;
13347 salt_t
*salt
= hash_buf
->salt
;
13349 char *iter_pos
= input_buf
+ 9;
13351 char *salt_pos
= strchr (iter_pos
, '$');
13353 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13357 char *hash_pos
= strchr (salt_pos
, '$');
13359 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13361 uint salt_len
= hash_pos
- salt_pos
;
13363 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13365 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13367 salt
->salt_len
= salt_len
;
13369 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13371 salt
->salt_sign
[0] = atoi (salt_iter
);
13373 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13377 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13379 digest
[0] = byte_swap_32 (digest
[0]);
13380 digest
[1] = byte_swap_32 (digest
[1]);
13381 digest
[2] = byte_swap_32 (digest
[2]);
13382 digest
[3] = byte_swap_32 (digest
[3]);
13383 digest
[4] = byte_swap_32 (digest
[4]);
13384 digest
[5] = byte_swap_32 (digest
[5]);
13385 digest
[6] = byte_swap_32 (digest
[6]);
13386 digest
[7] = byte_swap_32 (digest
[7]);
13388 return (PARSER_OK
);
13391 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13393 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
13395 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13397 u64
*digest
= (u64
*) hash_buf
->digest
;
13399 salt_t
*salt
= hash_buf
->salt
;
13401 char *iter_pos
= input_buf
+ 9;
13403 char *salt_pos
= strchr (iter_pos
, '$');
13405 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13409 char *hash_pos
= strchr (salt_pos
, '$');
13411 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13413 uint salt_len
= hash_pos
- salt_pos
;
13415 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13417 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13419 salt
->salt_len
= salt_len
;
13421 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13423 salt
->salt_sign
[0] = atoi (salt_iter
);
13425 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13429 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13431 digest
[0] = byte_swap_64 (digest
[0]);
13432 digest
[1] = byte_swap_64 (digest
[1]);
13433 digest
[2] = byte_swap_64 (digest
[2]);
13434 digest
[3] = byte_swap_64 (digest
[3]);
13435 digest
[4] = byte_swap_64 (digest
[4]);
13436 digest
[5] = byte_swap_64 (digest
[5]);
13437 digest
[6] = byte_swap_64 (digest
[6]);
13438 digest
[7] = byte_swap_64 (digest
[7]);
13440 return (PARSER_OK
);
13443 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13445 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
13447 u32
*digest
= (u32
*) hash_buf
->digest
;
13449 salt_t
*salt
= hash_buf
->salt
;
13451 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
13457 char *iterations_pos
= input_buf
;
13459 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13461 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13463 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13465 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13469 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13471 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13473 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13475 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13477 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13479 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13484 * pbkdf2 iterations
13487 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13490 * handle salt encoding
13493 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13495 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13497 const char p0
= saltbuf_pos
[i
+ 0];
13498 const char p1
= saltbuf_pos
[i
+ 1];
13500 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13501 | hex_convert (p0
) << 4;
13504 salt
->salt_len
= saltbuf_len
/ 2;
13507 * handle cipher encoding
13510 uint
*tmp
= (uint
*) mymalloc (32);
13512 char *cipherbuf_ptr
= (char *) tmp
;
13514 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13516 const char p0
= cipherbuf_pos
[i
+ 0];
13517 const char p1
= cipherbuf_pos
[i
+ 1];
13519 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13520 | hex_convert (p0
) << 4;
13523 // iv is stored at salt_buf 4 (length 16)
13524 // data is stored at salt_buf 8 (length 16)
13526 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13527 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13528 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13529 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13531 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13532 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13533 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13534 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13538 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13540 const char p0
= cipherbuf_pos
[j
+ 0];
13541 const char p1
= cipherbuf_pos
[j
+ 1];
13543 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13544 | hex_convert (p0
) << 4;
13551 digest
[0] = 0x10101010;
13552 digest
[1] = 0x10101010;
13553 digest
[2] = 0x10101010;
13554 digest
[3] = 0x10101010;
13556 return (PARSER_OK
);
13559 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13561 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13563 u32
*digest
= (u32
*) hash_buf
->digest
;
13565 salt_t
*salt
= hash_buf
->salt
;
13567 char *hashbuf_pos
= input_buf
;
13569 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13571 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13573 uint hash_len
= iterations_pos
- hashbuf_pos
;
13575 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13579 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13581 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13583 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13587 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13589 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13591 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13593 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13595 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13597 salt
->salt_len
= salt_len
;
13599 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13601 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13602 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13603 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13604 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13606 return (PARSER_OK
);
13609 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13611 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13613 u32
*digest
= (u32
*) hash_buf
->digest
;
13615 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13616 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13617 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13618 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13619 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13620 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13621 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13622 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13624 digest
[0] = byte_swap_32 (digest
[0]);
13625 digest
[1] = byte_swap_32 (digest
[1]);
13626 digest
[2] = byte_swap_32 (digest
[2]);
13627 digest
[3] = byte_swap_32 (digest
[3]);
13628 digest
[4] = byte_swap_32 (digest
[4]);
13629 digest
[5] = byte_swap_32 (digest
[5]);
13630 digest
[6] = byte_swap_32 (digest
[6]);
13631 digest
[7] = byte_swap_32 (digest
[7]);
13633 return (PARSER_OK
);
13636 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13638 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13640 u32
*digest
= (u32
*) hash_buf
->digest
;
13642 salt_t
*salt
= hash_buf
->salt
;
13644 char *salt_pos
= input_buf
+ 3;
13646 uint iterations_len
= 0;
13648 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13652 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13654 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13655 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13659 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13663 iterations_len
+= 8;
13667 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13670 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13672 char *hash_pos
= strchr (salt_pos
, '$');
13674 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13676 uint salt_len
= hash_pos
- salt_pos
;
13678 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13680 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13682 salt
->salt_len
= salt_len
;
13686 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13688 return (PARSER_OK
);
13691 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13693 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13695 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13697 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13699 u64
*digest
= (u64
*) hash_buf
->digest
;
13701 salt_t
*salt
= hash_buf
->salt
;
13703 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13705 char *iter_pos
= input_buf
+ 4;
13707 char *salt_pos
= strchr (iter_pos
, '$');
13709 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13713 char *hash_pos
= strchr (salt_pos
, '$');
13715 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13717 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13721 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13722 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13723 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13724 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13725 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13726 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13727 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13728 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13730 uint salt_len
= hash_pos
- salt_pos
- 1;
13732 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13734 salt
->salt_len
= salt_len
/ 2;
13736 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13737 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13738 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13739 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13740 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13741 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13742 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13743 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13745 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13746 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13747 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13748 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13749 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13750 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13751 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13752 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13753 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13754 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13756 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13758 salt
->salt_iter
= atoi (iter_pos
) - 1;
13760 return (PARSER_OK
);
13763 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13765 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13767 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13769 u32
*digest
= (u32
*) hash_buf
->digest
;
13771 salt_t
*salt
= hash_buf
->salt
;
13773 char *salt_pos
= input_buf
+ 14;
13775 char *hash_pos
= strchr (salt_pos
, '*');
13777 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13781 uint salt_len
= hash_pos
- salt_pos
- 1;
13783 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13785 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13787 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13789 salt
->salt_len
= salt_len
;
13791 u8 tmp_buf
[100] = { 0 };
13793 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13795 memcpy (digest
, tmp_buf
, 32);
13797 digest
[0] = byte_swap_32 (digest
[0]);
13798 digest
[1] = byte_swap_32 (digest
[1]);
13799 digest
[2] = byte_swap_32 (digest
[2]);
13800 digest
[3] = byte_swap_32 (digest
[3]);
13801 digest
[4] = byte_swap_32 (digest
[4]);
13802 digest
[5] = byte_swap_32 (digest
[5]);
13803 digest
[6] = byte_swap_32 (digest
[6]);
13804 digest
[7] = byte_swap_32 (digest
[7]);
13806 digest
[0] -= SHA256M_A
;
13807 digest
[1] -= SHA256M_B
;
13808 digest
[2] -= SHA256M_C
;
13809 digest
[3] -= SHA256M_D
;
13810 digest
[4] -= SHA256M_E
;
13811 digest
[5] -= SHA256M_F
;
13812 digest
[6] -= SHA256M_G
;
13813 digest
[7] -= SHA256M_H
;
13815 return (PARSER_OK
);
13818 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13820 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13822 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13824 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13826 u64
*digest
= (u64
*) hash_buf
->digest
;
13828 salt_t
*salt
= hash_buf
->salt
;
13830 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13832 char *iter_pos
= input_buf
+ 19;
13834 char *salt_pos
= strchr (iter_pos
, '.');
13836 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13840 char *hash_pos
= strchr (salt_pos
, '.');
13842 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13844 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13848 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13849 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13850 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13851 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13852 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13853 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13854 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13855 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13857 uint salt_len
= hash_pos
- salt_pos
- 1;
13861 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13865 for (i
= 0; i
< salt_len
; i
++)
13867 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13870 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13871 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13873 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13875 salt
->salt_len
= salt_len
;
13877 salt
->salt_iter
= atoi (iter_pos
) - 1;
13879 return (PARSER_OK
);
13882 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13884 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13886 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13888 u64
*digest
= (u64
*) hash_buf
->digest
;
13890 salt_t
*salt
= hash_buf
->salt
;
13892 u8 tmp_buf
[120] = { 0 };
13894 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13896 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13898 memcpy (digest
, tmp_buf
, 64);
13900 digest
[0] = byte_swap_64 (digest
[0]);
13901 digest
[1] = byte_swap_64 (digest
[1]);
13902 digest
[2] = byte_swap_64 (digest
[2]);
13903 digest
[3] = byte_swap_64 (digest
[3]);
13904 digest
[4] = byte_swap_64 (digest
[4]);
13905 digest
[5] = byte_swap_64 (digest
[5]);
13906 digest
[6] = byte_swap_64 (digest
[6]);
13907 digest
[7] = byte_swap_64 (digest
[7]);
13909 digest
[0] -= SHA512M_A
;
13910 digest
[1] -= SHA512M_B
;
13911 digest
[2] -= SHA512M_C
;
13912 digest
[3] -= SHA512M_D
;
13913 digest
[4] -= SHA512M_E
;
13914 digest
[5] -= SHA512M_F
;
13915 digest
[6] -= SHA512M_G
;
13916 digest
[7] -= SHA512M_H
;
13918 int salt_len
= tmp_len
- 64;
13920 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13922 salt
->salt_len
= salt_len
;
13924 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13926 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13928 char *ptr
= (char *) salt
->salt_buf
;
13930 ptr
[salt
->salt_len
] = 0x80;
13933 return (PARSER_OK
);
13936 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13938 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13940 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13944 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13947 u32
*digest
= (u32
*) hash_buf
->digest
;
13949 salt_t
*salt
= hash_buf
->salt
;
13951 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13952 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13953 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13954 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13956 digest
[0] = byte_swap_32 (digest
[0]);
13957 digest
[1] = byte_swap_32 (digest
[1]);
13958 digest
[2] = byte_swap_32 (digest
[2]);
13959 digest
[3] = byte_swap_32 (digest
[3]);
13961 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13963 uint salt_len
= input_len
- 32 - 1;
13965 char *salt_buf
= input_buf
+ 32 + 1;
13967 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13969 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13971 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13973 salt
->salt_len
= salt_len
;
13975 return (PARSER_OK
);
13978 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13980 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13982 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13986 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13989 u32
*digest
= (u32
*) hash_buf
->digest
;
13991 salt_t
*salt
= hash_buf
->salt
;
13993 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13994 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13995 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13996 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13997 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13999 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14001 uint salt_len
= input_len
- 40 - 1;
14003 char *salt_buf
= input_buf
+ 40 + 1;
14005 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14007 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14009 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14011 salt
->salt_len
= salt_len
;
14013 return (PARSER_OK
);
14016 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14018 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14020 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
14024 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
14027 u32
*digest
= (u32
*) hash_buf
->digest
;
14029 salt_t
*salt
= hash_buf
->salt
;
14031 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14032 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14033 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14034 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14035 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14036 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
14037 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
14038 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
14040 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14042 uint salt_len
= input_len
- 64 - 1;
14044 char *salt_buf
= input_buf
+ 64 + 1;
14046 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14048 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14050 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14052 salt
->salt_len
= salt_len
;
14054 return (PARSER_OK
);
14057 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14059 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14061 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
14065 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
14068 u64
*digest
= (u64
*) hash_buf
->digest
;
14070 salt_t
*salt
= hash_buf
->salt
;
14072 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
14073 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
14074 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
14075 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
14076 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
14077 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
14078 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
14079 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
14081 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14083 uint salt_len
= input_len
- 128 - 1;
14085 char *salt_buf
= input_buf
+ 128 + 1;
14087 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14089 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14091 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14093 salt
->salt_len
= salt_len
;
14095 return (PARSER_OK
);
14098 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14100 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
14102 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
14104 u32
*digest
= (u32
*) hash_buf
->digest
;
14106 salt_t
*salt
= hash_buf
->salt
;
14108 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
14114 char *user_pos
= input_buf
+ 10 + 1;
14116 char *realm_pos
= strchr (user_pos
, '$');
14118 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14120 uint user_len
= realm_pos
- user_pos
;
14122 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
14126 char *salt_pos
= strchr (realm_pos
, '$');
14128 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14130 uint realm_len
= salt_pos
- realm_pos
;
14132 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
14136 char *data_pos
= strchr (salt_pos
, '$');
14138 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14140 uint salt_len
= data_pos
- salt_pos
;
14142 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
14146 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
14148 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
14154 memcpy (krb5pa
->user
, user_pos
, user_len
);
14155 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
14156 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
14158 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
14160 for (uint i
= 0; i
< (36 * 2); i
+= 2)
14162 const char p0
= data_pos
[i
+ 0];
14163 const char p1
= data_pos
[i
+ 1];
14165 *timestamp_ptr
++ = hex_convert (p1
) << 0
14166 | hex_convert (p0
) << 4;
14169 char *checksum_ptr
= (char *) krb5pa
->checksum
;
14171 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
14173 const char p0
= data_pos
[i
+ 0];
14174 const char p1
= data_pos
[i
+ 1];
14176 *checksum_ptr
++ = hex_convert (p1
) << 0
14177 | hex_convert (p0
) << 4;
14181 * copy some data to generic buffers to make sorting happy
14184 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
14185 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
14186 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
14187 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
14188 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
14189 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
14190 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
14191 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
14192 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
14194 salt
->salt_len
= 36;
14196 digest
[0] = krb5pa
->checksum
[0];
14197 digest
[1] = krb5pa
->checksum
[1];
14198 digest
[2] = krb5pa
->checksum
[2];
14199 digest
[3] = krb5pa
->checksum
[3];
14201 return (PARSER_OK
);
14204 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14206 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
14208 u32
*digest
= (u32
*) hash_buf
->digest
;
14210 salt_t
*salt
= hash_buf
->salt
;
14216 char *salt_pos
= input_buf
;
14218 char *hash_pos
= strchr (salt_pos
, '$');
14220 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14222 uint salt_len
= hash_pos
- salt_pos
;
14224 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14228 uint hash_len
= input_len
- 1 - salt_len
;
14230 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14238 for (uint i
= 0; i
< salt_len
; i
++)
14240 if (salt_pos
[i
] == ' ') continue;
14245 // SAP user names cannot be longer than 12 characters
14246 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14248 // SAP user name cannot start with ! or ?
14249 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14255 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14257 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14259 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14261 salt
->salt_len
= salt_len
;
14263 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
14264 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
14268 digest
[0] = byte_swap_32 (digest
[0]);
14269 digest
[1] = byte_swap_32 (digest
[1]);
14271 return (PARSER_OK
);
14274 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14276 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
14278 u32
*digest
= (u32
*) hash_buf
->digest
;
14280 salt_t
*salt
= hash_buf
->salt
;
14286 char *salt_pos
= input_buf
;
14288 char *hash_pos
= strchr (salt_pos
, '$');
14290 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14292 uint salt_len
= hash_pos
- salt_pos
;
14294 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14298 uint hash_len
= input_len
- 1 - salt_len
;
14300 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
14308 for (uint i
= 0; i
< salt_len
; i
++)
14310 if (salt_pos
[i
] == ' ') continue;
14315 // SAP user names cannot be longer than 12 characters
14316 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
14317 // so far nobody complained so we stay with this because it helps in optimization
14318 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
14320 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14322 // SAP user name cannot start with ! or ?
14323 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14329 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14331 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14333 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14335 salt
->salt_len
= salt_len
;
14337 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14338 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14339 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14340 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14341 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14343 return (PARSER_OK
);
14346 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14348 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
14350 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14352 u64
*digest
= (u64
*) hash_buf
->digest
;
14354 salt_t
*salt
= hash_buf
->salt
;
14356 char *iter_pos
= input_buf
+ 3;
14358 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
14360 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
14362 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
14364 salt
->salt_iter
= salt_iter
;
14366 char *salt_pos
= iter_pos
+ 1;
14370 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
14372 salt
->salt_len
= salt_len
;
14374 char *hash_pos
= salt_pos
+ salt_len
;
14376 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14380 char *tmp
= (char *) salt
->salt_buf_pc
;
14382 tmp
[0] = hash_pos
[42];
14386 digest
[ 0] = byte_swap_64 (digest
[ 0]);
14387 digest
[ 1] = byte_swap_64 (digest
[ 1]);
14388 digest
[ 2] = byte_swap_64 (digest
[ 2]);
14389 digest
[ 3] = byte_swap_64 (digest
[ 3]);
14395 return (PARSER_OK
);
14398 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14400 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
14402 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14404 u32
*digest
= (u32
*) hash_buf
->digest
;
14406 salt_t
*salt
= hash_buf
->salt
;
14408 char *salt_buf
= input_buf
+ 6;
14410 uint salt_len
= 16;
14412 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14414 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14416 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14418 salt
->salt_len
= salt_len
;
14420 char *hash_pos
= input_buf
+ 6 + 16;
14422 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14423 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14424 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14425 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14426 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14427 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
14428 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
14429 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
14431 return (PARSER_OK
);
14434 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14436 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
14438 u32
*digest
= (u32
*) hash_buf
->digest
;
14440 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14441 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14445 return (PARSER_OK
);
14448 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14450 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
14452 u32
*digest
= (u32
*) hash_buf
->digest
;
14454 salt_t
*salt
= hash_buf
->salt
;
14456 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
14458 char *saltbuf_pos
= input_buf
;
14460 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
14462 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14464 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14466 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14467 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14469 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14473 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14475 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14477 char *salt_ptr
= (char *) saltbuf_pos
;
14478 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14483 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14485 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14488 rakp_ptr
[j
] = 0x80;
14490 rakp
->salt_len
= j
;
14492 for (i
= 0; i
< 64; i
++)
14494 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14497 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14498 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14499 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14500 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14501 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14502 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14503 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14504 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14506 salt
->salt_len
= 32; // muss min. 32 haben
14508 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14509 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14510 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14511 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14512 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14514 return (PARSER_OK
);
14517 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14519 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14521 u32
*digest
= (u32
*) hash_buf
->digest
;
14523 salt_t
*salt
= hash_buf
->salt
;
14525 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14527 char *salt_pos
= input_buf
+ 1;
14529 memcpy (salt
->salt_buf
, salt_pos
, 8);
14531 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14532 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14534 salt
->salt_len
= 8;
14536 char *hash_pos
= salt_pos
+ 8;
14538 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14539 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14540 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14541 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14542 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14544 digest
[0] -= SHA1M_A
;
14545 digest
[1] -= SHA1M_B
;
14546 digest
[2] -= SHA1M_C
;
14547 digest
[3] -= SHA1M_D
;
14548 digest
[4] -= SHA1M_E
;
14550 return (PARSER_OK
);
14553 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14555 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14557 u32
*digest
= (u32
*) hash_buf
->digest
;
14559 salt_t
*salt
= hash_buf
->salt
;
14561 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14562 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14563 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14564 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14566 digest
[0] = byte_swap_32 (digest
[0]);
14567 digest
[1] = byte_swap_32 (digest
[1]);
14568 digest
[2] = byte_swap_32 (digest
[2]);
14569 digest
[3] = byte_swap_32 (digest
[3]);
14571 digest
[0] -= MD5M_A
;
14572 digest
[1] -= MD5M_B
;
14573 digest
[2] -= MD5M_C
;
14574 digest
[3] -= MD5M_D
;
14576 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14578 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14580 u32
*salt_buf
= salt
->salt_buf
;
14582 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14583 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14584 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14585 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14587 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14588 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14589 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14590 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14592 salt
->salt_len
= 16 + 1;
14594 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14596 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14598 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14600 return (PARSER_OK
);
14603 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14605 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14607 u32
*digest
= (u32
*) hash_buf
->digest
;
14609 salt_t
*salt
= hash_buf
->salt
;
14611 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14617 char *hashbuf_pos
= input_buf
;
14619 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14621 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14623 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14625 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14629 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14631 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14633 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14635 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14639 char *databuf_pos
= strchr (iteration_pos
, ':');
14641 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14643 const uint iteration_len
= databuf_pos
- iteration_pos
;
14645 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14646 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14648 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14650 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14651 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14657 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14658 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14659 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14660 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14661 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14662 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14663 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14664 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14668 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14670 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14672 const char p0
= saltbuf_pos
[i
+ 0];
14673 const char p1
= saltbuf_pos
[i
+ 1];
14675 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14676 | hex_convert (p0
) << 4;
14679 salt
->salt_buf
[4] = 0x01000000;
14680 salt
->salt_buf
[5] = 0x80;
14682 salt
->salt_len
= saltbuf_len
/ 2;
14686 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14690 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14692 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14694 const char p0
= databuf_pos
[i
+ 0];
14695 const char p1
= databuf_pos
[i
+ 1];
14697 *databuf_ptr
++ = hex_convert (p1
) << 0
14698 | hex_convert (p0
) << 4;
14701 *databuf_ptr
++ = 0x80;
14703 for (uint i
= 0; i
< 512; i
++)
14705 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14708 cloudkey
->data_len
= databuf_len
/ 2;
14710 return (PARSER_OK
);
14713 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14715 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14717 u32
*digest
= (u32
*) hash_buf
->digest
;
14719 salt_t
*salt
= hash_buf
->salt
;
14725 char *hashbuf_pos
= input_buf
;
14727 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14729 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14731 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14733 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14737 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14739 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14741 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14743 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14745 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14749 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14751 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14753 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14755 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14757 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14761 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14763 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14764 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14766 // ok, the plan for this algorithm is the following:
14767 // we have 2 salts here, the domain-name and a random salt
14768 // while both are used in the initial transformation,
14769 // only the random salt is used in the following iterations
14770 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14771 // and one that includes only the real salt (stored into salt_buf[]).
14772 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14774 u8 tmp_buf
[100] = { 0 };
14776 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14778 memcpy (digest
, tmp_buf
, 20);
14780 digest
[0] = byte_swap_32 (digest
[0]);
14781 digest
[1] = byte_swap_32 (digest
[1]);
14782 digest
[2] = byte_swap_32 (digest
[2]);
14783 digest
[3] = byte_swap_32 (digest
[3]);
14784 digest
[4] = byte_swap_32 (digest
[4]);
14788 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14790 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14792 char *len_ptr
= NULL
;
14794 for (uint i
= 0; i
< domainbuf_len
; i
++)
14796 if (salt_buf_pc_ptr
[i
] == '.')
14798 len_ptr
= &salt_buf_pc_ptr
[i
];
14808 salt
->salt_buf_pc
[7] = domainbuf_len
;
14812 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14814 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14816 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14818 salt
->salt_len
= salt_len
;
14822 salt
->salt_iter
= atoi (iteration_pos
);
14824 return (PARSER_OK
);
14827 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14829 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14831 u32
*digest
= (u32
*) hash_buf
->digest
;
14833 salt_t
*salt
= hash_buf
->salt
;
14835 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14836 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14837 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14838 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14839 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14841 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14843 uint salt_len
= input_len
- 40 - 1;
14845 char *salt_buf
= input_buf
+ 40 + 1;
14847 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14849 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14851 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14853 salt
->salt_len
= salt_len
;
14855 return (PARSER_OK
);
14858 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14860 const u8 ascii_to_ebcdic
[] =
14862 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14863 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14864 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14865 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14866 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14867 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14868 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14869 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14870 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14871 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14872 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14873 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14874 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14875 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14876 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14877 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14880 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14882 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14884 u32
*digest
= (u32
*) hash_buf
->digest
;
14886 salt_t
*salt
= hash_buf
->salt
;
14888 char *salt_pos
= input_buf
+ 6 + 1;
14890 char *digest_pos
= strchr (salt_pos
, '*');
14892 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14894 uint salt_len
= digest_pos
- salt_pos
;
14896 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14898 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14900 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14904 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14905 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14907 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14909 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14911 salt
->salt_len
= salt_len
;
14913 for (uint i
= 0; i
< salt_len
; i
++)
14915 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14917 for (uint i
= salt_len
; i
< 8; i
++)
14919 salt_buf_pc_ptr
[i
] = 0x40;
14924 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14926 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14927 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14929 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14930 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14932 digest
[0] = byte_swap_32 (digest
[0]);
14933 digest
[1] = byte_swap_32 (digest
[1]);
14935 IP (digest
[0], digest
[1], tt
);
14937 digest
[0] = rotr32 (digest
[0], 29);
14938 digest
[1] = rotr32 (digest
[1], 29);
14942 return (PARSER_OK
);
14945 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14947 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14949 u32
*digest
= (u32
*) hash_buf
->digest
;
14951 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14952 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14953 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14954 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14956 digest
[0] = byte_swap_32 (digest
[0]);
14957 digest
[1] = byte_swap_32 (digest
[1]);
14958 digest
[2] = byte_swap_32 (digest
[2]);
14959 digest
[3] = byte_swap_32 (digest
[3]);
14961 return (PARSER_OK
);
14964 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14966 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14968 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14970 u32
*digest
= (u32
*) hash_buf
->digest
;
14972 salt_t
*salt
= hash_buf
->salt
;
14974 u8 tmp_buf
[120] = { 0 };
14976 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14978 tmp_buf
[3] += -4; // dont ask!
14980 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14982 salt
->salt_len
= 5;
14984 memcpy (digest
, tmp_buf
+ 5, 9);
14986 // yes, only 9 byte are needed to crack, but 10 to display
14988 salt
->salt_buf_pc
[7] = input_buf
[20];
14990 return (PARSER_OK
);
14993 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14995 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14997 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14999 u32
*digest
= (u32
*) hash_buf
->digest
;
15001 salt_t
*salt
= hash_buf
->salt
;
15003 u8 tmp_buf
[120] = { 0 };
15005 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15007 tmp_buf
[3] += -4; // dont ask!
15011 memcpy (salt
->salt_buf
, tmp_buf
, 16);
15013 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)
15017 char tmp_iter_buf
[11] = { 0 };
15019 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
15021 tmp_iter_buf
[10] = 0;
15023 salt
->salt_iter
= atoi (tmp_iter_buf
);
15025 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
15027 return (PARSER_SALT_ITERATION
);
15030 salt
->salt_iter
--; // first round in init
15032 // 2 additional bytes for display only
15034 salt
->salt_buf_pc
[0] = tmp_buf
[26];
15035 salt
->salt_buf_pc
[1] = tmp_buf
[27];
15039 memcpy (digest
, tmp_buf
+ 28, 8);
15041 digest
[0] = byte_swap_32 (digest
[0]);
15042 digest
[1] = byte_swap_32 (digest
[1]);
15046 return (PARSER_OK
);
15049 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15051 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
15053 u32
*digest
= (u32
*) hash_buf
->digest
;
15055 salt_t
*salt
= hash_buf
->salt
;
15057 char *salt_buf_pos
= input_buf
;
15059 char *hash_buf_pos
= salt_buf_pos
+ 6;
15061 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
15062 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
15063 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
15064 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
15065 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
15066 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
15067 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
15068 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
15070 digest
[0] -= SHA256M_A
;
15071 digest
[1] -= SHA256M_B
;
15072 digest
[2] -= SHA256M_C
;
15073 digest
[3] -= SHA256M_D
;
15074 digest
[4] -= SHA256M_E
;
15075 digest
[5] -= SHA256M_F
;
15076 digest
[6] -= SHA256M_G
;
15077 digest
[7] -= SHA256M_H
;
15079 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15081 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
15083 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15085 salt
->salt_len
= salt_len
;
15087 return (PARSER_OK
);
15090 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15092 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
15094 u32
*digest
= (u32
*) hash_buf
->digest
;
15096 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15098 salt_t
*salt
= hash_buf
->salt
;
15100 char *salt_buf
= input_buf
+ 6;
15102 char *digest_buf
= strchr (salt_buf
, '$');
15104 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15106 uint salt_len
= digest_buf
- salt_buf
;
15108 digest_buf
++; // skip the '$' symbol
15110 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15112 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15114 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15116 salt
->salt_len
= salt_len
;
15118 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15119 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15120 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15121 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15123 digest
[0] = byte_swap_32 (digest
[0]);
15124 digest
[1] = byte_swap_32 (digest
[1]);
15125 digest
[2] = byte_swap_32 (digest
[2]);
15126 digest
[3] = byte_swap_32 (digest
[3]);
15128 digest
[0] -= MD5M_A
;
15129 digest
[1] -= MD5M_B
;
15130 digest
[2] -= MD5M_C
;
15131 digest
[3] -= MD5M_D
;
15133 return (PARSER_OK
);
15136 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15138 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
15140 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15142 u32
*digest
= (u32
*) hash_buf
->digest
;
15144 salt_t
*salt
= hash_buf
->salt
;
15146 char *salt_buf
= input_buf
+ 3;
15148 char *digest_buf
= strchr (salt_buf
, '$');
15150 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15152 uint salt_len
= digest_buf
- salt_buf
;
15154 digest_buf
++; // skip the '$' symbol
15156 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15158 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15160 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15162 salt_buf_ptr
[salt_len
] = 0x2d;
15164 salt
->salt_len
= salt_len
+ 1;
15166 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15167 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15168 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15169 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15171 digest
[0] = byte_swap_32 (digest
[0]);
15172 digest
[1] = byte_swap_32 (digest
[1]);
15173 digest
[2] = byte_swap_32 (digest
[2]);
15174 digest
[3] = byte_swap_32 (digest
[3]);
15176 digest
[0] -= MD5M_A
;
15177 digest
[1] -= MD5M_B
;
15178 digest
[2] -= MD5M_C
;
15179 digest
[3] -= MD5M_D
;
15181 return (PARSER_OK
);
15184 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15186 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
15188 u32
*digest
= (u32
*) hash_buf
->digest
;
15190 salt_t
*salt
= hash_buf
->salt
;
15192 u8 tmp_buf
[100] = { 0 };
15194 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
15196 memcpy (digest
, tmp_buf
, 20);
15198 digest
[0] = byte_swap_32 (digest
[0]);
15199 digest
[1] = byte_swap_32 (digest
[1]);
15200 digest
[2] = byte_swap_32 (digest
[2]);
15201 digest
[3] = byte_swap_32 (digest
[3]);
15202 digest
[4] = byte_swap_32 (digest
[4]);
15204 digest
[0] -= SHA1M_A
;
15205 digest
[1] -= SHA1M_B
;
15206 digest
[2] -= SHA1M_C
;
15207 digest
[3] -= SHA1M_D
;
15208 digest
[4] -= SHA1M_E
;
15210 salt
->salt_buf
[0] = 0x80;
15212 salt
->salt_len
= 0;
15214 return (PARSER_OK
);
15217 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15219 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
15221 u32
*digest
= (u32
*) hash_buf
->digest
;
15223 salt_t
*salt
= hash_buf
->salt
;
15225 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15226 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15227 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15228 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15230 digest
[0] = byte_swap_32 (digest
[0]);
15231 digest
[1] = byte_swap_32 (digest
[1]);
15232 digest
[2] = byte_swap_32 (digest
[2]);
15233 digest
[3] = byte_swap_32 (digest
[3]);
15235 digest
[0] -= MD5M_A
;
15236 digest
[1] -= MD5M_B
;
15237 digest
[2] -= MD5M_C
;
15238 digest
[3] -= MD5M_D
;
15240 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15242 uint salt_len
= input_len
- 32 - 1;
15244 char *salt_buf
= input_buf
+ 32 + 1;
15246 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15248 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15250 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15253 * add static "salt" part
15256 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
15260 salt
->salt_len
= salt_len
;
15262 return (PARSER_OK
);
15265 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15267 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
15269 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
15271 u32
*digest
= (u32
*) hash_buf
->digest
;
15273 salt_t
*salt
= hash_buf
->salt
;
15275 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
15281 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
15283 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
15285 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15287 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
15289 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
15293 char *keylen_pos
= strchr (saltbuf_pos
, '$');
15295 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15297 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
15299 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15303 char *keybuf_pos
= strchr (keylen_pos
, '$');
15305 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15307 uint keylen_len
= keybuf_pos
- keylen_pos
;
15309 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
15313 char *databuf_pos
= strchr (keybuf_pos
, '$');
15315 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15317 uint keybuf_len
= databuf_pos
- keybuf_pos
;
15319 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15323 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
15325 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
15331 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
15332 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
15333 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
15334 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
15336 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
15337 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
15338 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
15339 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
15341 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15342 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15343 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15344 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15346 salt
->salt_len
= 16;
15347 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
15349 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
15351 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
15354 return (PARSER_OK
);
15357 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15359 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
15361 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15363 u32
*digest
= (u32
*) hash_buf
->digest
;
15365 salt_t
*salt
= hash_buf
->salt
;
15371 // first is the N salt parameter
15373 char *N_pos
= input_buf
+ 6;
15375 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15379 salt
->scrypt_N
= atoi (N_pos
);
15383 char *r_pos
= strchr (N_pos
, ':');
15385 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15389 salt
->scrypt_r
= atoi (r_pos
);
15393 char *p_pos
= strchr (r_pos
, ':');
15395 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15399 salt
->scrypt_p
= atoi (p_pos
);
15403 char *saltbuf_pos
= strchr (p_pos
, ':');
15405 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15409 char *hash_pos
= strchr (saltbuf_pos
, ':');
15411 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15417 int salt_len_base64
= hash_pos
- saltbuf_pos
;
15419 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
15421 u8 tmp_buf
[33] = { 0 };
15423 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
15425 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15427 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
15429 salt
->salt_len
= tmp_len
;
15430 salt
->salt_iter
= 1;
15432 // digest - base64 decode
15434 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15436 tmp_len
= input_len
- (hash_pos
- input_buf
);
15438 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
15440 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
15442 memcpy (digest
, tmp_buf
, 32);
15444 return (PARSER_OK
);
15447 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15449 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
15451 u32
*digest
= (u32
*) hash_buf
->digest
;
15453 salt_t
*salt
= hash_buf
->salt
;
15459 char decrypted
[76] = { 0 }; // iv + hash
15461 juniper_decrypt_hash (input_buf
, decrypted
);
15463 char *md5crypt_hash
= decrypted
+ 12;
15465 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15467 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15469 char *salt_pos
= md5crypt_hash
+ 3;
15471 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15473 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15475 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15479 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15481 return (PARSER_OK
);
15484 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15486 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15488 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15490 u32
*digest
= (u32
*) hash_buf
->digest
;
15492 salt_t
*salt
= hash_buf
->salt
;
15494 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15500 // first is *raw* salt
15502 char *salt_pos
= input_buf
+ 3;
15504 char *hash_pos
= strchr (salt_pos
, '$');
15506 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15508 uint salt_len
= hash_pos
- salt_pos
;
15510 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15514 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15516 memcpy (salt_buf_ptr
, salt_pos
, 14);
15518 salt_buf_ptr
[17] = 0x01;
15519 salt_buf_ptr
[18] = 0x80;
15521 // add some stuff to normal salt to make sorted happy
15523 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15524 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15525 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15526 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15528 salt
->salt_len
= salt_len
;
15529 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15531 // base64 decode hash
15533 u8 tmp_buf
[100] = { 0 };
15535 uint hash_len
= input_len
- 3 - salt_len
- 1;
15537 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15539 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15541 memcpy (digest
, tmp_buf
, 32);
15543 digest
[0] = byte_swap_32 (digest
[0]);
15544 digest
[1] = byte_swap_32 (digest
[1]);
15545 digest
[2] = byte_swap_32 (digest
[2]);
15546 digest
[3] = byte_swap_32 (digest
[3]);
15547 digest
[4] = byte_swap_32 (digest
[4]);
15548 digest
[5] = byte_swap_32 (digest
[5]);
15549 digest
[6] = byte_swap_32 (digest
[6]);
15550 digest
[7] = byte_swap_32 (digest
[7]);
15552 return (PARSER_OK
);
15555 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15557 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15559 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15561 u32
*digest
= (u32
*) hash_buf
->digest
;
15563 salt_t
*salt
= hash_buf
->salt
;
15569 // first is *raw* salt
15571 char *salt_pos
= input_buf
+ 3;
15573 char *hash_pos
= strchr (salt_pos
, '$');
15575 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15577 uint salt_len
= hash_pos
- salt_pos
;
15579 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15581 salt
->salt_len
= salt_len
;
15584 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15586 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15587 salt_buf_ptr
[salt_len
] = 0;
15589 // base64 decode hash
15591 u8 tmp_buf
[100] = { 0 };
15593 uint hash_len
= input_len
- 3 - salt_len
- 1;
15595 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15597 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15599 memcpy (digest
, tmp_buf
, 32);
15602 salt
->scrypt_N
= 16384;
15603 salt
->scrypt_r
= 1;
15604 salt
->scrypt_p
= 1;
15605 salt
->salt_iter
= 1;
15607 return (PARSER_OK
);
15610 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15612 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15614 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15616 u32
*digest
= (u32
*) hash_buf
->digest
;
15618 salt_t
*salt
= hash_buf
->salt
;
15620 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15626 char *version_pos
= input_buf
+ 8 + 1;
15628 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15630 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15632 u32 version_len
= verifierHashSize_pos
- version_pos
;
15634 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15636 verifierHashSize_pos
++;
15638 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15640 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15642 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15644 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15648 char *saltSize_pos
= strchr (keySize_pos
, '*');
15650 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15652 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15654 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15658 char *osalt_pos
= strchr (saltSize_pos
, '*');
15660 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15662 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15664 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15668 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15670 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15672 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15674 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15676 encryptedVerifier_pos
++;
15678 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15680 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15682 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15684 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15686 encryptedVerifierHash_pos
++;
15688 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;
15690 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15692 const uint version
= atoi (version_pos
);
15694 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15696 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15698 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15700 const uint keySize
= atoi (keySize_pos
);
15702 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15704 office2007
->keySize
= keySize
;
15706 const uint saltSize
= atoi (saltSize_pos
);
15708 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15714 salt
->salt_len
= 16;
15715 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15717 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15718 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15719 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15720 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15726 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15727 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15728 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15729 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15731 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15732 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15733 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15734 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15735 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15741 digest
[0] = office2007
->encryptedVerifierHash
[0];
15742 digest
[1] = office2007
->encryptedVerifierHash
[1];
15743 digest
[2] = office2007
->encryptedVerifierHash
[2];
15744 digest
[3] = office2007
->encryptedVerifierHash
[3];
15746 return (PARSER_OK
);
15749 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15751 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15753 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15755 u32
*digest
= (u32
*) hash_buf
->digest
;
15757 salt_t
*salt
= hash_buf
->salt
;
15759 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15765 char *version_pos
= input_buf
+ 8 + 1;
15767 char *spinCount_pos
= strchr (version_pos
, '*');
15769 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15771 u32 version_len
= spinCount_pos
- version_pos
;
15773 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15777 char *keySize_pos
= strchr (spinCount_pos
, '*');
15779 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15781 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15783 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15787 char *saltSize_pos
= strchr (keySize_pos
, '*');
15789 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15791 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15793 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15797 char *osalt_pos
= strchr (saltSize_pos
, '*');
15799 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15801 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15803 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15807 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15809 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15811 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15813 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15815 encryptedVerifier_pos
++;
15817 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15819 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15821 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15823 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15825 encryptedVerifierHash_pos
++;
15827 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;
15829 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15831 const uint version
= atoi (version_pos
);
15833 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15835 const uint spinCount
= atoi (spinCount_pos
);
15837 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15839 const uint keySize
= atoi (keySize_pos
);
15841 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15843 const uint saltSize
= atoi (saltSize_pos
);
15845 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15851 salt
->salt_len
= 16;
15852 salt
->salt_iter
= spinCount
;
15854 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15855 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15856 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15857 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15863 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15864 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15865 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15866 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15868 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15869 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15870 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15871 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15872 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15873 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15874 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15875 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15881 digest
[0] = office2010
->encryptedVerifierHash
[0];
15882 digest
[1] = office2010
->encryptedVerifierHash
[1];
15883 digest
[2] = office2010
->encryptedVerifierHash
[2];
15884 digest
[3] = office2010
->encryptedVerifierHash
[3];
15886 return (PARSER_OK
);
15889 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15891 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15893 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15895 u32
*digest
= (u32
*) hash_buf
->digest
;
15897 salt_t
*salt
= hash_buf
->salt
;
15899 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15905 char *version_pos
= input_buf
+ 8 + 1;
15907 char *spinCount_pos
= strchr (version_pos
, '*');
15909 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15911 u32 version_len
= spinCount_pos
- version_pos
;
15913 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15917 char *keySize_pos
= strchr (spinCount_pos
, '*');
15919 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15921 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15923 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15927 char *saltSize_pos
= strchr (keySize_pos
, '*');
15929 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15931 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15933 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15937 char *osalt_pos
= strchr (saltSize_pos
, '*');
15939 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15941 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15943 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15947 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15949 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15951 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15953 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15955 encryptedVerifier_pos
++;
15957 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15959 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15961 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15963 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15965 encryptedVerifierHash_pos
++;
15967 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;
15969 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15971 const uint version
= atoi (version_pos
);
15973 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15975 const uint spinCount
= atoi (spinCount_pos
);
15977 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15979 const uint keySize
= atoi (keySize_pos
);
15981 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15983 const uint saltSize
= atoi (saltSize_pos
);
15985 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15991 salt
->salt_len
= 16;
15992 salt
->salt_iter
= spinCount
;
15994 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15995 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15996 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15997 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16003 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16004 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16005 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16006 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16008 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16009 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16010 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16011 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16012 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16013 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
16014 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
16015 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
16021 digest
[0] = office2013
->encryptedVerifierHash
[0];
16022 digest
[1] = office2013
->encryptedVerifierHash
[1];
16023 digest
[2] = office2013
->encryptedVerifierHash
[2];
16024 digest
[3] = office2013
->encryptedVerifierHash
[3];
16026 return (PARSER_OK
);
16029 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16031 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
16033 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16035 u32
*digest
= (u32
*) hash_buf
->digest
;
16037 salt_t
*salt
= hash_buf
->salt
;
16039 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16045 char *version_pos
= input_buf
+ 11;
16047 char *osalt_pos
= strchr (version_pos
, '*');
16049 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16051 u32 version_len
= osalt_pos
- version_pos
;
16053 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16057 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16059 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16061 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16063 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16065 encryptedVerifier_pos
++;
16067 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16069 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16071 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16073 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16075 encryptedVerifierHash_pos
++;
16077 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16079 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16081 const uint version
= *version_pos
- 0x30;
16083 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16089 oldoffice01
->version
= version
;
16091 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16092 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16093 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16094 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16096 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16097 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16098 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16099 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16101 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16102 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16103 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16104 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16106 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16107 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16108 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16109 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16115 salt
->salt_len
= 16;
16117 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16118 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16119 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16120 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16122 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16123 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16124 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16125 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16127 // this is a workaround as office produces multiple documents with the same salt
16129 salt
->salt_len
+= 32;
16131 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16132 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16133 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16134 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16135 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16136 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16137 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16138 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16144 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
16145 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
16146 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
16147 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
16149 return (PARSER_OK
);
16152 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16154 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
16157 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16159 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
16161 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16163 u32
*digest
= (u32
*) hash_buf
->digest
;
16165 salt_t
*salt
= hash_buf
->salt
;
16167 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16173 char *version_pos
= input_buf
+ 11;
16175 char *osalt_pos
= strchr (version_pos
, '*');
16177 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16179 u32 version_len
= osalt_pos
- version_pos
;
16181 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16185 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16187 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16189 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16191 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16193 encryptedVerifier_pos
++;
16195 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16197 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16199 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16201 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16203 encryptedVerifierHash_pos
++;
16205 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16207 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16209 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16211 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16215 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16217 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16219 const uint version
= *version_pos
- 0x30;
16221 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16227 oldoffice01
->version
= version
;
16229 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16230 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16231 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16232 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16234 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16235 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16236 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16237 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16239 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16240 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16241 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16242 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16244 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16245 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16246 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16247 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16249 oldoffice01
->rc4key
[1] = 0;
16250 oldoffice01
->rc4key
[0] = 0;
16252 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16253 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16254 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16255 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16256 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16257 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16258 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16259 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16260 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16261 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16263 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
16264 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
16270 salt
->salt_len
= 16;
16272 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16273 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16274 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16275 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16277 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16278 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16279 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16280 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16282 // this is a workaround as office produces multiple documents with the same salt
16284 salt
->salt_len
+= 32;
16286 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16287 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16288 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16289 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16290 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16291 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16292 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16293 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16299 digest
[0] = oldoffice01
->rc4key
[0];
16300 digest
[1] = oldoffice01
->rc4key
[1];
16304 return (PARSER_OK
);
16307 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16309 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
16311 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16313 u32
*digest
= (u32
*) hash_buf
->digest
;
16315 salt_t
*salt
= hash_buf
->salt
;
16317 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16323 char *version_pos
= input_buf
+ 11;
16325 char *osalt_pos
= strchr (version_pos
, '*');
16327 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16329 u32 version_len
= osalt_pos
- version_pos
;
16331 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16335 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16337 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16339 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16341 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16343 encryptedVerifier_pos
++;
16345 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16347 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16349 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16351 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16353 encryptedVerifierHash_pos
++;
16355 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16357 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16359 const uint version
= *version_pos
- 0x30;
16361 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16367 oldoffice34
->version
= version
;
16369 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16370 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16371 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16372 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16374 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16375 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16376 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16377 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16379 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16380 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16381 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16382 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16383 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16385 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16386 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16387 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16388 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16389 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16395 salt
->salt_len
= 16;
16397 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16398 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16399 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16400 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16402 // this is a workaround as office produces multiple documents with the same salt
16404 salt
->salt_len
+= 32;
16406 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16407 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16408 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16409 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16410 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16411 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16412 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16413 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16419 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
16420 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
16421 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
16422 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
16424 return (PARSER_OK
);
16427 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16429 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16431 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
16434 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16436 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
16438 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16440 u32
*digest
= (u32
*) hash_buf
->digest
;
16442 salt_t
*salt
= hash_buf
->salt
;
16444 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16450 char *version_pos
= input_buf
+ 11;
16452 char *osalt_pos
= strchr (version_pos
, '*');
16454 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16456 u32 version_len
= osalt_pos
- version_pos
;
16458 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16462 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16464 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16466 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16468 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16470 encryptedVerifier_pos
++;
16472 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16474 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16476 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16478 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16480 encryptedVerifierHash_pos
++;
16482 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16484 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16486 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16488 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16492 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16494 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16496 const uint version
= *version_pos
- 0x30;
16498 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16504 oldoffice34
->version
= version
;
16506 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16507 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16508 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16509 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16511 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16512 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16513 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16514 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16516 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16517 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16518 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16519 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16520 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16522 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16523 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16524 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16525 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16526 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16528 oldoffice34
->rc4key
[1] = 0;
16529 oldoffice34
->rc4key
[0] = 0;
16531 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16532 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16533 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16534 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16535 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16536 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16537 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16538 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16539 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16540 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16542 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16543 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16549 salt
->salt_len
= 16;
16551 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16552 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16553 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16554 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16556 // this is a workaround as office produces multiple documents with the same salt
16558 salt
->salt_len
+= 32;
16560 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16561 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16562 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16563 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16564 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16565 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16566 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16567 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16573 digest
[0] = oldoffice34
->rc4key
[0];
16574 digest
[1] = oldoffice34
->rc4key
[1];
16578 return (PARSER_OK
);
16581 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16583 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16585 u32
*digest
= (u32
*) hash_buf
->digest
;
16587 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16588 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16589 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16590 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16592 digest
[0] = byte_swap_32 (digest
[0]);
16593 digest
[1] = byte_swap_32 (digest
[1]);
16594 digest
[2] = byte_swap_32 (digest
[2]);
16595 digest
[3] = byte_swap_32 (digest
[3]);
16597 return (PARSER_OK
);
16600 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16602 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16604 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16606 u32
*digest
= (u32
*) hash_buf
->digest
;
16608 salt_t
*salt
= hash_buf
->salt
;
16610 char *signature_pos
= input_buf
;
16612 char *salt_pos
= strchr (signature_pos
, '$');
16614 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16616 u32 signature_len
= salt_pos
- signature_pos
;
16618 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16622 char *hash_pos
= strchr (salt_pos
, '$');
16624 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16626 u32 salt_len
= hash_pos
- salt_pos
;
16628 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16632 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16634 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16636 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16637 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16638 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16639 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16640 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16642 digest
[0] -= SHA1M_A
;
16643 digest
[1] -= SHA1M_B
;
16644 digest
[2] -= SHA1M_C
;
16645 digest
[3] -= SHA1M_D
;
16646 digest
[4] -= SHA1M_E
;
16648 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16650 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16652 salt
->salt_len
= salt_len
;
16654 return (PARSER_OK
);
16657 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16659 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16661 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16663 u32
*digest
= (u32
*) hash_buf
->digest
;
16665 salt_t
*salt
= hash_buf
->salt
;
16667 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16673 char *iter_pos
= input_buf
+ 14;
16675 const int iter
= atoi (iter_pos
);
16677 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16679 salt
->salt_iter
= iter
- 1;
16681 char *salt_pos
= strchr (iter_pos
, '$');
16683 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16687 char *hash_pos
= strchr (salt_pos
, '$');
16689 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16691 const uint salt_len
= hash_pos
- salt_pos
;
16695 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16697 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16699 salt
->salt_len
= salt_len
;
16701 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16702 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16704 // add some stuff to normal salt to make sorted happy
16706 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16707 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16708 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16709 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16710 salt
->salt_buf
[4] = salt
->salt_iter
;
16712 // base64 decode hash
16714 u8 tmp_buf
[100] = { 0 };
16716 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16718 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16720 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16722 memcpy (digest
, tmp_buf
, 32);
16724 digest
[0] = byte_swap_32 (digest
[0]);
16725 digest
[1] = byte_swap_32 (digest
[1]);
16726 digest
[2] = byte_swap_32 (digest
[2]);
16727 digest
[3] = byte_swap_32 (digest
[3]);
16728 digest
[4] = byte_swap_32 (digest
[4]);
16729 digest
[5] = byte_swap_32 (digest
[5]);
16730 digest
[6] = byte_swap_32 (digest
[6]);
16731 digest
[7] = byte_swap_32 (digest
[7]);
16733 return (PARSER_OK
);
16736 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16738 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16740 u32
*digest
= (u32
*) hash_buf
->digest
;
16742 salt_t
*salt
= hash_buf
->salt
;
16744 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16745 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16749 digest
[0] = byte_swap_32 (digest
[0]);
16750 digest
[1] = byte_swap_32 (digest
[1]);
16752 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16753 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16754 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16756 char iter_c
= input_buf
[17];
16757 char iter_d
= input_buf
[19];
16759 // atm only defaults, let's see if there's more request
16760 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16761 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16763 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16765 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16766 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16767 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16768 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16770 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16771 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16772 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16773 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16775 salt
->salt_len
= 16;
16777 return (PARSER_OK
);
16780 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16782 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16784 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16786 u32
*digest
= (u32
*) hash_buf
->digest
;
16788 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16790 salt_t
*salt
= hash_buf
->salt
;
16792 char *salt_pos
= input_buf
+ 10;
16794 char *hash_pos
= strchr (salt_pos
, '$');
16796 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16798 uint salt_len
= hash_pos
- salt_pos
;
16802 uint hash_len
= input_len
- 10 - salt_len
- 1;
16804 // base64 decode salt
16806 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16808 u8 tmp_buf
[100] = { 0 };
16810 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16812 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16814 tmp_buf
[salt_len
] = 0x80;
16816 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16818 salt
->salt_len
= salt_len
;
16820 // base64 decode hash
16822 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16824 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16826 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16828 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16830 uint user_len
= hash_len
- 32;
16832 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16834 user_len
--; // skip the trailing space
16836 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16837 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16838 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16839 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16841 digest
[0] = byte_swap_32 (digest
[0]);
16842 digest
[1] = byte_swap_32 (digest
[1]);
16843 digest
[2] = byte_swap_32 (digest
[2]);
16844 digest
[3] = byte_swap_32 (digest
[3]);
16846 // store username for host only (output hash if cracked)
16848 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16849 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16851 return (PARSER_OK
);
16854 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16856 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16858 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16860 u32
*digest
= (u32
*) hash_buf
->digest
;
16862 salt_t
*salt
= hash_buf
->salt
;
16864 char *iter_pos
= input_buf
+ 10;
16866 u32 iter
= atoi (iter_pos
);
16870 return (PARSER_SALT_ITERATION
);
16873 iter
--; // first iteration is special
16875 salt
->salt_iter
= iter
;
16877 char *base64_pos
= strchr (iter_pos
, '}');
16879 if (base64_pos
== NULL
)
16881 return (PARSER_SIGNATURE_UNMATCHED
);
16886 // base64 decode salt
16888 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16890 u8 tmp_buf
[100] = { 0 };
16892 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16894 if (decoded_len
< 24)
16896 return (PARSER_SALT_LENGTH
);
16901 uint salt_len
= decoded_len
- 20;
16903 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16904 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16906 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16908 salt
->salt_len
= salt_len
;
16912 u32
*digest_ptr
= (u32
*) tmp_buf
;
16914 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16915 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16916 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16917 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16918 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16920 return (PARSER_OK
);
16923 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16925 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16927 u32
*digest
= (u32
*) hash_buf
->digest
;
16929 salt_t
*salt
= hash_buf
->salt
;
16931 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16932 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16933 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16934 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16935 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16937 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16939 uint salt_len
= input_len
- 40 - 1;
16941 char *salt_buf
= input_buf
+ 40 + 1;
16943 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16945 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16947 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16949 salt
->salt_len
= salt_len
;
16951 return (PARSER_OK
);
16954 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16956 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16958 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16960 u32
*digest
= (u32
*) hash_buf
->digest
;
16962 salt_t
*salt
= hash_buf
->salt
;
16964 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16970 char *V_pos
= input_buf
+ 5;
16972 char *R_pos
= strchr (V_pos
, '*');
16974 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16976 u32 V_len
= R_pos
- V_pos
;
16980 char *bits_pos
= strchr (R_pos
, '*');
16982 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16984 u32 R_len
= bits_pos
- R_pos
;
16988 char *P_pos
= strchr (bits_pos
, '*');
16990 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16992 u32 bits_len
= P_pos
- bits_pos
;
16996 char *enc_md_pos
= strchr (P_pos
, '*');
16998 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17000 u32 P_len
= enc_md_pos
- P_pos
;
17004 char *id_len_pos
= strchr (enc_md_pos
, '*');
17006 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17008 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17012 char *id_buf_pos
= strchr (id_len_pos
, '*');
17014 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17016 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17020 char *u_len_pos
= strchr (id_buf_pos
, '*');
17022 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17024 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17026 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17030 char *u_buf_pos
= strchr (u_len_pos
, '*');
17032 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17034 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17038 char *o_len_pos
= strchr (u_buf_pos
, '*');
17040 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17042 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17044 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17048 char *o_buf_pos
= strchr (o_len_pos
, '*');
17050 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17052 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17056 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;
17058 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17062 const int V
= atoi (V_pos
);
17063 const int R
= atoi (R_pos
);
17064 const int P
= atoi (P_pos
);
17066 if (V
!= 1) return (PARSER_SALT_VALUE
);
17067 if (R
!= 2) return (PARSER_SALT_VALUE
);
17069 const int enc_md
= atoi (enc_md_pos
);
17071 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17073 const int id_len
= atoi (id_len_pos
);
17074 const int u_len
= atoi (u_len_pos
);
17075 const int o_len
= atoi (o_len_pos
);
17077 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17078 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17079 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17081 const int bits
= atoi (bits_pos
);
17083 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17085 // copy data to esalt
17091 pdf
->enc_md
= enc_md
;
17093 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17094 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17095 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17096 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17097 pdf
->id_len
= id_len
;
17099 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17100 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17101 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17102 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17103 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17104 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17105 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17106 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17107 pdf
->u_len
= u_len
;
17109 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17110 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17111 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17112 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17113 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17114 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17115 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17116 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17117 pdf
->o_len
= o_len
;
17119 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17120 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17121 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17122 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17124 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17125 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17126 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17127 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17128 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17129 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17130 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17131 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17133 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17134 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17135 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17136 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17137 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17138 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17139 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17140 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17142 // we use ID for salt, maybe needs to change, we will see...
17144 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17145 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17146 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17147 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17148 salt
->salt_len
= pdf
->id_len
;
17150 digest
[0] = pdf
->u_buf
[0];
17151 digest
[1] = pdf
->u_buf
[1];
17152 digest
[2] = pdf
->u_buf
[2];
17153 digest
[3] = pdf
->u_buf
[3];
17155 return (PARSER_OK
);
17158 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17160 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
17163 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17165 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
17167 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17169 u32
*digest
= (u32
*) hash_buf
->digest
;
17171 salt_t
*salt
= hash_buf
->salt
;
17173 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17179 char *V_pos
= input_buf
+ 5;
17181 char *R_pos
= strchr (V_pos
, '*');
17183 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17185 u32 V_len
= R_pos
- V_pos
;
17189 char *bits_pos
= strchr (R_pos
, '*');
17191 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17193 u32 R_len
= bits_pos
- R_pos
;
17197 char *P_pos
= strchr (bits_pos
, '*');
17199 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17201 u32 bits_len
= P_pos
- bits_pos
;
17205 char *enc_md_pos
= strchr (P_pos
, '*');
17207 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17209 u32 P_len
= enc_md_pos
- P_pos
;
17213 char *id_len_pos
= strchr (enc_md_pos
, '*');
17215 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17217 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17221 char *id_buf_pos
= strchr (id_len_pos
, '*');
17223 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17225 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17229 char *u_len_pos
= strchr (id_buf_pos
, '*');
17231 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17233 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17235 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17239 char *u_buf_pos
= strchr (u_len_pos
, '*');
17241 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17243 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17247 char *o_len_pos
= strchr (u_buf_pos
, '*');
17249 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17251 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17253 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17257 char *o_buf_pos
= strchr (o_len_pos
, '*');
17259 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17261 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17265 char *rc4key_pos
= strchr (o_buf_pos
, ':');
17267 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17269 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
17271 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17275 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;
17277 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
17281 const int V
= atoi (V_pos
);
17282 const int R
= atoi (R_pos
);
17283 const int P
= atoi (P_pos
);
17285 if (V
!= 1) return (PARSER_SALT_VALUE
);
17286 if (R
!= 2) return (PARSER_SALT_VALUE
);
17288 const int enc_md
= atoi (enc_md_pos
);
17290 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17292 const int id_len
= atoi (id_len_pos
);
17293 const int u_len
= atoi (u_len_pos
);
17294 const int o_len
= atoi (o_len_pos
);
17296 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17297 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17298 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17300 const int bits
= atoi (bits_pos
);
17302 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17304 // copy data to esalt
17310 pdf
->enc_md
= enc_md
;
17312 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17313 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17314 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17315 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17316 pdf
->id_len
= id_len
;
17318 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17319 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17320 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17321 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17322 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17323 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17324 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17325 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17326 pdf
->u_len
= u_len
;
17328 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17329 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17330 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17331 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17332 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17333 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17334 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17335 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17336 pdf
->o_len
= o_len
;
17338 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17339 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17340 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17341 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17343 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17344 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17345 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17346 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17347 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17348 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17349 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17350 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17352 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17353 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17354 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17355 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17356 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17357 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17358 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17359 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17361 pdf
->rc4key
[1] = 0;
17362 pdf
->rc4key
[0] = 0;
17364 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
17365 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
17366 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
17367 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
17368 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
17369 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
17370 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
17371 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
17372 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
17373 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
17375 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
17376 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
17378 // we use ID for salt, maybe needs to change, we will see...
17380 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17381 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17382 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17383 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17384 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17385 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17386 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17387 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17388 salt
->salt_len
= pdf
->id_len
+ 16;
17390 digest
[0] = pdf
->rc4key
[0];
17391 digest
[1] = pdf
->rc4key
[1];
17395 return (PARSER_OK
);
17398 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17400 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
17402 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17404 u32
*digest
= (u32
*) hash_buf
->digest
;
17406 salt_t
*salt
= hash_buf
->salt
;
17408 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17414 char *V_pos
= input_buf
+ 5;
17416 char *R_pos
= strchr (V_pos
, '*');
17418 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17420 u32 V_len
= R_pos
- V_pos
;
17424 char *bits_pos
= strchr (R_pos
, '*');
17426 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17428 u32 R_len
= bits_pos
- R_pos
;
17432 char *P_pos
= strchr (bits_pos
, '*');
17434 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17436 u32 bits_len
= P_pos
- bits_pos
;
17440 char *enc_md_pos
= strchr (P_pos
, '*');
17442 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17444 u32 P_len
= enc_md_pos
- P_pos
;
17448 char *id_len_pos
= strchr (enc_md_pos
, '*');
17450 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17452 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17456 char *id_buf_pos
= strchr (id_len_pos
, '*');
17458 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17460 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17464 char *u_len_pos
= strchr (id_buf_pos
, '*');
17466 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17468 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17470 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17474 char *u_buf_pos
= strchr (u_len_pos
, '*');
17476 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17478 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17482 char *o_len_pos
= strchr (u_buf_pos
, '*');
17484 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17486 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17488 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17492 char *o_buf_pos
= strchr (o_len_pos
, '*');
17494 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17496 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17500 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;
17502 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17506 const int V
= atoi (V_pos
);
17507 const int R
= atoi (R_pos
);
17508 const int P
= atoi (P_pos
);
17512 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17513 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17515 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17517 const int id_len
= atoi (id_len_pos
);
17518 const int u_len
= atoi (u_len_pos
);
17519 const int o_len
= atoi (o_len_pos
);
17521 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17523 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17524 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17526 const int bits
= atoi (bits_pos
);
17528 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17534 enc_md
= atoi (enc_md_pos
);
17537 // copy data to esalt
17543 pdf
->enc_md
= enc_md
;
17545 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17546 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17547 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17548 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17552 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17553 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17554 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17555 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17558 pdf
->id_len
= id_len
;
17560 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17561 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17562 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17563 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17564 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17565 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17566 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17567 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17568 pdf
->u_len
= u_len
;
17570 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17571 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17572 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17573 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17574 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17575 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17576 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17577 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17578 pdf
->o_len
= o_len
;
17580 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17581 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17582 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17583 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17587 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17588 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17589 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17590 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17593 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17594 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17595 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17596 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17597 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17598 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17599 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17600 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17602 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17603 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17604 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17605 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17606 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17607 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17608 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17609 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17611 // precompute rc4 data for later use
17627 uint salt_pc_block
[32] = { 0 };
17629 char *salt_pc_ptr
= (char *) salt_pc_block
;
17631 memcpy (salt_pc_ptr
, padding
, 32);
17632 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17634 uint salt_pc_digest
[4] = { 0 };
17636 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17638 pdf
->rc4data
[0] = salt_pc_digest
[0];
17639 pdf
->rc4data
[1] = salt_pc_digest
[1];
17641 // we use ID for salt, maybe needs to change, we will see...
17643 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17644 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17645 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17646 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17647 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17648 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17649 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17650 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17651 salt
->salt_len
= pdf
->id_len
+ 16;
17653 salt
->salt_iter
= ROUNDS_PDF14
;
17655 digest
[0] = pdf
->u_buf
[0];
17656 digest
[1] = pdf
->u_buf
[1];
17660 return (PARSER_OK
);
17663 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17665 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17667 if (ret
!= PARSER_OK
)
17672 u32
*digest
= (u32
*) hash_buf
->digest
;
17674 salt_t
*salt
= hash_buf
->salt
;
17676 digest
[0] -= SHA256M_A
;
17677 digest
[1] -= SHA256M_B
;
17678 digest
[2] -= SHA256M_C
;
17679 digest
[3] -= SHA256M_D
;
17680 digest
[4] -= SHA256M_E
;
17681 digest
[5] -= SHA256M_F
;
17682 digest
[6] -= SHA256M_G
;
17683 digest
[7] -= SHA256M_H
;
17685 salt
->salt_buf
[2] = 0x80;
17687 return (PARSER_OK
);
17690 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17692 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17694 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17696 u32
*digest
= (u32
*) hash_buf
->digest
;
17698 salt_t
*salt
= hash_buf
->salt
;
17700 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17706 char *V_pos
= input_buf
+ 5;
17708 char *R_pos
= strchr (V_pos
, '*');
17710 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17712 u32 V_len
= R_pos
- V_pos
;
17716 char *bits_pos
= strchr (R_pos
, '*');
17718 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17720 u32 R_len
= bits_pos
- R_pos
;
17724 char *P_pos
= strchr (bits_pos
, '*');
17726 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17728 u32 bits_len
= P_pos
- bits_pos
;
17732 char *enc_md_pos
= strchr (P_pos
, '*');
17734 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17736 u32 P_len
= enc_md_pos
- P_pos
;
17740 char *id_len_pos
= strchr (enc_md_pos
, '*');
17742 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17744 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17748 char *id_buf_pos
= strchr (id_len_pos
, '*');
17750 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17752 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17756 char *u_len_pos
= strchr (id_buf_pos
, '*');
17758 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17760 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17764 char *u_buf_pos
= strchr (u_len_pos
, '*');
17766 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17768 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17772 char *o_len_pos
= strchr (u_buf_pos
, '*');
17774 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17776 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17780 char *o_buf_pos
= strchr (o_len_pos
, '*');
17782 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17784 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17788 char *last
= strchr (o_buf_pos
, '*');
17790 if (last
== NULL
) last
= input_buf
+ input_len
;
17792 u32 o_buf_len
= last
- o_buf_pos
;
17796 const int V
= atoi (V_pos
);
17797 const int R
= atoi (R_pos
);
17801 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17802 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17804 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17806 const int bits
= atoi (bits_pos
);
17808 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17810 int enc_md
= atoi (enc_md_pos
);
17812 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17814 const uint id_len
= atoi (id_len_pos
);
17815 const uint u_len
= atoi (u_len_pos
);
17816 const uint o_len
= atoi (o_len_pos
);
17818 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17819 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17820 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17821 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17822 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17823 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17824 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17825 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17827 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17828 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17829 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17831 // copy data to esalt
17833 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17835 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17837 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17840 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17841 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17843 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17844 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17846 salt
->salt_len
= 8;
17847 salt
->salt_iter
= ROUNDS_PDF17L8
;
17849 digest
[0] = pdf
->u_buf
[0];
17850 digest
[1] = pdf
->u_buf
[1];
17851 digest
[2] = pdf
->u_buf
[2];
17852 digest
[3] = pdf
->u_buf
[3];
17853 digest
[4] = pdf
->u_buf
[4];
17854 digest
[5] = pdf
->u_buf
[5];
17855 digest
[6] = pdf
->u_buf
[6];
17856 digest
[7] = pdf
->u_buf
[7];
17858 return (PARSER_OK
);
17861 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17863 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17865 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17867 u32
*digest
= (u32
*) hash_buf
->digest
;
17869 salt_t
*salt
= hash_buf
->salt
;
17871 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17879 char *iter_pos
= input_buf
+ 7;
17881 u32 iter
= atoi (iter_pos
);
17883 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17884 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17886 // first is *raw* salt
17888 char *salt_pos
= strchr (iter_pos
, ':');
17890 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17894 char *hash_pos
= strchr (salt_pos
, ':');
17896 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17898 u32 salt_len
= hash_pos
- salt_pos
;
17900 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17904 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17906 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17910 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17912 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17914 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17916 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17917 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17919 salt
->salt_len
= salt_len
;
17920 salt
->salt_iter
= iter
- 1;
17924 u8 tmp_buf
[100] = { 0 };
17926 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17928 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17930 memcpy (digest
, tmp_buf
, 16);
17932 digest
[0] = byte_swap_32 (digest
[0]);
17933 digest
[1] = byte_swap_32 (digest
[1]);
17934 digest
[2] = byte_swap_32 (digest
[2]);
17935 digest
[3] = byte_swap_32 (digest
[3]);
17937 // add some stuff to normal salt to make sorted happy
17939 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17940 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17941 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17942 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17943 salt
->salt_buf
[4] = salt
->salt_iter
;
17945 return (PARSER_OK
);
17948 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17950 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17952 u32
*digest
= (u32
*) hash_buf
->digest
;
17954 salt_t
*salt
= hash_buf
->salt
;
17956 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17957 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17958 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17959 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17961 digest
[0] = byte_swap_32 (digest
[0]);
17962 digest
[1] = byte_swap_32 (digest
[1]);
17963 digest
[2] = byte_swap_32 (digest
[2]);
17964 digest
[3] = byte_swap_32 (digest
[3]);
17966 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17968 uint salt_len
= input_len
- 32 - 1;
17970 char *salt_buf
= input_buf
+ 32 + 1;
17972 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17974 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17976 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17978 salt
->salt_len
= salt_len
;
17980 return (PARSER_OK
);
17983 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17985 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17987 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17989 u32
*digest
= (u32
*) hash_buf
->digest
;
17991 salt_t
*salt
= hash_buf
->salt
;
17993 char *user_pos
= input_buf
+ 10;
17995 char *salt_pos
= strchr (user_pos
, '*');
17997 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18001 char *hash_pos
= strchr (salt_pos
, '*');
18005 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18007 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
18009 uint user_len
= salt_pos
- user_pos
- 1;
18011 uint salt_len
= hash_pos
- salt_pos
- 1;
18013 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
18019 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18020 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18021 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18022 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18024 digest
[0] = byte_swap_32 (digest
[0]);
18025 digest
[1] = byte_swap_32 (digest
[1]);
18026 digest
[2] = byte_swap_32 (digest
[2]);
18027 digest
[3] = byte_swap_32 (digest
[3]);
18029 digest
[0] -= MD5M_A
;
18030 digest
[1] -= MD5M_B
;
18031 digest
[2] -= MD5M_C
;
18032 digest
[3] -= MD5M_D
;
18038 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18040 // first 4 bytes are the "challenge"
18042 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
18043 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
18044 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
18045 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
18047 // append the user name
18049 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
18051 salt
->salt_len
= 4 + user_len
;
18053 return (PARSER_OK
);
18056 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18058 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
18060 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18062 u32
*digest
= (u32
*) hash_buf
->digest
;
18064 salt_t
*salt
= hash_buf
->salt
;
18066 char *salt_pos
= input_buf
+ 9;
18068 char *hash_pos
= strchr (salt_pos
, '*');
18070 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18074 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18076 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
18078 uint salt_len
= hash_pos
- salt_pos
- 1;
18080 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
18086 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18087 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18088 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18089 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18090 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18096 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18098 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18100 salt
->salt_len
= salt_len
;
18102 return (PARSER_OK
);
18105 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18107 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
18109 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18111 u32
*digest
= (u32
*) hash_buf
->digest
;
18113 salt_t
*salt
= hash_buf
->salt
;
18115 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
18121 char *cry_master_len_pos
= input_buf
+ 9;
18123 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
18125 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18127 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
18129 cry_master_buf_pos
++;
18131 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
18133 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18135 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
18137 cry_salt_len_pos
++;
18139 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
18141 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18143 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
18145 cry_salt_buf_pos
++;
18147 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
18149 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18151 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
18155 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
18157 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18159 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
18163 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
18165 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18167 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
18171 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
18173 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18175 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
18177 public_key_len_pos
++;
18179 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
18181 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18183 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
18185 public_key_buf_pos
++;
18187 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;
18189 const uint cry_master_len
= atoi (cry_master_len_pos
);
18190 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
18191 const uint ckey_len
= atoi (ckey_len_pos
);
18192 const uint public_key_len
= atoi (public_key_len_pos
);
18194 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
18195 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
18196 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
18197 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
18199 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
18201 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
18203 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
18206 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
18208 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
18210 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
18213 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
18215 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
18217 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
18220 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
18221 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
18222 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
18225 * store digest (should be unique enought, hopefully)
18228 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
18229 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
18230 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
18231 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
18237 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
18239 const uint cry_rounds
= atoi (cry_rounds_pos
);
18241 salt
->salt_iter
= cry_rounds
- 1;
18243 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18245 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
18247 salt
->salt_len
= salt_len
;
18249 return (PARSER_OK
);
18252 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18254 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
18256 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18258 u32
*digest
= (u32
*) hash_buf
->digest
;
18260 salt_t
*salt
= hash_buf
->salt
;
18262 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
18264 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
18266 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
18268 memcpy (temp_input_buf
, input_buf
, input_len
);
18272 char *URI_server_pos
= temp_input_buf
+ 6;
18274 char *URI_client_pos
= strchr (URI_server_pos
, '*');
18276 if (URI_client_pos
== NULL
)
18278 myfree (temp_input_buf
);
18280 return (PARSER_SEPARATOR_UNMATCHED
);
18283 URI_client_pos
[0] = 0;
18286 uint URI_server_len
= strlen (URI_server_pos
);
18288 if (URI_server_len
> 512)
18290 myfree (temp_input_buf
);
18292 return (PARSER_SALT_LENGTH
);
18297 char *user_pos
= strchr (URI_client_pos
, '*');
18299 if (user_pos
== NULL
)
18301 myfree (temp_input_buf
);
18303 return (PARSER_SEPARATOR_UNMATCHED
);
18309 uint URI_client_len
= strlen (URI_client_pos
);
18311 if (URI_client_len
> 512)
18313 myfree (temp_input_buf
);
18315 return (PARSER_SALT_LENGTH
);
18320 char *realm_pos
= strchr (user_pos
, '*');
18322 if (realm_pos
== NULL
)
18324 myfree (temp_input_buf
);
18326 return (PARSER_SEPARATOR_UNMATCHED
);
18332 uint user_len
= strlen (user_pos
);
18334 if (user_len
> 116)
18336 myfree (temp_input_buf
);
18338 return (PARSER_SALT_LENGTH
);
18343 char *method_pos
= strchr (realm_pos
, '*');
18345 if (method_pos
== NULL
)
18347 myfree (temp_input_buf
);
18349 return (PARSER_SEPARATOR_UNMATCHED
);
18355 uint realm_len
= strlen (realm_pos
);
18357 if (realm_len
> 116)
18359 myfree (temp_input_buf
);
18361 return (PARSER_SALT_LENGTH
);
18366 char *URI_prefix_pos
= strchr (method_pos
, '*');
18368 if (URI_prefix_pos
== NULL
)
18370 myfree (temp_input_buf
);
18372 return (PARSER_SEPARATOR_UNMATCHED
);
18375 URI_prefix_pos
[0] = 0;
18378 uint method_len
= strlen (method_pos
);
18380 if (method_len
> 246)
18382 myfree (temp_input_buf
);
18384 return (PARSER_SALT_LENGTH
);
18389 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
18391 if (URI_resource_pos
== NULL
)
18393 myfree (temp_input_buf
);
18395 return (PARSER_SEPARATOR_UNMATCHED
);
18398 URI_resource_pos
[0] = 0;
18399 URI_resource_pos
++;
18401 uint URI_prefix_len
= strlen (URI_prefix_pos
);
18403 if (URI_prefix_len
> 245)
18405 myfree (temp_input_buf
);
18407 return (PARSER_SALT_LENGTH
);
18412 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
18414 if (URI_suffix_pos
== NULL
)
18416 myfree (temp_input_buf
);
18418 return (PARSER_SEPARATOR_UNMATCHED
);
18421 URI_suffix_pos
[0] = 0;
18424 uint URI_resource_len
= strlen (URI_resource_pos
);
18426 if (URI_resource_len
< 1 || URI_resource_len
> 246)
18428 myfree (temp_input_buf
);
18430 return (PARSER_SALT_LENGTH
);
18435 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
18437 if (nonce_pos
== NULL
)
18439 myfree (temp_input_buf
);
18441 return (PARSER_SEPARATOR_UNMATCHED
);
18447 uint URI_suffix_len
= strlen (URI_suffix_pos
);
18449 if (URI_suffix_len
> 245)
18451 myfree (temp_input_buf
);
18453 return (PARSER_SALT_LENGTH
);
18458 char *nonce_client_pos
= strchr (nonce_pos
, '*');
18460 if (nonce_client_pos
== NULL
)
18462 myfree (temp_input_buf
);
18464 return (PARSER_SEPARATOR_UNMATCHED
);
18467 nonce_client_pos
[0] = 0;
18468 nonce_client_pos
++;
18470 uint nonce_len
= strlen (nonce_pos
);
18472 if (nonce_len
< 1 || nonce_len
> 50)
18474 myfree (temp_input_buf
);
18476 return (PARSER_SALT_LENGTH
);
18481 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18483 if (nonce_count_pos
== NULL
)
18485 myfree (temp_input_buf
);
18487 return (PARSER_SEPARATOR_UNMATCHED
);
18490 nonce_count_pos
[0] = 0;
18493 uint nonce_client_len
= strlen (nonce_client_pos
);
18495 if (nonce_client_len
> 50)
18497 myfree (temp_input_buf
);
18499 return (PARSER_SALT_LENGTH
);
18504 char *qop_pos
= strchr (nonce_count_pos
, '*');
18506 if (qop_pos
== NULL
)
18508 myfree (temp_input_buf
);
18510 return (PARSER_SEPARATOR_UNMATCHED
);
18516 uint nonce_count_len
= strlen (nonce_count_pos
);
18518 if (nonce_count_len
> 50)
18520 myfree (temp_input_buf
);
18522 return (PARSER_SALT_LENGTH
);
18527 char *directive_pos
= strchr (qop_pos
, '*');
18529 if (directive_pos
== NULL
)
18531 myfree (temp_input_buf
);
18533 return (PARSER_SEPARATOR_UNMATCHED
);
18536 directive_pos
[0] = 0;
18539 uint qop_len
= strlen (qop_pos
);
18543 myfree (temp_input_buf
);
18545 return (PARSER_SALT_LENGTH
);
18550 char *digest_pos
= strchr (directive_pos
, '*');
18552 if (digest_pos
== NULL
)
18554 myfree (temp_input_buf
);
18556 return (PARSER_SEPARATOR_UNMATCHED
);
18562 uint directive_len
= strlen (directive_pos
);
18564 if (directive_len
!= 3)
18566 myfree (temp_input_buf
);
18568 return (PARSER_SALT_LENGTH
);
18571 if (memcmp (directive_pos
, "MD5", 3))
18573 log_info ("ERROR: only the MD5 directive is currently supported\n");
18575 myfree (temp_input_buf
);
18577 return (PARSER_SIP_AUTH_DIRECTIVE
);
18581 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18586 uint md5_max_len
= 4 * 64;
18588 uint md5_remaining_len
= md5_max_len
;
18590 uint tmp_md5_buf
[64] = { 0 };
18592 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18594 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18596 md5_len
+= method_len
+ 1;
18597 tmp_md5_ptr
+= method_len
+ 1;
18599 if (URI_prefix_len
> 0)
18601 md5_remaining_len
= md5_max_len
- md5_len
;
18603 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18605 md5_len
+= URI_prefix_len
+ 1;
18606 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18609 md5_remaining_len
= md5_max_len
- md5_len
;
18611 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18613 md5_len
+= URI_resource_len
;
18614 tmp_md5_ptr
+= URI_resource_len
;
18616 if (URI_suffix_len
> 0)
18618 md5_remaining_len
= md5_max_len
- md5_len
;
18620 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18622 md5_len
+= 1 + URI_suffix_len
;
18625 uint tmp_digest
[4] = { 0 };
18627 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18629 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18630 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18631 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18632 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18638 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18640 uint esalt_len
= 0;
18642 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18644 // there are 2 possibilities for the esalt:
18646 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18648 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18650 if (esalt_len
> max_esalt_len
)
18652 myfree (temp_input_buf
);
18654 return (PARSER_SALT_LENGTH
);
18657 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18669 esalt_len
= 1 + nonce_len
+ 1 + 32;
18671 if (esalt_len
> max_esalt_len
)
18673 myfree (temp_input_buf
);
18675 return (PARSER_SALT_LENGTH
);
18678 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18686 // add 0x80 to esalt
18688 esalt_buf_ptr
[esalt_len
] = 0x80;
18690 sip
->esalt_len
= esalt_len
;
18696 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18698 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18700 uint max_salt_len
= 119;
18702 if (salt_len
> max_salt_len
)
18704 myfree (temp_input_buf
);
18706 return (PARSER_SALT_LENGTH
);
18709 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18711 sip
->salt_len
= salt_len
;
18714 * fake salt (for sorting)
18717 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18721 uint fake_salt_len
= salt_len
;
18723 if (fake_salt_len
> max_salt_len
)
18725 fake_salt_len
= max_salt_len
;
18728 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18730 salt
->salt_len
= fake_salt_len
;
18736 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18737 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18738 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18739 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18741 digest
[0] = byte_swap_32 (digest
[0]);
18742 digest
[1] = byte_swap_32 (digest
[1]);
18743 digest
[2] = byte_swap_32 (digest
[2]);
18744 digest
[3] = byte_swap_32 (digest
[3]);
18746 myfree (temp_input_buf
);
18748 return (PARSER_OK
);
18751 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18753 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18755 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18757 u32
*digest
= (u32
*) hash_buf
->digest
;
18759 salt_t
*salt
= hash_buf
->salt
;
18763 char *digest_pos
= input_buf
;
18765 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18772 char *salt_buf
= input_buf
+ 8 + 1;
18776 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18778 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18780 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18782 salt
->salt_len
= salt_len
;
18784 return (PARSER_OK
);
18787 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18789 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18791 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18793 u32
*digest
= (u32
*) hash_buf
->digest
;
18795 salt_t
*salt
= hash_buf
->salt
;
18797 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18803 char *p_buf_pos
= input_buf
+ 4;
18805 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18807 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18809 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18811 NumCyclesPower_pos
++;
18813 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18815 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18817 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18821 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18823 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18825 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18829 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18831 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18833 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18837 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18839 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18841 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18845 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18847 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18849 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18853 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18855 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18857 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18861 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18863 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18865 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18869 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18871 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18873 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18877 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;
18879 const uint iter
= atoi (NumCyclesPower_pos
);
18880 const uint crc
= atoi (crc_buf_pos
);
18881 const uint p_buf
= atoi (p_buf_pos
);
18882 const uint salt_len
= atoi (salt_len_pos
);
18883 const uint iv_len
= atoi (iv_len_pos
);
18884 const uint unpack_size
= atoi (unpack_size_pos
);
18885 const uint data_len
= atoi (data_len_pos
);
18891 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18892 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18894 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18896 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18898 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18904 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18905 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18906 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18907 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18909 seven_zip
->iv_len
= iv_len
;
18911 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18913 seven_zip
->salt_len
= 0;
18915 seven_zip
->crc
= crc
;
18917 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18919 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18921 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18924 seven_zip
->data_len
= data_len
;
18926 seven_zip
->unpack_size
= unpack_size
;
18930 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18931 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18932 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18933 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18935 salt
->salt_len
= 16;
18937 salt
->salt_sign
[0] = iter
;
18939 salt
->salt_iter
= 1 << iter
;
18950 return (PARSER_OK
);
18953 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18955 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18957 u32
*digest
= (u32
*) hash_buf
->digest
;
18959 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18960 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18961 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18962 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18963 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18964 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18965 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18966 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18968 digest
[0] = byte_swap_32 (digest
[0]);
18969 digest
[1] = byte_swap_32 (digest
[1]);
18970 digest
[2] = byte_swap_32 (digest
[2]);
18971 digest
[3] = byte_swap_32 (digest
[3]);
18972 digest
[4] = byte_swap_32 (digest
[4]);
18973 digest
[5] = byte_swap_32 (digest
[5]);
18974 digest
[6] = byte_swap_32 (digest
[6]);
18975 digest
[7] = byte_swap_32 (digest
[7]);
18977 return (PARSER_OK
);
18980 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18982 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18984 u32
*digest
= (u32
*) hash_buf
->digest
;
18986 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18987 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18988 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18989 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18990 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18991 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18992 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18993 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18994 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18995 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18996 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18997 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18998 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18999 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
19000 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
19001 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
19003 digest
[ 0] = byte_swap_32 (digest
[ 0]);
19004 digest
[ 1] = byte_swap_32 (digest
[ 1]);
19005 digest
[ 2] = byte_swap_32 (digest
[ 2]);
19006 digest
[ 3] = byte_swap_32 (digest
[ 3]);
19007 digest
[ 4] = byte_swap_32 (digest
[ 4]);
19008 digest
[ 5] = byte_swap_32 (digest
[ 5]);
19009 digest
[ 6] = byte_swap_32 (digest
[ 6]);
19010 digest
[ 7] = byte_swap_32 (digest
[ 7]);
19011 digest
[ 8] = byte_swap_32 (digest
[ 8]);
19012 digest
[ 9] = byte_swap_32 (digest
[ 9]);
19013 digest
[10] = byte_swap_32 (digest
[10]);
19014 digest
[11] = byte_swap_32 (digest
[11]);
19015 digest
[12] = byte_swap_32 (digest
[12]);
19016 digest
[13] = byte_swap_32 (digest
[13]);
19017 digest
[14] = byte_swap_32 (digest
[14]);
19018 digest
[15] = byte_swap_32 (digest
[15]);
19020 return (PARSER_OK
);
19023 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19025 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
19027 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
19029 u32
*digest
= (u32
*) hash_buf
->digest
;
19031 salt_t
*salt
= hash_buf
->salt
;
19033 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
19041 char *iter_pos
= input_buf
+ 4;
19043 u32 iter
= atoi (iter_pos
);
19045 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19046 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19048 // first is *raw* salt
19050 char *salt_pos
= strchr (iter_pos
, ':');
19052 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19056 char *hash_pos
= strchr (salt_pos
, ':');
19058 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19060 u32 salt_len
= hash_pos
- salt_pos
;
19062 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19066 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19068 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19072 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
19074 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19076 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19078 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19079 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19081 salt
->salt_len
= salt_len
;
19082 salt
->salt_iter
= iter
- 1;
19086 u8 tmp_buf
[100] = { 0 };
19088 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19090 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19092 memcpy (digest
, tmp_buf
, 16);
19094 // add some stuff to normal salt to make sorted happy
19096 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
19097 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
19098 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
19099 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
19100 salt
->salt_buf
[4] = salt
->salt_iter
;
19102 return (PARSER_OK
);
19105 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19107 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
19109 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
19111 u32
*digest
= (u32
*) hash_buf
->digest
;
19113 salt_t
*salt
= hash_buf
->salt
;
19115 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
19123 char *iter_pos
= input_buf
+ 5;
19125 u32 iter
= atoi (iter_pos
);
19127 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19128 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19130 // first is *raw* salt
19132 char *salt_pos
= strchr (iter_pos
, ':');
19134 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19138 char *hash_pos
= strchr (salt_pos
, ':');
19140 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19142 u32 salt_len
= hash_pos
- salt_pos
;
19144 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19148 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19150 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19154 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
19156 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19158 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19160 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19161 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19163 salt
->salt_len
= salt_len
;
19164 salt
->salt_iter
= iter
- 1;
19168 u8 tmp_buf
[100] = { 0 };
19170 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19172 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19174 memcpy (digest
, tmp_buf
, 16);
19176 digest
[0] = byte_swap_32 (digest
[0]);
19177 digest
[1] = byte_swap_32 (digest
[1]);
19178 digest
[2] = byte_swap_32 (digest
[2]);
19179 digest
[3] = byte_swap_32 (digest
[3]);
19181 // add some stuff to normal salt to make sorted happy
19183 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
19184 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
19185 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
19186 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
19187 salt
->salt_buf
[4] = salt
->salt_iter
;
19189 return (PARSER_OK
);
19192 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19194 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
19196 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
19198 u64
*digest
= (u64
*) hash_buf
->digest
;
19200 salt_t
*salt
= hash_buf
->salt
;
19202 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
19210 char *iter_pos
= input_buf
+ 7;
19212 u32 iter
= atoi (iter_pos
);
19214 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19215 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19217 // first is *raw* salt
19219 char *salt_pos
= strchr (iter_pos
, ':');
19221 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19225 char *hash_pos
= strchr (salt_pos
, ':');
19227 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19229 u32 salt_len
= hash_pos
- salt_pos
;
19231 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19235 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19237 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19241 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
19243 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19245 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19247 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19248 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19250 salt
->salt_len
= salt_len
;
19251 salt
->salt_iter
= iter
- 1;
19255 u8 tmp_buf
[100] = { 0 };
19257 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19259 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19261 memcpy (digest
, tmp_buf
, 64);
19263 digest
[0] = byte_swap_64 (digest
[0]);
19264 digest
[1] = byte_swap_64 (digest
[1]);
19265 digest
[2] = byte_swap_64 (digest
[2]);
19266 digest
[3] = byte_swap_64 (digest
[3]);
19267 digest
[4] = byte_swap_64 (digest
[4]);
19268 digest
[5] = byte_swap_64 (digest
[5]);
19269 digest
[6] = byte_swap_64 (digest
[6]);
19270 digest
[7] = byte_swap_64 (digest
[7]);
19272 // add some stuff to normal salt to make sorted happy
19274 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
19275 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
19276 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
19277 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
19278 salt
->salt_buf
[4] = salt
->salt_iter
;
19280 return (PARSER_OK
);
19283 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19285 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
19287 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
19289 uint
*digest
= (uint
*) hash_buf
->digest
;
19291 salt_t
*salt
= hash_buf
->salt
;
19297 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
19299 char *hash_pos
= strchr (salt_pos
, '$');
19301 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19303 u32 salt_len
= hash_pos
- salt_pos
;
19305 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19309 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
19311 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
19315 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
19316 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
19334 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19335 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19337 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
19338 salt
->salt_len
= 8;
19340 return (PARSER_OK
);
19343 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19345 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
19347 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19349 unsigned char c19
= itoa64_to_int (input_buf
[19]);
19351 if (c19
& 3) return (PARSER_HASH_VALUE
);
19353 salt_t
*salt
= hash_buf
->salt
;
19355 u32
*digest
= (u32
*) hash_buf
->digest
;
19359 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
19360 | itoa64_to_int (input_buf
[2]) << 6
19361 | itoa64_to_int (input_buf
[3]) << 12
19362 | itoa64_to_int (input_buf
[4]) << 18;
19366 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
19367 | itoa64_to_int (input_buf
[6]) << 6
19368 | itoa64_to_int (input_buf
[7]) << 12
19369 | itoa64_to_int (input_buf
[8]) << 18;
19371 salt
->salt_len
= 4;
19373 u8 tmp_buf
[100] = { 0 };
19375 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
19377 memcpy (digest
, tmp_buf
, 8);
19381 IP (digest
[0], digest
[1], tt
);
19383 digest
[0] = rotr32 (digest
[0], 31);
19384 digest
[1] = rotr32 (digest
[1], 31);
19388 return (PARSER_OK
);
19391 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19393 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
19395 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
19397 u32
*digest
= (u32
*) hash_buf
->digest
;
19399 salt_t
*salt
= hash_buf
->salt
;
19405 char *type_pos
= input_buf
+ 6 + 1;
19407 char *salt_pos
= strchr (type_pos
, '*');
19409 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19411 u32 type_len
= salt_pos
- type_pos
;
19413 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
19417 char *crypted_pos
= strchr (salt_pos
, '*');
19419 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19421 u32 salt_len
= crypted_pos
- salt_pos
;
19423 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19427 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
19429 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
19435 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19436 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19438 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19439 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19441 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
19442 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
19443 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
19444 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
19446 salt
->salt_len
= 24;
19447 salt
->salt_iter
= ROUNDS_RAR3
;
19449 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
19450 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
19452 digest
[0] = 0xc43d7b00;
19453 digest
[1] = 0x40070000;
19457 return (PARSER_OK
);
19460 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19462 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19464 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19466 u32
*digest
= (u32
*) hash_buf
->digest
;
19468 salt_t
*salt
= hash_buf
->salt
;
19470 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19476 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19478 char *param1_pos
= strchr (param0_pos
, '$');
19480 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19482 u32 param0_len
= param1_pos
- param0_pos
;
19486 char *param2_pos
= strchr (param1_pos
, '$');
19488 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19490 u32 param1_len
= param2_pos
- param1_pos
;
19494 char *param3_pos
= strchr (param2_pos
, '$');
19496 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19498 u32 param2_len
= param3_pos
- param2_pos
;
19502 char *param4_pos
= strchr (param3_pos
, '$');
19504 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19506 u32 param3_len
= param4_pos
- param3_pos
;
19510 char *param5_pos
= strchr (param4_pos
, '$');
19512 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19514 u32 param4_len
= param5_pos
- param4_pos
;
19518 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19520 char *salt_buf
= param1_pos
;
19521 char *iv
= param3_pos
;
19522 char *pswcheck
= param5_pos
;
19524 const uint salt_len
= atoi (param0_pos
);
19525 const uint iterations
= atoi (param2_pos
);
19526 const uint pswcheck_len
= atoi (param4_pos
);
19532 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19533 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19534 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19536 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19537 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19538 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19544 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19545 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19546 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19547 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19549 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19550 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19551 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19552 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19554 salt
->salt_len
= 16;
19556 salt
->salt_sign
[0] = iterations
;
19558 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19564 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19565 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19569 return (PARSER_OK
);
19572 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19574 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19576 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19578 u32
*digest
= (u32
*) hash_buf
->digest
;
19580 salt_t
*salt
= hash_buf
->salt
;
19582 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19589 char *account_pos
= input_buf
+ 11 + 1;
19595 if (account_pos
[0] == '*')
19599 data_pos
= strchr (account_pos
, '*');
19604 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19606 uint account_len
= data_pos
- account_pos
+ 1;
19608 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19613 data_len
= input_len
- 11 - 1 - account_len
- 2;
19615 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19619 /* assume $krb5tgs$23$checksum$edata2 */
19620 data_pos
= account_pos
;
19622 memcpy (krb5tgs
->account_info
, "**", 3);
19624 data_len
= input_len
- 11 - 1 - 1;
19627 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19629 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19631 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19633 const char p0
= data_pos
[i
+ 0];
19634 const char p1
= data_pos
[i
+ 1];
19636 *checksum_ptr
++ = hex_convert (p1
) << 0
19637 | hex_convert (p0
) << 4;
19640 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19642 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19645 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19647 const char p0
= data_pos
[i
+ 0];
19648 const char p1
= data_pos
[i
+ 1];
19649 *edata_ptr
++ = hex_convert (p1
) << 0
19650 | hex_convert (p0
) << 4;
19653 /* this is needed for hmac_md5 */
19654 *edata_ptr
++ = 0x80;
19656 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19657 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19658 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19659 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19661 salt
->salt_len
= 32;
19663 digest
[0] = krb5tgs
->checksum
[0];
19664 digest
[1] = krb5tgs
->checksum
[1];
19665 digest
[2] = krb5tgs
->checksum
[2];
19666 digest
[3] = krb5tgs
->checksum
[3];
19668 return (PARSER_OK
);
19671 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19673 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19675 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19677 u32
*digest
= (u32
*) hash_buf
->digest
;
19679 salt_t
*salt
= hash_buf
->salt
;
19686 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19690 char *wrapped_key_pos
;
19694 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19696 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19698 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19700 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19705 data_pos
= salt_pos
;
19707 wrapped_key_pos
= strchr (salt_pos
, '*');
19709 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19711 uint salt_len
= wrapped_key_pos
- salt_pos
;
19713 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19718 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19720 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19722 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19723 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19724 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19725 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19729 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19730 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19731 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19732 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19733 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19734 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19736 salt
->salt_len
= 40;
19738 digest
[0] = salt
->salt_buf
[0];
19739 digest
[1] = salt
->salt_buf
[1];
19740 digest
[2] = salt
->salt_buf
[2];
19741 digest
[3] = salt
->salt_buf
[3];
19743 return (PARSER_OK
);
19746 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19748 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19750 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19752 u32
*digest
= (u32
*) hash_buf
->digest
;
19754 salt_t
*salt
= hash_buf
->salt
;
19756 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19766 char *algorithm_pos
;
19768 char *final_random_seed_pos
;
19769 u32 final_random_seed_len
;
19771 char *transf_random_seed_pos
;
19772 u32 transf_random_seed_len
;
19777 /* default is no keyfile provided */
19778 char *keyfile_len_pos
;
19779 u32 keyfile_len
= 0;
19780 u32 is_keyfile_present
= 0;
19781 char *keyfile_inline_pos
;
19784 /* specific to version 1 */
19785 char *contents_len_pos
;
19787 char *contents_pos
;
19789 /* specific to version 2 */
19790 char *expected_bytes_pos
;
19791 u32 expected_bytes_len
;
19793 char *contents_hash_pos
;
19794 u32 contents_hash_len
;
19796 version_pos
= input_buf
+ 8 + 1 + 1;
19798 keepass
->version
= atoi (version_pos
);
19800 rounds_pos
= strchr (version_pos
, '*');
19802 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19806 salt
->salt_iter
= (atoi (rounds_pos
));
19808 algorithm_pos
= strchr (rounds_pos
, '*');
19810 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19814 keepass
->algorithm
= atoi (algorithm_pos
);
19816 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19818 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19820 final_random_seed_pos
++;
19822 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19823 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19824 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19825 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19827 if (keepass
->version
== 2)
19829 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19830 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19831 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19832 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19835 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19837 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19839 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19841 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19842 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19844 transf_random_seed_pos
++;
19846 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19847 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19848 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19849 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19850 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19851 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19852 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19853 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19855 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19857 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19859 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19861 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19865 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19866 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19867 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19868 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19870 if (keepass
->version
== 1)
19872 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19874 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19876 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19878 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19880 contents_hash_pos
++;
19882 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19883 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19884 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19885 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19886 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19887 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19888 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19889 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19891 /* get length of contents following */
19892 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19894 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19896 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19898 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19902 u32 inline_flag
= atoi (inline_flag_pos
);
19904 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19906 contents_len_pos
= strchr (inline_flag_pos
, '*');
19908 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19910 contents_len_pos
++;
19912 contents_len
= atoi (contents_len_pos
);
19914 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19916 contents_pos
= strchr (contents_len_pos
, '*');
19918 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19924 keepass
->contents_len
= contents_len
;
19926 contents_len
= contents_len
/ 4;
19928 keyfile_inline_pos
= strchr (contents_pos
, '*');
19930 u32 real_contents_len
;
19932 if (keyfile_inline_pos
== NULL
)
19933 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19936 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19937 keyfile_inline_pos
++;
19938 is_keyfile_present
= 1;
19941 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
19943 for (i
= 0; i
< contents_len
; i
++)
19944 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
19946 else if (keepass
->version
== 2)
19948 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
19950 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19952 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
19954 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19956 expected_bytes_pos
++;
19958 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
19959 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
19960 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
19961 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
19962 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
19963 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
19964 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
19965 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
19967 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
19969 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19971 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
19973 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
19975 contents_hash_pos
++;
19977 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19978 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19979 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19980 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19981 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19982 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19983 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19984 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19986 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
19988 if (keyfile_inline_pos
== NULL
)
19989 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
19992 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
19993 keyfile_inline_pos
++;
19994 is_keyfile_present
= 1;
19996 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19999 if (is_keyfile_present
!= 0)
20001 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
20005 keyfile_len
= atoi (keyfile_len_pos
);
20007 keepass
->keyfile_len
= keyfile_len
;
20009 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20011 keyfile_pos
= strchr (keyfile_len_pos
, '*');
20013 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20017 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
20019 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20021 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
20022 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
20023 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
20024 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
20025 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
20026 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
20027 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
20028 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
20031 digest
[0] = keepass
->enc_iv
[0];
20032 digest
[1] = keepass
->enc_iv
[1];
20033 digest
[2] = keepass
->enc_iv
[2];
20034 digest
[3] = keepass
->enc_iv
[3];
20036 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
20037 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
20038 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
20039 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
20040 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
20041 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
20042 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
20043 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
20045 return (PARSER_OK
);
20048 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20050 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
20052 u32
*digest
= (u32
*) hash_buf
->digest
;
20054 salt_t
*salt
= hash_buf
->salt
;
20056 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20057 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20058 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20059 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20060 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20061 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20062 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20063 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20065 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20067 uint salt_len
= input_len
- 64 - 1;
20069 char *salt_buf
= input_buf
+ 64 + 1;
20071 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
20073 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
20075 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
20077 salt
->salt_len
= salt_len
;
20080 * we can precompute the first sha256 transform
20083 uint w
[16] = { 0 };
20085 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
20086 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
20087 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
20088 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
20089 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
20090 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
20091 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
20092 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
20093 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
20094 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
20095 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
20096 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
20097 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
20098 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
20099 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
20100 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
20102 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
20104 sha256_64 (w
, pc256
);
20106 salt
->salt_buf_pc
[0] = pc256
[0];
20107 salt
->salt_buf_pc
[1] = pc256
[1];
20108 salt
->salt_buf_pc
[2] = pc256
[2];
20109 salt
->salt_buf_pc
[3] = pc256
[3];
20110 salt
->salt_buf_pc
[4] = pc256
[4];
20111 salt
->salt_buf_pc
[5] = pc256
[5];
20112 salt
->salt_buf_pc
[6] = pc256
[6];
20113 salt
->salt_buf_pc
[7] = pc256
[7];
20115 digest
[0] -= pc256
[0];
20116 digest
[1] -= pc256
[1];
20117 digest
[2] -= pc256
[2];
20118 digest
[3] -= pc256
[3];
20119 digest
[4] -= pc256
[4];
20120 digest
[5] -= pc256
[5];
20121 digest
[6] -= pc256
[6];
20122 digest
[7] -= pc256
[7];
20124 return (PARSER_OK
);
20127 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20129 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
20131 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
20133 u32
*digest
= (u32
*) hash_buf
->digest
;
20135 salt_t
*salt
= hash_buf
->salt
;
20141 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
20143 char *data_buf_pos
= strchr (data_len_pos
, '$');
20145 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20147 u32 data_len_len
= data_buf_pos
- data_len_pos
;
20149 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
20150 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
20154 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
20156 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
20158 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
20160 u32 data_len
= atoi (data_len_pos
);
20162 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
20168 char *salt_pos
= data_buf_pos
;
20170 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20171 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20172 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
20173 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
20175 // this is actually the CT, which is also the hash later (if matched)
20177 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
20178 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
20179 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
20180 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
20182 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
20184 salt
->salt_iter
= 10 - 1;
20190 digest
[0] = salt
->salt_buf
[4];
20191 digest
[1] = salt
->salt_buf
[5];
20192 digest
[2] = salt
->salt_buf
[6];
20193 digest
[3] = salt
->salt_buf
[7];
20195 return (PARSER_OK
);
20198 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20200 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
20202 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
20204 u32
*digest
= (u32
*) hash_buf
->digest
;
20206 salt_t
*salt
= hash_buf
->salt
;
20212 char *salt_pos
= input_buf
+ 11 + 1;
20214 char *iter_pos
= strchr (salt_pos
, ',');
20216 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20218 u32 salt_len
= iter_pos
- salt_pos
;
20220 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
20224 char *hash_pos
= strchr (iter_pos
, ',');
20226 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20228 u32 iter_len
= hash_pos
- iter_pos
;
20230 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
20234 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
20236 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
20242 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20243 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20244 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
20245 salt
->salt_buf
[3] = 0x00018000;
20247 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
20248 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
20249 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
20250 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
20252 salt
->salt_len
= salt_len
/ 2;
20254 salt
->salt_iter
= atoi (iter_pos
) - 1;
20260 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20261 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20262 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20263 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20264 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20265 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20266 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20267 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20269 return (PARSER_OK
);
20272 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20274 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
20276 u32
*digest
= (u32
*) hash_buf
->digest
;
20278 salt_t
*salt
= hash_buf
->salt
;
20284 char *hash_pos
= input_buf
+ 64;
20285 char *salt1_pos
= input_buf
+ 128;
20286 char *salt2_pos
= input_buf
;
20292 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
20293 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
20294 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
20295 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
20297 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
20298 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
20299 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
20300 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
20302 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
20303 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
20304 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
20305 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
20307 salt
->salt_len
= 48;
20309 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
20315 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20316 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20317 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20318 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20319 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20320 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20321 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20322 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20324 return (PARSER_OK
);
20327 int zip2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20329 if ((input_len
< DISPLAY_LEN_MIN_13600
) || (input_len
> DISPLAY_LEN_MAX_13600
)) return (PARSER_GLOBAL_LENGTH
);
20331 if (memcmp (SIGNATURE_ZIP2_START
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
20332 if (memcmp (SIGNATURE_ZIP2_STOP
, input_buf
+ input_len
- 7, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
20334 u32
*digest
= (u32
*) hash_buf
->digest
;
20336 salt_t
*salt
= hash_buf
->salt
;
20338 zip2_t
*zip2
= (zip2_t
*) hash_buf
->esalt
;
20344 char *param0_pos
= input_buf
+ 6 + 1;
20346 char *param1_pos
= strchr (param0_pos
, '*');
20348 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20350 u32 param0_len
= param1_pos
- param0_pos
;
20354 char *param2_pos
= strchr (param1_pos
, '*');
20356 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20358 u32 param1_len
= param2_pos
- param1_pos
;
20362 char *param3_pos
= strchr (param2_pos
, '*');
20364 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20366 u32 param2_len
= param3_pos
- param2_pos
;
20370 char *param4_pos
= strchr (param3_pos
, '*');
20372 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20374 u32 param3_len
= param4_pos
- param3_pos
;
20378 char *param5_pos
= strchr (param4_pos
, '*');
20380 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20382 u32 param4_len
= param5_pos
- param4_pos
;
20386 char *param6_pos
= strchr (param5_pos
, '*');
20388 if (param6_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20390 u32 param5_len
= param6_pos
- param5_pos
;
20394 char *param7_pos
= strchr (param6_pos
, '*');
20396 if (param7_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20398 u32 param6_len
= param7_pos
- param6_pos
;
20402 char *param8_pos
= strchr (param7_pos
, '*');
20404 if (param8_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20406 u32 param7_len
= param8_pos
- param7_pos
;
20410 const uint type
= atoi (param0_pos
);
20411 const uint mode
= atoi (param1_pos
);
20412 const uint magic
= atoi (param2_pos
);
20414 char *salt_buf
= param3_pos
;
20416 uint verify_bytes
; sscanf (param4_pos
, "%4x*", &verify_bytes
);
20418 const uint compress_length
= atoi (param5_pos
);
20420 char *data_buf
= param6_pos
;
20421 char *auth
= param7_pos
;
20427 if (param0_len
!= 1) return (PARSER_SALT_VALUE
);
20429 if (param1_len
!= 1) return (PARSER_SALT_VALUE
);
20431 if (param2_len
!= 1) return (PARSER_SALT_VALUE
);
20433 if ((param3_len
!= 16) && (param3_len
!= 24) && (param3_len
!= 32)) return (PARSER_SALT_VALUE
);
20435 if (param4_len
>= 5) return (PARSER_SALT_VALUE
);
20437 if (param5_len
>= 5) return (PARSER_SALT_VALUE
);
20439 if (param6_len
>= 8192) return (PARSER_SALT_VALUE
);
20441 if (param6_len
& 1) return (PARSER_SALT_VALUE
);
20443 if (param7_len
!= 20) return (PARSER_SALT_VALUE
);
20445 if (type
!= 0) return (PARSER_SALT_VALUE
);
20447 if ((mode
!= 1) && (mode
!= 2) && (mode
!= 3)) return (PARSER_SALT_VALUE
);
20449 if (magic
!= 0) return (PARSER_SALT_VALUE
);
20451 if (verify_bytes
>= 0x10000) return (PARSER_SALT_VALUE
);
20459 zip2
->magic
= magic
;
20463 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20464 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20465 zip2
->salt_buf
[2] = 0;
20466 zip2
->salt_buf
[3] = 0;
20468 zip2
->salt_len
= 8;
20470 else if (mode
== 2)
20472 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20473 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20474 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20475 zip2
->salt_buf
[3] = 0;
20477 zip2
->salt_len
= 12;
20479 else if (mode
== 3)
20481 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20482 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20483 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20484 zip2
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
20486 zip2
->salt_len
= 16;
20489 zip2
->salt_buf
[0] = byte_swap_32 (zip2
->salt_buf
[0]);
20490 zip2
->salt_buf
[1] = byte_swap_32 (zip2
->salt_buf
[1]);
20491 zip2
->salt_buf
[2] = byte_swap_32 (zip2
->salt_buf
[2]);
20492 zip2
->salt_buf
[3] = byte_swap_32 (zip2
->salt_buf
[3]);
20494 zip2
->verify_bytes
= verify_bytes
;
20496 zip2
->compress_length
= compress_length
;
20498 char *data_buf_ptr
= (char *) zip2
->data_buf
;
20500 for (uint i
= 0; i
< param6_len
; i
+= 2)
20502 const char p0
= data_buf
[i
+ 0];
20503 const char p1
= data_buf
[i
+ 1];
20505 *data_buf_ptr
++ = hex_convert (p1
) << 0
20506 | hex_convert (p0
) << 4;
20511 *data_buf_ptr
= 0x80;
20513 char *auth_ptr
= (char *) zip2
->auth_buf
;
20515 for (uint i
= 0; i
< param7_len
; i
+= 2)
20517 const char p0
= auth
[i
+ 0];
20518 const char p1
= auth
[i
+ 1];
20520 *auth_ptr
++ = hex_convert (p1
) << 0
20521 | hex_convert (p0
) << 4;
20530 salt
->salt_buf
[0] = zip2
->salt_buf
[0];
20531 salt
->salt_buf
[1] = zip2
->salt_buf
[1];
20532 salt
->salt_buf
[2] = zip2
->salt_buf
[2];
20533 salt
->salt_buf
[3] = zip2
->salt_buf
[3];
20534 salt
->salt_buf
[4] = zip2
->data_buf
[0];
20535 salt
->salt_buf
[5] = zip2
->data_buf
[1];
20536 salt
->salt_buf
[6] = zip2
->data_buf
[2];
20537 salt
->salt_buf
[7] = zip2
->data_buf
[3];
20539 salt
->salt_len
= 32;
20541 salt
->salt_iter
= ROUNDS_ZIP2
- 1;
20544 * digest buf (fake)
20547 digest
[0] = zip2
->auth_buf
[0];
20548 digest
[1] = zip2
->auth_buf
[1];
20549 digest
[2] = zip2
->auth_buf
[2];
20550 digest
[3] = zip2
->auth_buf
[3];
20552 return (PARSER_OK
);
20555 int win8phone_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20557 if ((input_len
< DISPLAY_LEN_MIN_13800
) || (input_len
> DISPLAY_LEN_MAX_13800
)) return (PARSER_GLOBAL_LENGTH
);
20559 u32
*digest
= (u32
*) hash_buf
->digest
;
20561 salt_t
*salt
= hash_buf
->salt
;
20563 win8phone_t
*esalt
= hash_buf
->esalt
;
20565 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20566 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20567 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20568 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20569 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20570 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20571 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20572 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20574 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20576 char *salt_buf_ptr
= input_buf
+ 64 + 1;
20578 u32
*salt_buf
= esalt
->salt_buf
;
20580 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
20582 salt_buf
[i
] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[j
]);
20585 salt
->salt_buf
[0] = salt_buf
[0];
20586 salt
->salt_buf
[1] = salt_buf
[1];
20587 salt
->salt_buf
[2] = salt_buf
[2];
20588 salt
->salt_buf
[3] = salt_buf
[3];
20589 salt
->salt_buf
[4] = salt_buf
[4];
20590 salt
->salt_buf
[5] = salt_buf
[5];
20591 salt
->salt_buf
[6] = salt_buf
[6];
20592 salt
->salt_buf
[7] = salt_buf
[7];
20594 salt
->salt_len
= 64;
20596 return (PARSER_OK
);
20600 * parallel running threads
20605 BOOL WINAPI
sigHandler_default (DWORD sig
)
20609 case CTRL_CLOSE_EVENT
:
20612 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
20613 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
20614 * function otherwise it is too late (e.g. after returning from this function)
20619 SetConsoleCtrlHandler (NULL
, TRUE
);
20626 case CTRL_LOGOFF_EVENT
:
20627 case CTRL_SHUTDOWN_EVENT
:
20631 SetConsoleCtrlHandler (NULL
, TRUE
);
20639 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
20643 case CTRL_CLOSE_EVENT
:
20647 SetConsoleCtrlHandler (NULL
, TRUE
);
20654 case CTRL_LOGOFF_EVENT
:
20655 case CTRL_SHUTDOWN_EVENT
:
20659 SetConsoleCtrlHandler (NULL
, TRUE
);
20667 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
20669 if (callback
== NULL
)
20671 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
20675 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
20681 void sigHandler_default (int sig
)
20685 signal (sig
, NULL
);
20688 void sigHandler_benchmark (int sig
)
20692 signal (sig
, NULL
);
20695 void hc_signal (void (callback
) (int))
20697 if (callback
== NULL
) callback
= SIG_DFL
;
20699 signal (SIGINT
, callback
);
20700 signal (SIGTERM
, callback
);
20701 signal (SIGABRT
, callback
);
20706 void status_display ();
20708 void *thread_keypress (void *p
)
20710 int benchmark
= *((int *) p
);
20712 uint quiet
= data
.quiet
;
20716 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
20718 int ch
= tty_getchar();
20720 if (ch
== -1) break;
20722 if (ch
== 0) continue;
20724 //https://github.com/hashcat/hashcat/issues/302
20729 hc_thread_mutex_lock (mux_display
);
20745 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20746 if (quiet
== 0) fflush (stdout
);
20758 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20759 if (quiet
== 0) fflush (stdout
);
20771 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20772 if (quiet
== 0) fflush (stdout
);
20784 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20785 if (quiet
== 0) fflush (stdout
);
20793 if (benchmark
== 1) break;
20795 stop_at_checkpoint ();
20799 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20800 if (quiet
== 0) fflush (stdout
);
20808 if (benchmark
== 1)
20820 //https://github.com/hashcat/hashcat/issues/302
20825 hc_thread_mutex_unlock (mux_display
);
20837 bool class_num (const u8 c
)
20839 return ((c
>= '0') && (c
<= '9'));
20842 bool class_lower (const u8 c
)
20844 return ((c
>= 'a') && (c
<= 'z'));
20847 bool class_upper (const u8 c
)
20849 return ((c
>= 'A') && (c
<= 'Z'));
20852 bool class_alpha (const u8 c
)
20854 return (class_lower (c
) || class_upper (c
));
20857 int conv_ctoi (const u8 c
)
20863 else if (class_upper (c
))
20865 return c
- 'A' + 10;
20871 int conv_itoc (const u8 c
)
20879 return c
+ 'A' - 10;
20889 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20890 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20891 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20892 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20893 #define MAX_KERNEL_RULES 255
20894 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20895 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20896 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20898 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20899 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20900 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20901 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20903 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20908 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20910 switch (rule_buf
[rule_pos
])
20916 case RULE_OP_MANGLE_NOOP
:
20917 SET_NAME (rule
, rule_buf
[rule_pos
]);
20920 case RULE_OP_MANGLE_LREST
:
20921 SET_NAME (rule
, rule_buf
[rule_pos
]);
20924 case RULE_OP_MANGLE_UREST
:
20925 SET_NAME (rule
, rule_buf
[rule_pos
]);
20928 case RULE_OP_MANGLE_LREST_UFIRST
:
20929 SET_NAME (rule
, rule_buf
[rule_pos
]);
20932 case RULE_OP_MANGLE_UREST_LFIRST
:
20933 SET_NAME (rule
, rule_buf
[rule_pos
]);
20936 case RULE_OP_MANGLE_TREST
:
20937 SET_NAME (rule
, rule_buf
[rule_pos
]);
20940 case RULE_OP_MANGLE_TOGGLE_AT
:
20941 SET_NAME (rule
, rule_buf
[rule_pos
]);
20942 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20945 case RULE_OP_MANGLE_REVERSE
:
20946 SET_NAME (rule
, rule_buf
[rule_pos
]);
20949 case RULE_OP_MANGLE_DUPEWORD
:
20950 SET_NAME (rule
, rule_buf
[rule_pos
]);
20953 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20954 SET_NAME (rule
, rule_buf
[rule_pos
]);
20955 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20958 case RULE_OP_MANGLE_REFLECT
:
20959 SET_NAME (rule
, rule_buf
[rule_pos
]);
20962 case RULE_OP_MANGLE_ROTATE_LEFT
:
20963 SET_NAME (rule
, rule_buf
[rule_pos
]);
20966 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20967 SET_NAME (rule
, rule_buf
[rule_pos
]);
20970 case RULE_OP_MANGLE_APPEND
:
20971 SET_NAME (rule
, rule_buf
[rule_pos
]);
20972 SET_P0 (rule
, rule_buf
[rule_pos
]);
20975 case RULE_OP_MANGLE_PREPEND
:
20976 SET_NAME (rule
, rule_buf
[rule_pos
]);
20977 SET_P0 (rule
, rule_buf
[rule_pos
]);
20980 case RULE_OP_MANGLE_DELETE_FIRST
:
20981 SET_NAME (rule
, rule_buf
[rule_pos
]);
20984 case RULE_OP_MANGLE_DELETE_LAST
:
20985 SET_NAME (rule
, rule_buf
[rule_pos
]);
20988 case RULE_OP_MANGLE_DELETE_AT
:
20989 SET_NAME (rule
, rule_buf
[rule_pos
]);
20990 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20993 case RULE_OP_MANGLE_EXTRACT
:
20994 SET_NAME (rule
, rule_buf
[rule_pos
]);
20995 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20996 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20999 case RULE_OP_MANGLE_OMIT
:
21000 SET_NAME (rule
, rule_buf
[rule_pos
]);
21001 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21002 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21005 case RULE_OP_MANGLE_INSERT
:
21006 SET_NAME (rule
, rule_buf
[rule_pos
]);
21007 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21008 SET_P1 (rule
, rule_buf
[rule_pos
]);
21011 case RULE_OP_MANGLE_OVERSTRIKE
:
21012 SET_NAME (rule
, rule_buf
[rule_pos
]);
21013 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21014 SET_P1 (rule
, rule_buf
[rule_pos
]);
21017 case RULE_OP_MANGLE_TRUNCATE_AT
:
21018 SET_NAME (rule
, rule_buf
[rule_pos
]);
21019 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21022 case RULE_OP_MANGLE_REPLACE
:
21023 SET_NAME (rule
, rule_buf
[rule_pos
]);
21024 SET_P0 (rule
, rule_buf
[rule_pos
]);
21025 SET_P1 (rule
, rule_buf
[rule_pos
]);
21028 case RULE_OP_MANGLE_PURGECHAR
:
21032 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21036 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21037 SET_NAME (rule
, rule_buf
[rule_pos
]);
21038 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21041 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21042 SET_NAME (rule
, rule_buf
[rule_pos
]);
21043 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21046 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21047 SET_NAME (rule
, rule_buf
[rule_pos
]);
21050 case RULE_OP_MANGLE_SWITCH_FIRST
:
21051 SET_NAME (rule
, rule_buf
[rule_pos
]);
21054 case RULE_OP_MANGLE_SWITCH_LAST
:
21055 SET_NAME (rule
, rule_buf
[rule_pos
]);
21058 case RULE_OP_MANGLE_SWITCH_AT
:
21059 SET_NAME (rule
, rule_buf
[rule_pos
]);
21060 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21061 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21064 case RULE_OP_MANGLE_CHR_SHIFTL
:
21065 SET_NAME (rule
, rule_buf
[rule_pos
]);
21066 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21069 case RULE_OP_MANGLE_CHR_SHIFTR
:
21070 SET_NAME (rule
, rule_buf
[rule_pos
]);
21071 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21074 case RULE_OP_MANGLE_CHR_INCR
:
21075 SET_NAME (rule
, rule_buf
[rule_pos
]);
21076 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21079 case RULE_OP_MANGLE_CHR_DECR
:
21080 SET_NAME (rule
, rule_buf
[rule_pos
]);
21081 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21084 case RULE_OP_MANGLE_REPLACE_NP1
:
21085 SET_NAME (rule
, rule_buf
[rule_pos
]);
21086 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21089 case RULE_OP_MANGLE_REPLACE_NM1
:
21090 SET_NAME (rule
, rule_buf
[rule_pos
]);
21091 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21094 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21095 SET_NAME (rule
, rule_buf
[rule_pos
]);
21096 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21099 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21100 SET_NAME (rule
, rule_buf
[rule_pos
]);
21101 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21104 case RULE_OP_MANGLE_TITLE
:
21105 SET_NAME (rule
, rule_buf
[rule_pos
]);
21114 if (rule_pos
< rule_len
) return (-1);
21119 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
21123 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
21127 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
21131 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
21135 case RULE_OP_MANGLE_NOOP
:
21136 rule_buf
[rule_pos
] = rule_cmd
;
21139 case RULE_OP_MANGLE_LREST
:
21140 rule_buf
[rule_pos
] = rule_cmd
;
21143 case RULE_OP_MANGLE_UREST
:
21144 rule_buf
[rule_pos
] = rule_cmd
;
21147 case RULE_OP_MANGLE_LREST_UFIRST
:
21148 rule_buf
[rule_pos
] = rule_cmd
;
21151 case RULE_OP_MANGLE_UREST_LFIRST
:
21152 rule_buf
[rule_pos
] = rule_cmd
;
21155 case RULE_OP_MANGLE_TREST
:
21156 rule_buf
[rule_pos
] = rule_cmd
;
21159 case RULE_OP_MANGLE_TOGGLE_AT
:
21160 rule_buf
[rule_pos
] = rule_cmd
;
21161 GET_P0_CONV (rule
);
21164 case RULE_OP_MANGLE_REVERSE
:
21165 rule_buf
[rule_pos
] = rule_cmd
;
21168 case RULE_OP_MANGLE_DUPEWORD
:
21169 rule_buf
[rule_pos
] = rule_cmd
;
21172 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21173 rule_buf
[rule_pos
] = rule_cmd
;
21174 GET_P0_CONV (rule
);
21177 case RULE_OP_MANGLE_REFLECT
:
21178 rule_buf
[rule_pos
] = rule_cmd
;
21181 case RULE_OP_MANGLE_ROTATE_LEFT
:
21182 rule_buf
[rule_pos
] = rule_cmd
;
21185 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21186 rule_buf
[rule_pos
] = rule_cmd
;
21189 case RULE_OP_MANGLE_APPEND
:
21190 rule_buf
[rule_pos
] = rule_cmd
;
21194 case RULE_OP_MANGLE_PREPEND
:
21195 rule_buf
[rule_pos
] = rule_cmd
;
21199 case RULE_OP_MANGLE_DELETE_FIRST
:
21200 rule_buf
[rule_pos
] = rule_cmd
;
21203 case RULE_OP_MANGLE_DELETE_LAST
:
21204 rule_buf
[rule_pos
] = rule_cmd
;
21207 case RULE_OP_MANGLE_DELETE_AT
:
21208 rule_buf
[rule_pos
] = rule_cmd
;
21209 GET_P0_CONV (rule
);
21212 case RULE_OP_MANGLE_EXTRACT
:
21213 rule_buf
[rule_pos
] = rule_cmd
;
21214 GET_P0_CONV (rule
);
21215 GET_P1_CONV (rule
);
21218 case RULE_OP_MANGLE_OMIT
:
21219 rule_buf
[rule_pos
] = rule_cmd
;
21220 GET_P0_CONV (rule
);
21221 GET_P1_CONV (rule
);
21224 case RULE_OP_MANGLE_INSERT
:
21225 rule_buf
[rule_pos
] = rule_cmd
;
21226 GET_P0_CONV (rule
);
21230 case RULE_OP_MANGLE_OVERSTRIKE
:
21231 rule_buf
[rule_pos
] = rule_cmd
;
21232 GET_P0_CONV (rule
);
21236 case RULE_OP_MANGLE_TRUNCATE_AT
:
21237 rule_buf
[rule_pos
] = rule_cmd
;
21238 GET_P0_CONV (rule
);
21241 case RULE_OP_MANGLE_REPLACE
:
21242 rule_buf
[rule_pos
] = rule_cmd
;
21247 case RULE_OP_MANGLE_PURGECHAR
:
21251 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21255 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21256 rule_buf
[rule_pos
] = rule_cmd
;
21257 GET_P0_CONV (rule
);
21260 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21261 rule_buf
[rule_pos
] = rule_cmd
;
21262 GET_P0_CONV (rule
);
21265 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21266 rule_buf
[rule_pos
] = rule_cmd
;
21269 case RULE_OP_MANGLE_SWITCH_FIRST
:
21270 rule_buf
[rule_pos
] = rule_cmd
;
21273 case RULE_OP_MANGLE_SWITCH_LAST
:
21274 rule_buf
[rule_pos
] = rule_cmd
;
21277 case RULE_OP_MANGLE_SWITCH_AT
:
21278 rule_buf
[rule_pos
] = rule_cmd
;
21279 GET_P0_CONV (rule
);
21280 GET_P1_CONV (rule
);
21283 case RULE_OP_MANGLE_CHR_SHIFTL
:
21284 rule_buf
[rule_pos
] = rule_cmd
;
21285 GET_P0_CONV (rule
);
21288 case RULE_OP_MANGLE_CHR_SHIFTR
:
21289 rule_buf
[rule_pos
] = rule_cmd
;
21290 GET_P0_CONV (rule
);
21293 case RULE_OP_MANGLE_CHR_INCR
:
21294 rule_buf
[rule_pos
] = rule_cmd
;
21295 GET_P0_CONV (rule
);
21298 case RULE_OP_MANGLE_CHR_DECR
:
21299 rule_buf
[rule_pos
] = rule_cmd
;
21300 GET_P0_CONV (rule
);
21303 case RULE_OP_MANGLE_REPLACE_NP1
:
21304 rule_buf
[rule_pos
] = rule_cmd
;
21305 GET_P0_CONV (rule
);
21308 case RULE_OP_MANGLE_REPLACE_NM1
:
21309 rule_buf
[rule_pos
] = rule_cmd
;
21310 GET_P0_CONV (rule
);
21313 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21314 rule_buf
[rule_pos
] = rule_cmd
;
21315 GET_P0_CONV (rule
);
21318 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21319 rule_buf
[rule_pos
] = rule_cmd
;
21320 GET_P0_CONV (rule
);
21323 case RULE_OP_MANGLE_TITLE
:
21324 rule_buf
[rule_pos
] = rule_cmd
;
21328 return rule_pos
- 1;
21346 * CPU rules : this is from hashcat sources, cpu based rules
21349 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
21350 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
21352 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
21353 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
21354 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
21356 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
21357 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
21358 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
21360 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
21364 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
21369 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
21373 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
21378 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
21382 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
21387 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
21392 for (l
= 0; l
< arr_len
; l
++)
21394 r
= arr_len
- 1 - l
;
21398 MANGLE_SWITCH (arr
, l
, r
);
21404 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
21406 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21408 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
21410 return (arr_len
* 2);
21413 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
21415 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21417 int orig_len
= arr_len
;
21421 for (i
= 0; i
< times
; i
++)
21423 memcpy (&arr
[arr_len
], arr
, orig_len
);
21425 arr_len
+= orig_len
;
21431 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
21433 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21435 mangle_double (arr
, arr_len
);
21437 mangle_reverse (arr
+ arr_len
, arr_len
);
21439 return (arr_len
* 2);
21442 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
21447 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
21449 MANGLE_SWITCH (arr
, l
, r
);
21455 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
21460 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
21462 MANGLE_SWITCH (arr
, l
, r
);
21468 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21470 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21474 return (arr_len
+ 1);
21477 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21479 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21483 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21485 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21490 return (arr_len
+ 1);
21493 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21495 if (upos
>= arr_len
) return (arr_len
);
21499 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
21501 arr
[arr_pos
] = arr
[arr_pos
+ 1];
21504 return (arr_len
- 1);
21507 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21509 if (upos
>= arr_len
) return (arr_len
);
21511 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
21515 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
21517 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
21523 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21525 if (upos
>= arr_len
) return (arr_len
);
21527 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
21531 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
21533 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
21536 return (arr_len
- ulen
);
21539 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21541 if (upos
>= arr_len
) return (arr_len
);
21543 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21547 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
21549 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21554 return (arr_len
+ 1);
21557 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
)
21559 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21561 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
21563 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
21565 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
21567 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
21569 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
21571 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
21573 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
21575 return (arr_len
+ arr2_cpy
);
21578 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21580 if (upos
>= arr_len
) return (arr_len
);
21587 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21589 if (upos
>= arr_len
) return (arr_len
);
21591 memset (arr
+ upos
, 0, arr_len
- upos
);
21596 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
21600 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21602 if (arr
[arr_pos
] != oldc
) continue;
21604 arr
[arr_pos
] = newc
;
21610 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21616 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21618 if (arr
[arr_pos
] == c
) continue;
21620 arr
[ret_len
] = arr
[arr_pos
];
21628 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21630 if (ulen
> arr_len
) return (arr_len
);
21632 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21634 char cs
[100] = { 0 };
21636 memcpy (cs
, arr
, ulen
);
21640 for (i
= 0; i
< ulen
; i
++)
21644 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
21650 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21652 if (ulen
> arr_len
) return (arr_len
);
21654 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21656 int upos
= arr_len
- ulen
;
21660 for (i
= 0; i
< ulen
; i
++)
21662 char c
= arr
[upos
+ i
];
21664 arr_len
= mangle_append (arr
, arr_len
, c
);
21670 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21672 if ( arr_len
== 0) return (arr_len
);
21673 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21675 char c
= arr
[upos
];
21679 for (i
= 0; i
< ulen
; i
++)
21681 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
21687 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
21689 if ( arr_len
== 0) return (arr_len
);
21690 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21694 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21696 int new_pos
= arr_pos
* 2;
21698 arr
[new_pos
] = arr
[arr_pos
];
21700 arr
[new_pos
+ 1] = arr
[arr_pos
];
21703 return (arr_len
* 2);
21706 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21708 if (upos
>= arr_len
) return (arr_len
);
21709 if (upos2
>= arr_len
) return (arr_len
);
21711 MANGLE_SWITCH (arr
, upos
, upos2
);
21716 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21718 MANGLE_SWITCH (arr
, upos
, upos2
);
21723 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21725 if (upos
>= arr_len
) return (arr_len
);
21732 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21734 if (upos
>= arr_len
) return (arr_len
);
21741 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21743 if (upos
>= arr_len
) return (arr_len
);
21750 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21752 if (upos
>= arr_len
) return (arr_len
);
21759 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21761 int upper_next
= 1;
21765 for (pos
= 0; pos
< arr_len
; pos
++)
21767 if (arr
[pos
] == ' ')
21778 MANGLE_UPPER_AT (arr
, pos
);
21782 MANGLE_LOWER_AT (arr
, pos
);
21789 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21791 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21797 for (j
= 0; j
< rp_gen_num
; j
++)
21804 switch ((char) get_random_num (0, 9))
21807 r
= get_random_num (0, sizeof (grp_op_nop
));
21808 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21812 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21813 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21814 p1
= get_random_num (0, sizeof (grp_pos
));
21815 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21819 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21820 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21821 p1
= get_random_num (1, 6);
21822 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21826 r
= get_random_num (0, sizeof (grp_op_chr
));
21827 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21828 p1
= get_random_num (0x20, 0x7e);
21829 rule_buf
[rule_pos
++] = (char) p1
;
21833 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21834 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21835 p1
= get_random_num (0x20, 0x7e);
21836 rule_buf
[rule_pos
++] = (char) p1
;
21837 p2
= get_random_num (0x20, 0x7e);
21839 p2
= get_random_num (0x20, 0x7e);
21840 rule_buf
[rule_pos
++] = (char) p2
;
21844 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21845 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21846 p1
= get_random_num (0, sizeof (grp_pos
));
21847 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21848 p2
= get_random_num (0x20, 0x7e);
21849 rule_buf
[rule_pos
++] = (char) p2
;
21853 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21854 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21855 p1
= get_random_num (0, sizeof (grp_pos
));
21856 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21857 p2
= get_random_num (0, sizeof (grp_pos
));
21859 p2
= get_random_num (0, sizeof (grp_pos
));
21860 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21864 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21865 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21866 p1
= get_random_num (0, sizeof (grp_pos
));
21867 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21868 p2
= get_random_num (1, sizeof (grp_pos
));
21870 p2
= get_random_num (1, sizeof (grp_pos
));
21871 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21875 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21876 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21877 p1
= get_random_num (0, sizeof (grp_pos
));
21878 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21879 p2
= get_random_num (1, sizeof (grp_pos
));
21880 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21881 p3
= get_random_num (0, sizeof (grp_pos
));
21882 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21890 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21892 char mem
[BLOCK_SIZE
] = { 0 };
21894 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21896 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21898 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21900 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21902 int out_len
= in_len
;
21903 int mem_len
= in_len
;
21905 memcpy (out
, in
, out_len
);
21909 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21914 switch (rule
[rule_pos
])
21919 case RULE_OP_MANGLE_NOOP
:
21922 case RULE_OP_MANGLE_LREST
:
21923 out_len
= mangle_lrest (out
, out_len
);
21926 case RULE_OP_MANGLE_UREST
:
21927 out_len
= mangle_urest (out
, out_len
);
21930 case RULE_OP_MANGLE_LREST_UFIRST
:
21931 out_len
= mangle_lrest (out
, out_len
);
21932 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21935 case RULE_OP_MANGLE_UREST_LFIRST
:
21936 out_len
= mangle_urest (out
, out_len
);
21937 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21940 case RULE_OP_MANGLE_TREST
:
21941 out_len
= mangle_trest (out
, out_len
);
21944 case RULE_OP_MANGLE_TOGGLE_AT
:
21945 NEXT_RULEPOS (rule_pos
);
21946 NEXT_RPTOI (rule
, rule_pos
, upos
);
21947 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21950 case RULE_OP_MANGLE_REVERSE
:
21951 out_len
= mangle_reverse (out
, out_len
);
21954 case RULE_OP_MANGLE_DUPEWORD
:
21955 out_len
= mangle_double (out
, out_len
);
21958 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21959 NEXT_RULEPOS (rule_pos
);
21960 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21961 out_len
= mangle_double_times (out
, out_len
, ulen
);
21964 case RULE_OP_MANGLE_REFLECT
:
21965 out_len
= mangle_reflect (out
, out_len
);
21968 case RULE_OP_MANGLE_ROTATE_LEFT
:
21969 mangle_rotate_left (out
, out_len
);
21972 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21973 mangle_rotate_right (out
, out_len
);
21976 case RULE_OP_MANGLE_APPEND
:
21977 NEXT_RULEPOS (rule_pos
);
21978 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
21981 case RULE_OP_MANGLE_PREPEND
:
21982 NEXT_RULEPOS (rule_pos
);
21983 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
21986 case RULE_OP_MANGLE_DELETE_FIRST
:
21987 out_len
= mangle_delete_at (out
, out_len
, 0);
21990 case RULE_OP_MANGLE_DELETE_LAST
:
21991 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
21994 case RULE_OP_MANGLE_DELETE_AT
:
21995 NEXT_RULEPOS (rule_pos
);
21996 NEXT_RPTOI (rule
, rule_pos
, upos
);
21997 out_len
= mangle_delete_at (out
, out_len
, upos
);
22000 case RULE_OP_MANGLE_EXTRACT
:
22001 NEXT_RULEPOS (rule_pos
);
22002 NEXT_RPTOI (rule
, rule_pos
, upos
);
22003 NEXT_RULEPOS (rule_pos
);
22004 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22005 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
22008 case RULE_OP_MANGLE_OMIT
:
22009 NEXT_RULEPOS (rule_pos
);
22010 NEXT_RPTOI (rule
, rule_pos
, upos
);
22011 NEXT_RULEPOS (rule_pos
);
22012 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22013 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
22016 case RULE_OP_MANGLE_INSERT
:
22017 NEXT_RULEPOS (rule_pos
);
22018 NEXT_RPTOI (rule
, rule_pos
, upos
);
22019 NEXT_RULEPOS (rule_pos
);
22020 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
22023 case RULE_OP_MANGLE_OVERSTRIKE
:
22024 NEXT_RULEPOS (rule_pos
);
22025 NEXT_RPTOI (rule
, rule_pos
, upos
);
22026 NEXT_RULEPOS (rule_pos
);
22027 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
22030 case RULE_OP_MANGLE_TRUNCATE_AT
:
22031 NEXT_RULEPOS (rule_pos
);
22032 NEXT_RPTOI (rule
, rule_pos
, upos
);
22033 out_len
= mangle_truncate_at (out
, out_len
, upos
);
22036 case RULE_OP_MANGLE_REPLACE
:
22037 NEXT_RULEPOS (rule_pos
);
22038 NEXT_RULEPOS (rule_pos
);
22039 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
22042 case RULE_OP_MANGLE_PURGECHAR
:
22043 NEXT_RULEPOS (rule_pos
);
22044 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
22047 case RULE_OP_MANGLE_TOGGLECASE_REC
:
22051 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
22052 NEXT_RULEPOS (rule_pos
);
22053 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22054 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
22057 case RULE_OP_MANGLE_DUPECHAR_LAST
:
22058 NEXT_RULEPOS (rule_pos
);
22059 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22060 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
22063 case RULE_OP_MANGLE_DUPECHAR_ALL
:
22064 out_len
= mangle_dupechar (out
, out_len
);
22067 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
22068 NEXT_RULEPOS (rule_pos
);
22069 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22070 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
22073 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
22074 NEXT_RULEPOS (rule_pos
);
22075 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22076 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
22079 case RULE_OP_MANGLE_SWITCH_FIRST
:
22080 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
22083 case RULE_OP_MANGLE_SWITCH_LAST
:
22084 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
22087 case RULE_OP_MANGLE_SWITCH_AT
:
22088 NEXT_RULEPOS (rule_pos
);
22089 NEXT_RPTOI (rule
, rule_pos
, upos
);
22090 NEXT_RULEPOS (rule_pos
);
22091 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22092 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
22095 case RULE_OP_MANGLE_CHR_SHIFTL
:
22096 NEXT_RULEPOS (rule_pos
);
22097 NEXT_RPTOI (rule
, rule_pos
, upos
);
22098 mangle_chr_shiftl (out
, out_len
, upos
);
22101 case RULE_OP_MANGLE_CHR_SHIFTR
:
22102 NEXT_RULEPOS (rule_pos
);
22103 NEXT_RPTOI (rule
, rule_pos
, upos
);
22104 mangle_chr_shiftr (out
, out_len
, upos
);
22107 case RULE_OP_MANGLE_CHR_INCR
:
22108 NEXT_RULEPOS (rule_pos
);
22109 NEXT_RPTOI (rule
, rule_pos
, upos
);
22110 mangle_chr_incr (out
, out_len
, upos
);
22113 case RULE_OP_MANGLE_CHR_DECR
:
22114 NEXT_RULEPOS (rule_pos
);
22115 NEXT_RPTOI (rule
, rule_pos
, upos
);
22116 mangle_chr_decr (out
, out_len
, upos
);
22119 case RULE_OP_MANGLE_REPLACE_NP1
:
22120 NEXT_RULEPOS (rule_pos
);
22121 NEXT_RPTOI (rule
, rule_pos
, upos
);
22122 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
22125 case RULE_OP_MANGLE_REPLACE_NM1
:
22126 NEXT_RULEPOS (rule_pos
);
22127 NEXT_RPTOI (rule
, rule_pos
, upos
);
22128 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
22131 case RULE_OP_MANGLE_TITLE
:
22132 out_len
= mangle_title (out
, out_len
);
22135 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
22136 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22137 NEXT_RULEPOS (rule_pos
);
22138 NEXT_RPTOI (rule
, rule_pos
, upos
);
22139 NEXT_RULEPOS (rule_pos
);
22140 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22141 NEXT_RULEPOS (rule_pos
);
22142 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22143 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
22146 case RULE_OP_MANGLE_APPEND_MEMORY
:
22147 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22148 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22149 memcpy (out
+ out_len
, mem
, mem_len
);
22150 out_len
+= mem_len
;
22153 case RULE_OP_MANGLE_PREPEND_MEMORY
:
22154 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22155 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22156 memcpy (mem
+ mem_len
, out
, out_len
);
22157 out_len
+= mem_len
;
22158 memcpy (out
, mem
, out_len
);
22161 case RULE_OP_MEMORIZE_WORD
:
22162 memcpy (mem
, out
, out_len
);
22166 case RULE_OP_REJECT_LESS
:
22167 NEXT_RULEPOS (rule_pos
);
22168 NEXT_RPTOI (rule
, rule_pos
, upos
);
22169 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
22172 case RULE_OP_REJECT_GREATER
:
22173 NEXT_RULEPOS (rule_pos
);
22174 NEXT_RPTOI (rule
, rule_pos
, upos
);
22175 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
22178 case RULE_OP_REJECT_CONTAIN
:
22179 NEXT_RULEPOS (rule_pos
);
22180 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
22183 case RULE_OP_REJECT_NOT_CONTAIN
:
22184 NEXT_RULEPOS (rule_pos
);
22185 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
22188 case RULE_OP_REJECT_EQUAL_FIRST
:
22189 NEXT_RULEPOS (rule_pos
);
22190 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22193 case RULE_OP_REJECT_EQUAL_LAST
:
22194 NEXT_RULEPOS (rule_pos
);
22195 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22198 case RULE_OP_REJECT_EQUAL_AT
:
22199 NEXT_RULEPOS (rule_pos
);
22200 NEXT_RPTOI (rule
, rule_pos
, upos
);
22201 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22202 NEXT_RULEPOS (rule_pos
);
22203 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22206 case RULE_OP_REJECT_CONTAINS
:
22207 NEXT_RULEPOS (rule_pos
);
22208 NEXT_RPTOI (rule
, rule_pos
, upos
);
22209 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22210 NEXT_RULEPOS (rule_pos
);
22211 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
22212 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
22215 case RULE_OP_REJECT_MEMORY
:
22216 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
22220 return (RULE_RC_SYNTAX_ERROR
);
22225 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);