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
)
3198 if (data
.hm_xnvctrl
)
3200 if (set_fan_control (data
.hm_xnvctrl
, data
.hm_device
[device_id
].xnvctrl
, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_TRUE
) != 0) return -1;
3215 int hm_get_fanspeed_with_device_id (const uint device_id
)
3217 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3219 if (data
.hm_device
[device_id
].fan_get_supported
== 1)
3221 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3225 if (data
.hm_device
[device_id
].od_version
== 5)
3227 ADLFanSpeedValue lpFanSpeedValue
;
3229 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3231 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3232 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3233 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3235 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3237 return lpFanSpeedValue
.iFanSpeed
;
3239 else // od_version == 6
3241 ADLOD6FanSpeedInfo faninfo
;
3243 memset (&faninfo
, 0, sizeof (faninfo
));
3245 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &faninfo
) != ADL_OK
) return -1;
3247 return faninfo
.iFanSpeedPercent
;
3252 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3256 if (hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nvml
, 0, data
.hm_device
[device_id
].nvml
, (uint
*) &speed
) != NVML_SUCCESS
) return -1;
3265 int hm_get_buslanes_with_device_id (const uint device_id
)
3267 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3269 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3273 ADLPMActivity PMActivity
;
3275 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3277 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3279 return PMActivity
.iCurrentBusLanes
;
3283 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3285 unsigned int currLinkWidth
;
3287 if (hm_NVML_nvmlDeviceGetCurrPcieLinkWidth (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &currLinkWidth
) != NVML_SUCCESS
) return -1;
3289 return currLinkWidth
;
3295 int hm_get_utilization_with_device_id (const uint device_id
)
3297 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3299 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3303 ADLPMActivity PMActivity
;
3305 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3307 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3309 return PMActivity
.iActivityPercent
;
3313 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3315 nvmlUtilization_t utilization
;
3317 if (hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &utilization
) != NVML_SUCCESS
) return -1;
3319 return utilization
.gpu
;
3325 int hm_get_memoryspeed_with_device_id (const uint device_id
)
3327 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3329 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3333 ADLPMActivity PMActivity
;
3335 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3337 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3339 return PMActivity
.iMemoryClock
/ 100;
3343 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3347 if (hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_CLOCK_MEM
, &clock
) != NVML_SUCCESS
) return -1;
3355 int hm_get_corespeed_with_device_id (const uint device_id
)
3357 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3359 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3363 ADLPMActivity PMActivity
;
3365 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3367 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3369 return PMActivity
.iEngineClock
/ 100;
3373 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3377 if (hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_CLOCK_SM
, &clock
) != NVML_SUCCESS
) return -1;
3385 int hm_get_throttle_with_device_id (const uint device_id
)
3387 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3389 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3394 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3396 unsigned long long clocksThrottleReasons
= 0;
3397 unsigned long long supportedThrottleReasons
= 0;
3399 if (hm_NVML_nvmlDeviceGetCurrentClocksThrottleReasons (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &clocksThrottleReasons
) != NVML_SUCCESS
) return -1;
3400 if (hm_NVML_nvmlDeviceGetSupportedClocksThrottleReasons (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &supportedThrottleReasons
) != NVML_SUCCESS
) return -1;
3402 clocksThrottleReasons
&= supportedThrottleReasons
;
3404 clocksThrottleReasons
&= ~nvmlClocksThrottleReasonUnknown
;
3406 return (clocksThrottleReasons
> 0);
3412 int hm_set_fanspeed_with_device_id_xnvctrl (const uint device_id
, const int fanspeed
)
3414 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3416 if (data
.hm_xnvctrl
)
3418 if (set_fan_speed_target (data
.hm_xnvctrl
, data
.hm_device
[device_id
].xnvctrl
, fanspeed
) != 0) return -1;
3427 int hm_set_fanspeed_with_device_id_adl (const uint device_id
, const int fanspeed
, const int fanpolicy
)
3429 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3433 if (data
.hm_device
[device_id
].od_version
== 5)
3435 ADLFanSpeedValue lpFanSpeedValue
;
3437 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3439 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3440 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3441 lpFanSpeedValue
.iFlags
= (fanpolicy
== 1) ? ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
: 0;
3442 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3444 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3448 else // od_version == 6
3450 ADLOD6FanSpeedValue fan_speed_value
;
3452 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3454 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3455 fan_speed_value
.iFanSpeed
= fanspeed
;
3457 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &fan_speed_value
) != ADL_OK
) return -1;
3467 #endif // HAVE_HWMON
3473 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3475 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3477 if (css_cnt
> SP_PW_MAX
)
3479 log_error ("ERROR: mask length is too long");
3484 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3486 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3488 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3489 uint cs_len
= css
[css_pos
].cs_len
;
3491 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3493 uint c
= cs_buf
[cs_pos
] & 0xff;
3500 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3502 cs_t
*cs
= &css
[css_cnt
];
3504 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3506 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3510 for (i
= 0; i
< cs
->cs_len
; i
++)
3512 const uint u
= cs
->cs_buf
[i
];
3517 for (i
= 0; i
< in_len
; i
++)
3519 uint u
= in_buf
[i
] & 0xff;
3521 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3523 if (css_uniq
[u
] == 1) continue;
3527 cs
->cs_buf
[cs
->cs_len
] = u
;
3535 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3539 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3541 uint p0
= in_buf
[in_pos
] & 0xff;
3543 if (interpret
== 1 && p0
== '?')
3547 if (in_pos
== in_len
) break;
3549 uint p1
= in_buf
[in_pos
] & 0xff;
3553 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3555 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3557 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3559 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3561 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3563 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3565 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3566 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3568 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3569 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3571 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3572 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3574 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3575 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3577 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3579 default: log_error ("Syntax error: %s", in_buf
);
3585 if (data
.hex_charset
)
3589 if (in_pos
== in_len
)
3591 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3596 uint p1
= in_buf
[in_pos
] & 0xff;
3598 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3600 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3607 chr
= hex_convert (p1
) << 0;
3608 chr
|= hex_convert (p0
) << 4;
3610 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3616 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3622 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3626 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3628 sum
*= css
[css_pos
].cs_len
;
3634 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3636 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3641 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3643 char p0
= mask_buf
[mask_pos
];
3649 if (mask_pos
== mask_len
) break;
3651 char p1
= mask_buf
[mask_pos
];
3657 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3659 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3661 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3663 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3665 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3667 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3669 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3670 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3672 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3673 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3675 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3676 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3678 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3679 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3681 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3683 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3689 if (data
.hex_charset
)
3693 // if there is no 2nd hex character, show an error:
3695 if (mask_pos
== mask_len
)
3697 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3702 char p1
= mask_buf
[mask_pos
];
3704 // if they are not valid hex character, show an error:
3706 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3708 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3715 chr
|= hex_convert (p1
) << 0;
3716 chr
|= hex_convert (p0
) << 4;
3718 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3724 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3731 log_error ("ERROR: invalid mask length (0)");
3741 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3743 for (int i
= 0; i
< css_cnt
; i
++)
3745 uint len
= css
[i
].cs_len
;
3746 u64 next
= val
/ len
;
3747 uint pos
= val
% len
;
3748 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3753 void mp_cut_at (char *mask
, uint max
)
3757 uint mask_len
= strlen (mask
);
3759 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3761 if (mask
[i
] == '?') i
++;
3767 void mp_setup_sys (cs_t
*mp_sys
)
3771 uint donec
[CHARSIZ
] = { 0 };
3773 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3774 mp_sys
[0].cs_buf
[pos
++] = chr
;
3775 mp_sys
[0].cs_len
= pos
; }
3777 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3778 mp_sys
[1].cs_buf
[pos
++] = chr
;
3779 mp_sys
[1].cs_len
= pos
; }
3781 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3782 mp_sys
[2].cs_buf
[pos
++] = chr
;
3783 mp_sys
[2].cs_len
= pos
; }
3785 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3786 mp_sys
[3].cs_buf
[pos
++] = chr
;
3787 mp_sys
[3].cs_len
= pos
; }
3789 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3790 mp_sys
[4].cs_len
= pos
; }
3792 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3793 mp_sys
[5].cs_len
= pos
; }
3796 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3798 FILE *fp
= fopen (buf
, "rb");
3800 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3802 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3806 char mp_file
[1024] = { 0 };
3808 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3812 len
= in_superchop (mp_file
);
3816 log_info ("WARNING: charset file corrupted");
3818 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3822 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3827 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3829 mp_usr
[index
].cs_len
= 0;
3831 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3834 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3836 char *new_mask_buf
= (char *) mymalloc (256);
3842 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3844 if (css_pos
== len
) break;
3846 char p0
= mask_buf
[mask_pos
];
3848 new_mask_buf
[mask_pos
] = p0
;
3854 if (mask_pos
== mask_len
) break;
3856 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3860 if (data
.hex_charset
)
3864 if (mask_pos
== mask_len
)
3866 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3871 char p1
= mask_buf
[mask_pos
];
3873 // if they are not valid hex character, show an error:
3875 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3877 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3882 new_mask_buf
[mask_pos
] = p1
;
3887 if (css_pos
== len
) return (new_mask_buf
);
3889 myfree (new_mask_buf
);
3898 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3904 for (i
= start
; i
< stop
; i
++)
3906 sum
*= root_css_buf
[i
].cs_len
;
3912 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3916 cs_t
*cs
= &root_css_buf
[start
];
3920 for (i
= start
; i
< stop
; i
++)
3922 const u64 m
= v
% cs
->cs_len
;
3923 const u64 d
= v
/ cs
->cs_len
;
3927 const uint k
= cs
->cs_buf
[m
];
3929 pw_buf
[i
- start
] = (char) k
;
3931 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3935 int sp_comp_val (const void *p1
, const void *p2
)
3937 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3938 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3940 return b2
->val
- b1
->val
;
3943 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
)
3950 * Initialize hcstats
3953 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3955 u64
*root_stats_ptr
= root_stats_buf
;
3957 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3959 for (i
= 0; i
< SP_PW_MAX
; i
++)
3961 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3963 root_stats_ptr
+= CHARSIZ
;
3966 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3968 u64
*markov_stats_ptr
= markov_stats_buf
;
3970 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3972 for (i
= 0; i
< SP_PW_MAX
; i
++)
3974 for (j
= 0; j
< CHARSIZ
; j
++)
3976 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3978 markov_stats_ptr
+= CHARSIZ
;
3988 char hcstat_tmp
[256] = { 0 };
3990 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3992 hcstat
= hcstat_tmp
;
3995 FILE *fd
= fopen (hcstat
, "rb");
3999 log_error ("%s: %s", hcstat
, strerror (errno
));
4004 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
4006 log_error ("%s: Could not load data", hcstat
);
4013 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
4015 log_error ("%s: Could not load data", hcstat
);
4025 * Markov modifier of hcstat_table on user request
4030 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
4031 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
4036 /* Add all stats to first position */
4038 for (i
= 1; i
< SP_PW_MAX
; i
++)
4040 u64
*out
= root_stats_buf_by_pos
[0];
4041 u64
*in
= root_stats_buf_by_pos
[i
];
4043 for (j
= 0; j
< CHARSIZ
; j
++)
4049 for (i
= 1; i
< SP_PW_MAX
; i
++)
4051 u64
*out
= markov_stats_buf_by_key
[0][0];
4052 u64
*in
= markov_stats_buf_by_key
[i
][0];
4054 for (j
= 0; j
< CHARSIZ
; j
++)
4056 for (k
= 0; k
< CHARSIZ
; k
++)
4063 /* copy them to all pw_positions */
4065 for (i
= 1; i
< SP_PW_MAX
; i
++)
4067 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
4070 for (i
= 1; i
< SP_PW_MAX
; i
++)
4072 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
4080 hcstat_table_t
*root_table_ptr
= root_table_buf
;
4082 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
4084 for (i
= 0; i
< SP_PW_MAX
; i
++)
4086 root_table_buf_by_pos
[i
] = root_table_ptr
;
4088 root_table_ptr
+= CHARSIZ
;
4091 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
4093 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4095 for (i
= 0; i
< SP_PW_MAX
; i
++)
4097 for (j
= 0; j
< CHARSIZ
; j
++)
4099 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
4101 markov_table_ptr
+= CHARSIZ
;
4106 * Convert hcstat to tables
4109 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
4111 uint key
= i
% CHARSIZ
;
4113 root_table_buf
[i
].key
= key
;
4114 root_table_buf
[i
].val
= root_stats_buf
[i
];
4117 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
4119 uint key
= i
% CHARSIZ
;
4121 markov_table_buf
[i
].key
= key
;
4122 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
4125 myfree (root_stats_buf
);
4126 myfree (markov_stats_buf
);
4132 for (i
= 0; i
< SP_PW_MAX
; i
++)
4134 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4137 for (i
= 0; i
< SP_PW_MAX
; i
++)
4139 for (j
= 0; j
< CHARSIZ
; j
++)
4141 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4146 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
])
4149 * Convert tables to css
4152 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
4154 uint pw_pos
= i
/ CHARSIZ
;
4156 cs_t
*cs
= &root_css_buf
[pw_pos
];
4158 if (cs
->cs_len
== threshold
) continue;
4160 uint key
= root_table_buf
[i
].key
;
4162 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
4164 cs
->cs_buf
[cs
->cs_len
] = key
;
4170 * Convert table to css
4173 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4175 uint c
= i
/ CHARSIZ
;
4177 cs_t
*cs
= &markov_css_buf
[c
];
4179 if (cs
->cs_len
== threshold
) continue;
4181 uint pw_pos
= c
/ CHARSIZ
;
4183 uint key
= markov_table_buf
[i
].key
;
4185 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4187 cs
->cs_buf
[cs
->cs_len
] = key
;
4193 for (uint i = 0; i < 8; i++)
4195 for (uint j = 0x20; j < 0x80; j++)
4197 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4199 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4201 for (uint k = 0; k < 10; k++)
4203 printf (" %u\n", ptr->cs_buf[k]);
4210 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4212 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4214 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4224 for (uint j
= 1; j
< CHARSIZ
; j
++)
4234 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4236 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4238 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4240 out
+= CHARSIZ
* CHARSIZ
;
4241 in
+= CHARSIZ
* CHARSIZ
;
4243 for (uint j
= 0; j
< CHARSIZ
; j
++)
4250 for (uint k
= 1; k
< CHARSIZ
; k
++)
4262 * mixed shared functions
4265 void dump_hex (const u8
*s
, const int sz
)
4267 for (int i
= 0; i
< sz
; i
++)
4269 log_info_nn ("%02x ", s
[i
]);
4275 void usage_mini_print (const char *progname
)
4277 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4280 void usage_big_print (const char *progname
)
4282 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4285 char *get_exec_path ()
4287 int exec_path_len
= 1024;
4289 char *exec_path
= (char *) mymalloc (exec_path_len
);
4293 char tmp
[32] = { 0 };
4295 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4297 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4301 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4305 uint size
= exec_path_len
;
4307 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4309 log_error("! executable path buffer too small\n");
4314 const int len
= strlen (exec_path
);
4317 #error Your Operating System is not supported or detected
4325 char *get_install_dir (const char *progname
)
4327 char *install_dir
= mystrdup (progname
);
4328 char *last_slash
= NULL
;
4330 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4334 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4340 install_dir
[0] = '.';
4344 return (install_dir
);
4347 char *get_profile_dir (const char *homedir
)
4349 #define DOT_HASHCAT ".hashcat"
4351 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4353 char *profile_dir
= (char *) mymalloc (len
+ 1);
4355 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4360 char *get_session_dir (const char *profile_dir
)
4362 #define SESSIONS_FOLDER "sessions"
4364 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4366 char *session_dir
= (char *) mymalloc (len
+ 1);
4368 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4373 uint
count_lines (FILE *fd
)
4377 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4383 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4385 if (nread
< 1) continue;
4389 for (i
= 0; i
< nread
; i
++)
4391 if (prev
== '\n') cnt
++;
4402 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4406 FILE *fd
= fopen (filename
, "rb");
4410 log_error ("%s: %s", filename
, strerror (errno
));
4415 #define MAX_KEY_SIZE (1024 * 1024)
4417 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4419 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4425 for (int fpos
= 0; fpos
< nread
; fpos
++)
4427 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4429 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4430 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4431 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4432 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4434 if (kpos
>= 64) kpos
= 0;
4441 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4445 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4446 if (CPU_ISSET(core
, cpu_set
)) break;
4448 thread_affinity_policy_data_t policy
= { core
};
4450 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4452 if (data
.quiet
== 0)
4454 if (rc
!= KERN_SUCCESS
)
4456 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4464 void set_cpu_affinity (char *cpu_affinity
)
4467 DWORD_PTR aff_mask
= 0;
4475 char *devices
= strdup (cpu_affinity
);
4477 char *next
= strtok (devices
, ",");
4481 uint cpu_id
= atoi (next
);
4496 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4502 aff_mask
|= 1 << (cpu_id
- 1);
4504 CPU_SET ((cpu_id
- 1), &cpuset
);
4507 } while ((next
= strtok (NULL
, ",")) != NULL
);
4513 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4514 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4516 pthread_t thread
= pthread_self ();
4517 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4521 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4523 char *element
, *end
;
4525 end
= (char *) base
+ nmemb
* size
;
4527 for (element
= (char *) base
; element
< end
; element
+= size
)
4528 if (!compar (element
, key
))
4534 int sort_by_u32 (const void *v1
, const void *v2
)
4536 const u32
*s1
= (const u32
*) v1
;
4537 const u32
*s2
= (const u32
*) v2
;
4542 int sort_by_salt (const void *v1
, const void *v2
)
4544 const salt_t
*s1
= (const salt_t
*) v1
;
4545 const salt_t
*s2
= (const salt_t
*) v2
;
4547 const int res1
= s1
->salt_len
- s2
->salt_len
;
4549 if (res1
!= 0) return (res1
);
4551 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4553 if (res2
!= 0) return (res2
);
4561 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4562 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4569 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4570 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4576 int sort_by_salt_buf (const void *v1
, const void *v2
)
4578 const pot_t
*p1
= (const pot_t
*) v1
;
4579 const pot_t
*p2
= (const pot_t
*) v2
;
4581 const hash_t
*h1
= &p1
->hash
;
4582 const hash_t
*h2
= &p2
->hash
;
4584 const salt_t
*s1
= h1
->salt
;
4585 const salt_t
*s2
= h2
->salt
;
4591 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4592 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4598 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4600 const hash_t
*h1
= (const hash_t
*) v1
;
4601 const hash_t
*h2
= (const hash_t
*) v2
;
4603 const salt_t
*s1
= h1
->salt
;
4604 const salt_t
*s2
= h2
->salt
;
4606 // testphase: this should work
4611 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4612 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4615 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4616 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4617 if (s1->salt_len > s2->salt_len) return ( 1);
4618 if (s1->salt_len < s2->salt_len) return (-1);
4620 uint n = s1->salt_len;
4624 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4625 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4632 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4634 const hash_t
*h1
= (const hash_t
*) v1
;
4635 const hash_t
*h2
= (const hash_t
*) v2
;
4637 const salt_t
*s1
= h1
->salt
;
4638 const salt_t
*s2
= h2
->salt
;
4640 // 16 - 2 (since last 2 uints contain the digest)
4645 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4646 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4652 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4654 const hash_t
*h1
= (const hash_t
*) v1
;
4655 const hash_t
*h2
= (const hash_t
*) v2
;
4657 const void *d1
= h1
->digest
;
4658 const void *d2
= h2
->digest
;
4660 return data
.sort_by_digest (d1
, d2
);
4663 int sort_by_hash (const void *v1
, const void *v2
)
4665 const hash_t
*h1
= (const hash_t
*) v1
;
4666 const hash_t
*h2
= (const hash_t
*) v2
;
4670 const salt_t
*s1
= h1
->salt
;
4671 const salt_t
*s2
= h2
->salt
;
4673 int res
= sort_by_salt (s1
, s2
);
4675 if (res
!= 0) return (res
);
4678 const void *d1
= h1
->digest
;
4679 const void *d2
= h2
->digest
;
4681 return data
.sort_by_digest (d1
, d2
);
4684 int sort_by_pot (const void *v1
, const void *v2
)
4686 const pot_t
*p1
= (const pot_t
*) v1
;
4687 const pot_t
*p2
= (const pot_t
*) v2
;
4689 const hash_t
*h1
= &p1
->hash
;
4690 const hash_t
*h2
= &p2
->hash
;
4692 return sort_by_hash (h1
, h2
);
4695 int sort_by_mtime (const void *p1
, const void *p2
)
4697 const char **f1
= (const char **) p1
;
4698 const char **f2
= (const char **) p2
;
4700 struct stat s1
; stat (*f1
, &s1
);
4701 struct stat s2
; stat (*f2
, &s2
);
4703 return s2
.st_mtime
- s1
.st_mtime
;
4706 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4708 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4709 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4711 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4714 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4716 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4717 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4719 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4722 int sort_by_stringptr (const void *p1
, const void *p2
)
4724 const char **s1
= (const char **) p1
;
4725 const char **s2
= (const char **) p2
;
4727 return strcmp (*s1
, *s2
);
4730 int sort_by_dictstat (const void *s1
, const void *s2
)
4732 dictstat_t
*d1
= (dictstat_t
*) s1
;
4733 dictstat_t
*d2
= (dictstat_t
*) s2
;
4736 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4738 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4741 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4744 int sort_by_bitmap (const void *p1
, const void *p2
)
4746 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4747 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4749 return b1
->collisions
- b2
->collisions
;
4752 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4754 const u32
*d1
= (const u32
*) v1
;
4755 const u32
*d2
= (const u32
*) v2
;
4761 if (d1
[n
] > d2
[n
]) return ( 1);
4762 if (d1
[n
] < d2
[n
]) return (-1);
4768 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4770 const u32
*d1
= (const u32
*) v1
;
4771 const u32
*d2
= (const u32
*) v2
;
4777 if (d1
[n
] > d2
[n
]) return ( 1);
4778 if (d1
[n
] < d2
[n
]) return (-1);
4784 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4786 const u32
*d1
= (const u32
*) v1
;
4787 const u32
*d2
= (const u32
*) v2
;
4793 if (d1
[n
] > d2
[n
]) return ( 1);
4794 if (d1
[n
] < d2
[n
]) return (-1);
4800 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4802 const u32
*d1
= (const u32
*) v1
;
4803 const u32
*d2
= (const u32
*) v2
;
4809 if (d1
[n
] > d2
[n
]) return ( 1);
4810 if (d1
[n
] < d2
[n
]) return (-1);
4816 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4818 const u32
*d1
= (const u32
*) v1
;
4819 const u32
*d2
= (const u32
*) v2
;
4825 if (d1
[n
] > d2
[n
]) return ( 1);
4826 if (d1
[n
] < d2
[n
]) return (-1);
4832 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4834 const u32
*d1
= (const u32
*) v1
;
4835 const u32
*d2
= (const u32
*) v2
;
4841 if (d1
[n
] > d2
[n
]) return ( 1);
4842 if (d1
[n
] < d2
[n
]) return (-1);
4848 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4850 const u32
*d1
= (const u32
*) v1
;
4851 const u32
*d2
= (const u32
*) v2
;
4857 if (d1
[n
] > d2
[n
]) return ( 1);
4858 if (d1
[n
] < d2
[n
]) return (-1);
4864 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4866 const u32
*d1
= (const u32
*) v1
;
4867 const u32
*d2
= (const u32
*) v2
;
4873 if (d1
[n
] > d2
[n
]) return ( 1);
4874 if (d1
[n
] < d2
[n
]) return (-1);
4880 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4882 const u64
*d1
= (const u64
*) v1
;
4883 const u64
*d2
= (const u64
*) v2
;
4889 if (d1
[n
] > d2
[n
]) return ( 1);
4890 if (d1
[n
] < d2
[n
]) return (-1);
4896 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4898 const u64
*d1
= (const u64
*) v1
;
4899 const u64
*d2
= (const u64
*) v2
;
4905 if (d1
[n
] > d2
[n
]) return ( 1);
4906 if (d1
[n
] < d2
[n
]) return (-1);
4912 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4914 const u64
*d1
= (const u64
*) v1
;
4915 const u64
*d2
= (const u64
*) v2
;
4921 if (d1
[n
] > d2
[n
]) return ( 1);
4922 if (d1
[n
] < d2
[n
]) return (-1);
4928 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4930 const u32
*d1
= (const u32
*) v1
;
4931 const u32
*d2
= (const u32
*) v2
;
4933 const uint dgst_pos0
= data
.dgst_pos0
;
4934 const uint dgst_pos1
= data
.dgst_pos1
;
4935 const uint dgst_pos2
= data
.dgst_pos2
;
4936 const uint dgst_pos3
= data
.dgst_pos3
;
4938 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4939 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4940 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4941 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4942 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4943 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4944 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4945 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4950 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4952 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4953 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4955 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4957 if (res1
!= 0) return (res1
);
4962 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4964 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4965 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4967 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4969 if (res1
!= 0) return (res1
);
4971 const int res2
= t1
->attack_mode
4974 if (res2
!= 0) return (res2
);
4976 const int res3
= t1
->hash_type
4979 if (res3
!= 0) return (res3
);
4984 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
)
4986 uint outfile_autohex
= data
.outfile_autohex
;
4988 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4990 FILE *debug_fp
= NULL
;
4992 if (debug_file
!= NULL
)
4994 debug_fp
= fopen (debug_file
, "ab");
4996 lock_file (debug_fp
);
5003 if (debug_fp
== NULL
)
5005 log_info ("WARNING: Could not open debug-file for writing");
5009 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
5011 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
5013 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
5016 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
5018 if (debug_mode
== 4)
5020 fputc (':', debug_fp
);
5022 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
5025 fputc ('\n', debug_fp
);
5027 if (debug_file
!= NULL
) fclose (debug_fp
);
5031 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
5033 int needs_hexify
= 0;
5035 if (outfile_autohex
== 1)
5037 for (uint i
= 0; i
< plain_len
; i
++)
5039 if (plain_ptr
[i
] < 0x20)
5046 if (plain_ptr
[i
] > 0x7f)
5055 if (needs_hexify
== 1)
5057 fprintf (fp
, "$HEX[");
5059 for (uint i
= 0; i
< plain_len
; i
++)
5061 fprintf (fp
, "%02x", plain_ptr
[i
]);
5068 fwrite (plain_ptr
, plain_len
, 1, fp
);
5072 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
)
5074 uint outfile_format
= data
.outfile_format
;
5076 char separator
= data
.separator
;
5078 if (outfile_format
& OUTFILE_FMT_HASH
)
5080 fprintf (out_fp
, "%s", out_buf
);
5082 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5084 fputc (separator
, out_fp
);
5087 else if (data
.username
)
5089 if (username
!= NULL
)
5091 for (uint i
= 0; i
< user_len
; i
++)
5093 fprintf (out_fp
, "%c", username
[i
]);
5096 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5098 fputc (separator
, out_fp
);
5103 if (outfile_format
& OUTFILE_FMT_PLAIN
)
5105 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
5107 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5109 fputc (separator
, out_fp
);
5113 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
5115 for (uint i
= 0; i
< plain_len
; i
++)
5117 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
5120 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
5122 fputc (separator
, out_fp
);
5126 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
5129 __mingw_fprintf (out_fp
, "%llu", crackpos
);
5134 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
5136 fprintf (out_fp
, "%llu", crackpos
);
5141 fputc ('\n', out_fp
);
5144 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
)
5148 pot_key
.hash
.salt
= hashes_buf
->salt
;
5149 pot_key
.hash
.digest
= hashes_buf
->digest
;
5151 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5157 input_buf
[input_len
] = 0;
5160 unsigned char *username
= NULL
;
5165 user_t
*user
= hashes_buf
->hash_info
->user
;
5169 username
= (unsigned char *) (user
->user_name
);
5171 user_len
= user
->user_len
;
5175 // do output the line
5176 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5180 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5181 #define LM_MASKED_PLAIN "[notfound]"
5183 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
)
5189 pot_left_key
.hash
.salt
= hash_left
->salt
;
5190 pot_left_key
.hash
.digest
= hash_left
->digest
;
5192 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5196 uint weak_hash_found
= 0;
5198 pot_t pot_right_key
;
5200 pot_right_key
.hash
.salt
= hash_right
->salt
;
5201 pot_right_key
.hash
.digest
= hash_right
->digest
;
5203 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5205 if (pot_right_ptr
== NULL
)
5207 // special case, if "weak hash"
5209 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5211 weak_hash_found
= 1;
5213 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5215 // in theory this is not needed, but we are paranoia:
5217 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5218 pot_right_ptr
->plain_len
= 0;
5222 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5224 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
5229 // at least one half was found:
5233 input_buf
[input_len
] = 0;
5237 unsigned char *username
= NULL
;
5242 user_t
*user
= hash_left
->hash_info
->user
;
5246 username
= (unsigned char *) (user
->user_name
);
5248 user_len
= user
->user_len
;
5252 // mask the part which was not found
5254 uint left_part_masked
= 0;
5255 uint right_part_masked
= 0;
5257 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5259 if (pot_left_ptr
== NULL
)
5261 left_part_masked
= 1;
5263 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5265 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5267 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5268 pot_left_ptr
->plain_len
= mask_plain_len
;
5271 if (pot_right_ptr
== NULL
)
5273 right_part_masked
= 1;
5275 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5277 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5279 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5280 pot_right_ptr
->plain_len
= mask_plain_len
;
5283 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5287 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5289 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5291 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5293 // do output the line
5295 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5297 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5299 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5300 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5303 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
)
5307 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5309 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5311 if (pot_ptr
== NULL
)
5315 input_buf
[input_len
] = 0;
5317 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5321 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
)
5327 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5329 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5333 pot_t pot_right_key
;
5335 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5337 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5339 uint weak_hash_found
= 0;
5341 if (pot_right_ptr
== NULL
)
5343 // special case, if "weak hash"
5345 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5347 weak_hash_found
= 1;
5349 // we just need that pot_right_ptr is not a NULL pointer
5351 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5355 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5357 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5362 // ... at least one part was not cracked
5366 input_buf
[input_len
] = 0;
5368 // only show the hash part which is still not cracked
5370 uint user_len
= input_len
- 32;
5372 char *hash_output
= (char *) mymalloc (33);
5374 memcpy (hash_output
, input_buf
, input_len
);
5376 if (pot_left_ptr
!= NULL
)
5378 // only show right part (because left part was already found)
5380 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5382 hash_output
[user_len
+ 16] = 0;
5385 if (pot_right_ptr
!= NULL
)
5387 // only show left part (because right part was already found)
5389 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5391 hash_output
[user_len
+ 16] = 0;
5394 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5396 myfree (hash_output
);
5398 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5401 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5403 uint opencl_platforms_filter
= 0;
5405 if (opencl_platforms
)
5407 char *platforms
= strdup (opencl_platforms
);
5409 char *next
= strtok (platforms
, ",");
5413 int platform
= atoi (next
);
5415 if (platform
< 1 || platform
> 32)
5417 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5422 opencl_platforms_filter
|= 1 << (platform
- 1);
5424 } while ((next
= strtok (NULL
, ",")) != NULL
);
5430 opencl_platforms_filter
= -1;
5433 return opencl_platforms_filter
;
5436 u32
setup_devices_filter (char *opencl_devices
)
5438 u32 devices_filter
= 0;
5442 char *devices
= strdup (opencl_devices
);
5444 char *next
= strtok (devices
, ",");
5448 int device_id
= atoi (next
);
5450 if (device_id
< 1 || device_id
> 32)
5452 log_error ("ERROR: invalid device_id %u specified", device_id
);
5457 devices_filter
|= 1 << (device_id
- 1);
5459 } while ((next
= strtok (NULL
, ",")) != NULL
);
5465 devices_filter
= -1;
5468 return devices_filter
;
5471 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5473 cl_device_type device_types_filter
= 0;
5475 if (opencl_device_types
)
5477 char *device_types
= strdup (opencl_device_types
);
5479 char *next
= strtok (device_types
, ",");
5483 int device_type
= atoi (next
);
5485 if (device_type
< 1 || device_type
> 3)
5487 log_error ("ERROR: invalid device_type %u specified", device_type
);
5492 device_types_filter
|= 1 << device_type
;
5494 } while ((next
= strtok (NULL
, ",")) != NULL
);
5496 free (device_types
);
5500 // Do not use CPU by default, this often reduces GPU performance because
5501 // the CPU is too busy to handle GPU synchronization
5503 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5506 return device_types_filter
;
5509 u32
get_random_num (const u32 min
, const u32 max
)
5511 if (min
== max
) return (min
);
5513 return ((rand () % (max
- min
)) + min
);
5516 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5518 u32 quotient
= dividend
/ divisor
;
5520 if (dividend
% divisor
) quotient
++;
5525 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5527 u64 quotient
= dividend
/ divisor
;
5529 if (dividend
% divisor
) quotient
++;
5534 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5536 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5537 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5539 if (tm
->tm_year
- 70)
5541 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5542 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5544 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5546 else if (tm
->tm_yday
)
5548 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5549 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5551 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5553 else if (tm
->tm_hour
)
5555 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5556 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5558 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5560 else if (tm
->tm_min
)
5562 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5563 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5565 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5569 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5571 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5575 void format_speed_display (float val
, char *buf
, size_t len
)
5586 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5597 /* generate output */
5601 snprintf (buf
, len
- 1, "%.0f ", val
);
5605 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5609 void lowercase (u8
*buf
, int len
)
5611 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5614 void uppercase (u8
*buf
, int len
)
5616 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5619 int fgetl (FILE *fp
, char *line_buf
)
5625 const int c
= fgetc (fp
);
5627 if (c
== EOF
) break;
5629 line_buf
[line_len
] = (char) c
;
5633 if (line_len
== HCBUFSIZ
) line_len
--;
5635 if (c
== '\n') break;
5638 if (line_len
== 0) return 0;
5640 if (line_buf
[line_len
- 1] == '\n')
5644 line_buf
[line_len
] = 0;
5647 if (line_len
== 0) return 0;
5649 if (line_buf
[line_len
- 1] == '\r')
5653 line_buf
[line_len
] = 0;
5659 int in_superchop (char *buf
)
5661 int len
= strlen (buf
);
5665 if (buf
[len
- 1] == '\n')
5672 if (buf
[len
- 1] == '\r')
5687 char **scan_directory (const char *path
)
5689 char *tmp_path
= mystrdup (path
);
5691 size_t tmp_path_len
= strlen (tmp_path
);
5693 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5695 tmp_path
[tmp_path_len
- 1] = 0;
5697 tmp_path_len
= strlen (tmp_path
);
5700 char **files
= NULL
;
5706 if ((d
= opendir (tmp_path
)) != NULL
)
5712 memset (&e
, 0, sizeof (e
));
5713 struct dirent
*de
= NULL
;
5715 if (readdir_r (d
, &e
, &de
) != 0)
5717 log_error ("ERROR: readdir_r() failed");
5722 if (de
== NULL
) break;
5726 while ((de
= readdir (d
)) != NULL
)
5729 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5731 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5733 char *path_file
= (char *) mymalloc (path_size
+ 1);
5735 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5737 path_file
[path_size
] = 0;
5741 if ((d_test
= opendir (path_file
)) != NULL
)
5749 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5753 files
[num_files
- 1] = path_file
;
5759 else if (errno
== ENOTDIR
)
5761 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5765 files
[num_files
- 1] = mystrdup (path
);
5768 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5772 files
[num_files
- 1] = NULL
;
5779 int count_dictionaries (char **dictionary_files
)
5781 if (dictionary_files
== NULL
) return 0;
5785 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5793 char *stroptitype (const uint opti_type
)
5797 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5798 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5799 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5800 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5801 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5802 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5803 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5804 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5805 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5806 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5807 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5808 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5809 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5810 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5811 case OPTI_TYPE_SLOW_HASH_SIMD
: return ((char *) OPTI_STR_SLOW_HASH_SIMD
); break;
5812 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5813 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5814 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5815 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5821 char *strparser (const uint parser_status
)
5823 switch (parser_status
)
5825 case PARSER_OK
: return ((char *) PA_000
); break;
5826 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5827 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5828 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5829 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5830 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5831 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5832 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5833 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5834 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5835 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5836 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5837 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5838 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5839 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5840 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5841 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5844 return ((char *) PA_255
);
5847 char *strhashtype (const uint hash_mode
)
5851 case 0: return ((char *) HT_00000
); break;
5852 case 10: return ((char *) HT_00010
); break;
5853 case 11: return ((char *) HT_00011
); break;
5854 case 12: return ((char *) HT_00012
); break;
5855 case 20: return ((char *) HT_00020
); break;
5856 case 21: return ((char *) HT_00021
); break;
5857 case 22: return ((char *) HT_00022
); break;
5858 case 23: return ((char *) HT_00023
); break;
5859 case 30: return ((char *) HT_00030
); break;
5860 case 40: return ((char *) HT_00040
); break;
5861 case 50: return ((char *) HT_00050
); break;
5862 case 60: return ((char *) HT_00060
); break;
5863 case 100: return ((char *) HT_00100
); break;
5864 case 101: return ((char *) HT_00101
); break;
5865 case 110: return ((char *) HT_00110
); break;
5866 case 111: return ((char *) HT_00111
); break;
5867 case 112: return ((char *) HT_00112
); break;
5868 case 120: return ((char *) HT_00120
); break;
5869 case 121: return ((char *) HT_00121
); break;
5870 case 122: return ((char *) HT_00122
); break;
5871 case 124: return ((char *) HT_00124
); break;
5872 case 125: return ((char *) HT_00125
); break;
5873 case 130: return ((char *) HT_00130
); break;
5874 case 131: return ((char *) HT_00131
); break;
5875 case 132: return ((char *) HT_00132
); break;
5876 case 133: return ((char *) HT_00133
); break;
5877 case 140: return ((char *) HT_00140
); break;
5878 case 141: return ((char *) HT_00141
); break;
5879 case 150: return ((char *) HT_00150
); break;
5880 case 160: return ((char *) HT_00160
); break;
5881 case 190: return ((char *) HT_00190
); break;
5882 case 200: return ((char *) HT_00200
); break;
5883 case 300: return ((char *) HT_00300
); break;
5884 case 400: return ((char *) HT_00400
); break;
5885 case 500: return ((char *) HT_00500
); break;
5886 case 501: return ((char *) HT_00501
); break;
5887 case 900: return ((char *) HT_00900
); break;
5888 case 910: return ((char *) HT_00910
); break;
5889 case 1000: return ((char *) HT_01000
); break;
5890 case 1100: return ((char *) HT_01100
); break;
5891 case 1400: return ((char *) HT_01400
); break;
5892 case 1410: return ((char *) HT_01410
); break;
5893 case 1420: return ((char *) HT_01420
); break;
5894 case 1421: return ((char *) HT_01421
); break;
5895 case 1430: return ((char *) HT_01430
); break;
5896 case 1440: return ((char *) HT_01440
); break;
5897 case 1441: return ((char *) HT_01441
); break;
5898 case 1450: return ((char *) HT_01450
); break;
5899 case 1460: return ((char *) HT_01460
); break;
5900 case 1500: return ((char *) HT_01500
); break;
5901 case 1600: return ((char *) HT_01600
); break;
5902 case 1700: return ((char *) HT_01700
); break;
5903 case 1710: return ((char *) HT_01710
); break;
5904 case 1711: return ((char *) HT_01711
); break;
5905 case 1720: return ((char *) HT_01720
); break;
5906 case 1722: return ((char *) HT_01722
); break;
5907 case 1730: return ((char *) HT_01730
); break;
5908 case 1731: return ((char *) HT_01731
); break;
5909 case 1740: return ((char *) HT_01740
); break;
5910 case 1750: return ((char *) HT_01750
); break;
5911 case 1760: return ((char *) HT_01760
); break;
5912 case 1800: return ((char *) HT_01800
); break;
5913 case 2100: return ((char *) HT_02100
); break;
5914 case 2400: return ((char *) HT_02400
); break;
5915 case 2410: return ((char *) HT_02410
); break;
5916 case 2500: return ((char *) HT_02500
); break;
5917 case 2600: return ((char *) HT_02600
); break;
5918 case 2611: return ((char *) HT_02611
); break;
5919 case 2612: return ((char *) HT_02612
); break;
5920 case 2711: return ((char *) HT_02711
); break;
5921 case 2811: return ((char *) HT_02811
); break;
5922 case 3000: return ((char *) HT_03000
); break;
5923 case 3100: return ((char *) HT_03100
); break;
5924 case 3200: return ((char *) HT_03200
); break;
5925 case 3710: return ((char *) HT_03710
); break;
5926 case 3711: return ((char *) HT_03711
); break;
5927 case 3800: return ((char *) HT_03800
); break;
5928 case 4300: return ((char *) HT_04300
); break;
5929 case 4400: return ((char *) HT_04400
); break;
5930 case 4500: return ((char *) HT_04500
); break;
5931 case 4700: return ((char *) HT_04700
); break;
5932 case 4800: return ((char *) HT_04800
); break;
5933 case 4900: return ((char *) HT_04900
); break;
5934 case 5000: return ((char *) HT_05000
); break;
5935 case 5100: return ((char *) HT_05100
); break;
5936 case 5200: return ((char *) HT_05200
); break;
5937 case 5300: return ((char *) HT_05300
); break;
5938 case 5400: return ((char *) HT_05400
); break;
5939 case 5500: return ((char *) HT_05500
); break;
5940 case 5600: return ((char *) HT_05600
); break;
5941 case 5700: return ((char *) HT_05700
); break;
5942 case 5800: return ((char *) HT_05800
); break;
5943 case 6000: return ((char *) HT_06000
); break;
5944 case 6100: return ((char *) HT_06100
); break;
5945 case 6211: return ((char *) HT_06211
); break;
5946 case 6212: return ((char *) HT_06212
); break;
5947 case 6213: return ((char *) HT_06213
); break;
5948 case 6221: return ((char *) HT_06221
); break;
5949 case 6222: return ((char *) HT_06222
); break;
5950 case 6223: return ((char *) HT_06223
); break;
5951 case 6231: return ((char *) HT_06231
); break;
5952 case 6232: return ((char *) HT_06232
); break;
5953 case 6233: return ((char *) HT_06233
); break;
5954 case 6241: return ((char *) HT_06241
); break;
5955 case 6242: return ((char *) HT_06242
); break;
5956 case 6243: return ((char *) HT_06243
); break;
5957 case 6300: return ((char *) HT_06300
); break;
5958 case 6400: return ((char *) HT_06400
); break;
5959 case 6500: return ((char *) HT_06500
); break;
5960 case 6600: return ((char *) HT_06600
); break;
5961 case 6700: return ((char *) HT_06700
); break;
5962 case 6800: return ((char *) HT_06800
); break;
5963 case 6900: return ((char *) HT_06900
); break;
5964 case 7100: return ((char *) HT_07100
); break;
5965 case 7200: return ((char *) HT_07200
); break;
5966 case 7300: return ((char *) HT_07300
); break;
5967 case 7400: return ((char *) HT_07400
); break;
5968 case 7500: return ((char *) HT_07500
); break;
5969 case 7600: return ((char *) HT_07600
); break;
5970 case 7700: return ((char *) HT_07700
); break;
5971 case 7800: return ((char *) HT_07800
); break;
5972 case 7900: return ((char *) HT_07900
); break;
5973 case 8000: return ((char *) HT_08000
); break;
5974 case 8100: return ((char *) HT_08100
); break;
5975 case 8200: return ((char *) HT_08200
); break;
5976 case 8300: return ((char *) HT_08300
); break;
5977 case 8400: return ((char *) HT_08400
); break;
5978 case 8500: return ((char *) HT_08500
); break;
5979 case 8600: return ((char *) HT_08600
); break;
5980 case 8700: return ((char *) HT_08700
); break;
5981 case 8800: return ((char *) HT_08800
); break;
5982 case 8900: return ((char *) HT_08900
); break;
5983 case 9000: return ((char *) HT_09000
); break;
5984 case 9100: return ((char *) HT_09100
); break;
5985 case 9200: return ((char *) HT_09200
); break;
5986 case 9300: return ((char *) HT_09300
); break;
5987 case 9400: return ((char *) HT_09400
); break;
5988 case 9500: return ((char *) HT_09500
); break;
5989 case 9600: return ((char *) HT_09600
); break;
5990 case 9700: return ((char *) HT_09700
); break;
5991 case 9710: return ((char *) HT_09710
); break;
5992 case 9720: return ((char *) HT_09720
); break;
5993 case 9800: return ((char *) HT_09800
); break;
5994 case 9810: return ((char *) HT_09810
); break;
5995 case 9820: return ((char *) HT_09820
); break;
5996 case 9900: return ((char *) HT_09900
); break;
5997 case 10000: return ((char *) HT_10000
); break;
5998 case 10100: return ((char *) HT_10100
); break;
5999 case 10200: return ((char *) HT_10200
); break;
6000 case 10300: return ((char *) HT_10300
); break;
6001 case 10400: return ((char *) HT_10400
); break;
6002 case 10410: return ((char *) HT_10410
); break;
6003 case 10420: return ((char *) HT_10420
); break;
6004 case 10500: return ((char *) HT_10500
); break;
6005 case 10600: return ((char *) HT_10600
); break;
6006 case 10700: return ((char *) HT_10700
); break;
6007 case 10800: return ((char *) HT_10800
); break;
6008 case 10900: return ((char *) HT_10900
); break;
6009 case 11000: return ((char *) HT_11000
); break;
6010 case 11100: return ((char *) HT_11100
); break;
6011 case 11200: return ((char *) HT_11200
); break;
6012 case 11300: return ((char *) HT_11300
); break;
6013 case 11400: return ((char *) HT_11400
); break;
6014 case 11500: return ((char *) HT_11500
); break;
6015 case 11600: return ((char *) HT_11600
); break;
6016 case 11700: return ((char *) HT_11700
); break;
6017 case 11800: return ((char *) HT_11800
); break;
6018 case 11900: return ((char *) HT_11900
); break;
6019 case 12000: return ((char *) HT_12000
); break;
6020 case 12100: return ((char *) HT_12100
); break;
6021 case 12200: return ((char *) HT_12200
); break;
6022 case 12300: return ((char *) HT_12300
); break;
6023 case 12400: return ((char *) HT_12400
); break;
6024 case 12500: return ((char *) HT_12500
); break;
6025 case 12600: return ((char *) HT_12600
); break;
6026 case 12700: return ((char *) HT_12700
); break;
6027 case 12800: return ((char *) HT_12800
); break;
6028 case 12900: return ((char *) HT_12900
); break;
6029 case 13000: return ((char *) HT_13000
); break;
6030 case 13100: return ((char *) HT_13100
); break;
6031 case 13200: return ((char *) HT_13200
); break;
6032 case 13300: return ((char *) HT_13300
); break;
6033 case 13400: return ((char *) HT_13400
); break;
6034 case 13500: return ((char *) HT_13500
); break;
6035 case 13600: return ((char *) HT_13600
); break;
6036 case 13711: return ((char *) HT_13711
); break;
6037 case 13712: return ((char *) HT_13712
); break;
6038 case 13713: return ((char *) HT_13713
); break;
6039 case 13721: return ((char *) HT_13721
); break;
6040 case 13722: return ((char *) HT_13722
); break;
6041 case 13723: return ((char *) HT_13723
); break;
6042 case 13731: return ((char *) HT_13731
); break;
6043 case 13732: return ((char *) HT_13732
); break;
6044 case 13733: return ((char *) HT_13733
); break;
6045 case 13741: return ((char *) HT_13741
); break;
6046 case 13742: return ((char *) HT_13742
); break;
6047 case 13743: return ((char *) HT_13743
); break;
6048 case 13751: return ((char *) HT_13751
); break;
6049 case 13752: return ((char *) HT_13752
); break;
6050 case 13753: return ((char *) HT_13753
); break;
6051 case 13761: return ((char *) HT_13761
); break;
6052 case 13762: return ((char *) HT_13762
); break;
6053 case 13763: return ((char *) HT_13763
); break;
6054 case 13800: return ((char *) HT_13800
); break;
6057 return ((char *) "Unknown");
6060 char *strstatus (const uint devices_status
)
6062 switch (devices_status
)
6064 case STATUS_INIT
: return ((char *) ST_0000
); break;
6065 case STATUS_STARTING
: return ((char *) ST_0001
); break;
6066 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
6067 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
6068 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
6069 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
6070 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
6071 case STATUS_QUIT
: return ((char *) ST_0007
); break;
6072 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
6073 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
6074 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
6077 return ((char *) "Unknown");
6080 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
6082 uint hash_type
= data
.hash_type
;
6083 uint hash_mode
= data
.hash_mode
;
6084 uint salt_type
= data
.salt_type
;
6085 uint opts_type
= data
.opts_type
;
6086 uint opti_type
= data
.opti_type
;
6087 uint dgst_size
= data
.dgst_size
;
6089 char *hashfile
= data
.hashfile
;
6093 uint digest_buf
[64] = { 0 };
6095 u64
*digest_buf64
= (u64
*) digest_buf
;
6097 char *digests_buf_ptr
= (char *) data
.digests_buf
;
6099 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
6101 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6107 case HASH_TYPE_DESCRYPT
:
6108 FP (digest_buf
[1], digest_buf
[0], tt
);
6111 case HASH_TYPE_DESRACF
:
6112 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6113 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6115 FP (digest_buf
[1], digest_buf
[0], tt
);
6119 FP (digest_buf
[1], digest_buf
[0], tt
);
6122 case HASH_TYPE_NETNTLM
:
6123 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6124 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6125 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
6126 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
6128 FP (digest_buf
[1], digest_buf
[0], tt
);
6129 FP (digest_buf
[3], digest_buf
[2], tt
);
6132 case HASH_TYPE_BSDICRYPT
:
6133 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
6134 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
6136 FP (digest_buf
[1], digest_buf
[0], tt
);
6141 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
6146 digest_buf
[0] += MD4M_A
;
6147 digest_buf
[1] += MD4M_B
;
6148 digest_buf
[2] += MD4M_C
;
6149 digest_buf
[3] += MD4M_D
;
6153 digest_buf
[0] += MD5M_A
;
6154 digest_buf
[1] += MD5M_B
;
6155 digest_buf
[2] += MD5M_C
;
6156 digest_buf
[3] += MD5M_D
;
6159 case HASH_TYPE_SHA1
:
6160 digest_buf
[0] += SHA1M_A
;
6161 digest_buf
[1] += SHA1M_B
;
6162 digest_buf
[2] += SHA1M_C
;
6163 digest_buf
[3] += SHA1M_D
;
6164 digest_buf
[4] += SHA1M_E
;
6167 case HASH_TYPE_SHA256
:
6168 digest_buf
[0] += SHA256M_A
;
6169 digest_buf
[1] += SHA256M_B
;
6170 digest_buf
[2] += SHA256M_C
;
6171 digest_buf
[3] += SHA256M_D
;
6172 digest_buf
[4] += SHA256M_E
;
6173 digest_buf
[5] += SHA256M_F
;
6174 digest_buf
[6] += SHA256M_G
;
6175 digest_buf
[7] += SHA256M_H
;
6178 case HASH_TYPE_SHA384
:
6179 digest_buf64
[0] += SHA384M_A
;
6180 digest_buf64
[1] += SHA384M_B
;
6181 digest_buf64
[2] += SHA384M_C
;
6182 digest_buf64
[3] += SHA384M_D
;
6183 digest_buf64
[4] += SHA384M_E
;
6184 digest_buf64
[5] += SHA384M_F
;
6185 digest_buf64
[6] += 0;
6186 digest_buf64
[7] += 0;
6189 case HASH_TYPE_SHA512
:
6190 digest_buf64
[0] += SHA512M_A
;
6191 digest_buf64
[1] += SHA512M_B
;
6192 digest_buf64
[2] += SHA512M_C
;
6193 digest_buf64
[3] += SHA512M_D
;
6194 digest_buf64
[4] += SHA512M_E
;
6195 digest_buf64
[5] += SHA512M_F
;
6196 digest_buf64
[6] += SHA512M_G
;
6197 digest_buf64
[7] += SHA512M_H
;
6202 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6204 if (dgst_size
== DGST_SIZE_4_2
)
6206 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6208 else if (dgst_size
== DGST_SIZE_4_4
)
6210 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6212 else if (dgst_size
== DGST_SIZE_4_5
)
6214 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6216 else if (dgst_size
== DGST_SIZE_4_6
)
6218 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6220 else if (dgst_size
== DGST_SIZE_4_8
)
6222 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6224 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6226 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6228 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6230 else if (hash_type
== HASH_TYPE_SHA384
)
6232 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6234 else if (hash_type
== HASH_TYPE_SHA512
)
6236 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6238 else if (hash_type
== HASH_TYPE_GOST
)
6240 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6243 else if (dgst_size
== DGST_SIZE_4_64
)
6245 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6247 else if (dgst_size
== DGST_SIZE_8_25
)
6249 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6253 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6254 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6255 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6261 memset (&salt
, 0, sizeof (salt_t
));
6263 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6265 char *ptr
= (char *) salt
.salt_buf
;
6267 uint len
= salt
.salt_len
;
6269 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6275 case HASH_TYPE_NETNTLM
:
6277 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6278 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6280 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6286 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6288 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6296 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6298 uint max
= salt
.salt_len
/ 4;
6302 for (uint i
= 0; i
< max
; i
++)
6304 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6308 if (opts_type
& OPTS_TYPE_ST_HEX
)
6310 char tmp
[64] = { 0 };
6312 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6314 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6319 memcpy (ptr
, tmp
, len
);
6322 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6324 memset (ptr
+ len
, 0, memset_size
);
6326 salt
.salt_len
= len
;
6330 // some modes require special encoding
6333 uint out_buf_plain
[256] = { 0 };
6334 uint out_buf_salt
[256] = { 0 };
6336 char tmp_buf
[1024] = { 0 };
6338 char *ptr_plain
= (char *) out_buf_plain
;
6339 char *ptr_salt
= (char *) out_buf_salt
;
6341 if (hash_mode
== 22)
6343 char username
[30] = { 0 };
6345 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6347 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6349 u16
*ptr
= (u16
*) digest_buf
;
6351 tmp_buf
[ 0] = sig
[0];
6352 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6353 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6354 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6355 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6356 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6357 tmp_buf
[ 6] = sig
[1];
6358 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6359 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6360 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6361 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6362 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6363 tmp_buf
[12] = sig
[2];
6364 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6365 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6366 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6367 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6368 tmp_buf
[17] = sig
[3];
6369 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6370 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6371 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6372 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6373 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6374 tmp_buf
[23] = sig
[4];
6375 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6376 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6377 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6378 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6379 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6380 tmp_buf
[29] = sig
[5];
6382 snprintf (out_buf
, len
-1, "%s:%s",
6386 else if (hash_mode
== 23)
6388 // do not show the skyper part in output
6390 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6392 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6394 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6401 else if (hash_mode
== 101)
6403 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6405 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6406 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6407 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6408 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6409 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6411 memcpy (tmp_buf
, digest_buf
, 20);
6413 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6415 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6417 else if (hash_mode
== 111)
6419 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6421 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6422 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6423 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6424 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6425 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6427 memcpy (tmp_buf
, digest_buf
, 20);
6428 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6430 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6432 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6434 else if ((hash_mode
== 122) || (hash_mode
== 125))
6436 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6437 (char *) salt
.salt_buf
,
6444 else if (hash_mode
== 124)
6446 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6447 (char *) salt
.salt_buf
,
6454 else if (hash_mode
== 131)
6456 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6457 (char *) salt
.salt_buf
,
6465 else if (hash_mode
== 132)
6467 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6468 (char *) salt
.salt_buf
,
6475 else if (hash_mode
== 133)
6477 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6479 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6480 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6481 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6482 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6483 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6485 memcpy (tmp_buf
, digest_buf
, 20);
6487 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6489 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6491 else if (hash_mode
== 141)
6493 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6495 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6497 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6499 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6501 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6502 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6503 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6504 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6505 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6507 memcpy (tmp_buf
, digest_buf
, 20);
6509 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6513 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6515 else if (hash_mode
== 400)
6517 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6519 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6520 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6521 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6522 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6524 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6526 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6528 else if (hash_mode
== 500)
6530 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6532 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6533 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6534 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6535 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6537 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6539 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6541 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6545 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6548 else if (hash_mode
== 501)
6550 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6552 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6553 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6555 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6557 else if (hash_mode
== 1421)
6559 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6561 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6577 else if (hash_mode
== 1441)
6579 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6581 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6583 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6585 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6587 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6588 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6589 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6590 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6591 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6592 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6593 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6594 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6596 memcpy (tmp_buf
, digest_buf
, 32);
6598 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6602 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6604 else if (hash_mode
== 1500)
6606 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6607 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6608 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6609 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6610 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6612 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6614 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6616 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6617 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6619 memcpy (tmp_buf
, digest_buf
, 8);
6621 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6623 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6627 else if (hash_mode
== 1600)
6629 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6631 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6632 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6633 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6634 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6636 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6638 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6640 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6644 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6647 else if (hash_mode
== 1711)
6649 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6651 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6652 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6653 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6654 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6655 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6656 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6657 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6658 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6660 memcpy (tmp_buf
, digest_buf
, 64);
6661 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6663 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6665 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6667 else if (hash_mode
== 1722)
6669 uint
*ptr
= digest_buf
;
6671 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6672 (unsigned char *) salt
.salt_buf
,
6682 else if (hash_mode
== 1731)
6684 uint
*ptr
= digest_buf
;
6686 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6687 (unsigned char *) salt
.salt_buf
,
6697 else if (hash_mode
== 1800)
6701 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6702 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6703 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6704 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6705 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6706 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6707 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6708 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6710 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6712 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6714 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6718 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6721 else if (hash_mode
== 2100)
6725 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6727 salt
.salt_iter
+ 1);
6729 uint signature_len
= strlen (out_buf
);
6731 pos
+= signature_len
;
6732 len
-= signature_len
;
6734 char *salt_ptr
= (char *) salt
.salt_buf
;
6736 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6738 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6739 byte_swap_32 (digest_buf
[0]),
6740 byte_swap_32 (digest_buf
[1]),
6741 byte_swap_32 (digest_buf
[2]),
6742 byte_swap_32 (digest_buf
[3]));
6744 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6746 memcpy (tmp_buf
, digest_buf
, 16);
6748 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6750 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6751 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6752 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6753 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6755 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6756 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6757 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6758 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6760 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6761 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6762 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6763 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6765 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6766 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6767 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6768 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6770 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6771 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6772 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6773 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6777 else if (hash_mode
== 2500)
6779 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6781 wpa_t
*wpa
= &wpas
[salt_pos
];
6783 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6784 (char *) salt
.salt_buf
,
6798 else if (hash_mode
== 4400)
6800 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6801 byte_swap_32 (digest_buf
[0]),
6802 byte_swap_32 (digest_buf
[1]),
6803 byte_swap_32 (digest_buf
[2]),
6804 byte_swap_32 (digest_buf
[3]));
6806 else if (hash_mode
== 4700)
6808 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6809 byte_swap_32 (digest_buf
[0]),
6810 byte_swap_32 (digest_buf
[1]),
6811 byte_swap_32 (digest_buf
[2]),
6812 byte_swap_32 (digest_buf
[3]),
6813 byte_swap_32 (digest_buf
[4]));
6815 else if (hash_mode
== 4800)
6817 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6819 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6824 byte_swap_32 (salt
.salt_buf
[0]),
6825 byte_swap_32 (salt
.salt_buf
[1]),
6826 byte_swap_32 (salt
.salt_buf
[2]),
6827 byte_swap_32 (salt
.salt_buf
[3]),
6830 else if (hash_mode
== 4900)
6832 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6833 byte_swap_32 (digest_buf
[0]),
6834 byte_swap_32 (digest_buf
[1]),
6835 byte_swap_32 (digest_buf
[2]),
6836 byte_swap_32 (digest_buf
[3]),
6837 byte_swap_32 (digest_buf
[4]));
6839 else if (hash_mode
== 5100)
6841 snprintf (out_buf
, len
-1, "%08x%08x",
6845 else if (hash_mode
== 5200)
6847 snprintf (out_buf
, len
-1, "%s", hashfile
);
6849 else if (hash_mode
== 5300)
6851 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6853 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6855 int buf_len
= len
-1;
6859 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6861 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6863 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6865 snprintf (out_buf
, buf_len
, ":");
6871 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6879 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6881 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6883 if ((i
== 0) || (i
== 5))
6885 snprintf (out_buf
, buf_len
, ":");
6891 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6899 for (uint i
= 0; i
< 4; i
++)
6903 snprintf (out_buf
, buf_len
, ":");
6909 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6915 else if (hash_mode
== 5400)
6917 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6919 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6921 int buf_len
= len
-1;
6925 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6927 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6929 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6931 snprintf (out_buf
, buf_len
, ":");
6937 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6945 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6947 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6949 if ((i
== 0) || (i
== 5))
6951 snprintf (out_buf
, buf_len
, ":");
6957 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6965 for (uint i
= 0; i
< 5; i
++)
6969 snprintf (out_buf
, buf_len
, ":");
6975 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6981 else if (hash_mode
== 5500)
6983 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6985 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6987 char user_buf
[64] = { 0 };
6988 char domain_buf
[64] = { 0 };
6989 char srvchall_buf
[1024] = { 0 };
6990 char clichall_buf
[1024] = { 0 };
6992 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6994 char *ptr
= (char *) netntlm
->userdomain_buf
;
6996 user_buf
[i
] = ptr
[j
];
6999 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7001 char *ptr
= (char *) netntlm
->userdomain_buf
;
7003 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7006 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7008 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7010 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7013 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7015 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7017 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7020 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
7028 byte_swap_32 (salt
.salt_buf_pc
[0]),
7029 byte_swap_32 (salt
.salt_buf_pc
[1]),
7032 else if (hash_mode
== 5600)
7034 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7036 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7038 char user_buf
[64] = { 0 };
7039 char domain_buf
[64] = { 0 };
7040 char srvchall_buf
[1024] = { 0 };
7041 char clichall_buf
[1024] = { 0 };
7043 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7045 char *ptr
= (char *) netntlm
->userdomain_buf
;
7047 user_buf
[i
] = ptr
[j
];
7050 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7052 char *ptr
= (char *) netntlm
->userdomain_buf
;
7054 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7057 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7059 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7061 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7064 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7066 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7068 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7071 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
7081 else if (hash_mode
== 5700)
7083 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7085 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7086 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7087 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7088 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7089 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7090 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7091 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7092 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7094 memcpy (tmp_buf
, digest_buf
, 32);
7096 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
7100 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
7102 else if (hash_mode
== 5800)
7104 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7105 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7106 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7107 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7108 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7110 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
7117 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
7119 snprintf (out_buf
, len
-1, "%s", hashfile
);
7121 else if (hash_mode
== 6300)
7123 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7125 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7126 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7127 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7128 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7130 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7132 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7134 else if (hash_mode
== 6400)
7136 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7138 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7140 else if (hash_mode
== 6500)
7142 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7144 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7146 else if (hash_mode
== 6600)
7148 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
7150 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
7152 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7153 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7155 uint buf_len
= len
- 1;
7157 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
7160 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
7162 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
7167 else if (hash_mode
== 6700)
7169 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7171 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7173 else if (hash_mode
== 6800)
7175 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
7177 else if (hash_mode
== 7100)
7179 uint
*ptr
= digest_buf
;
7181 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7183 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7185 uint esalt
[8] = { 0 };
7187 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7188 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7189 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7190 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7191 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7192 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7193 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7194 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7196 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",
7197 SIGNATURE_SHA512OSX
,
7199 esalt
[ 0], esalt
[ 1],
7200 esalt
[ 2], esalt
[ 3],
7201 esalt
[ 4], esalt
[ 5],
7202 esalt
[ 6], esalt
[ 7],
7210 ptr
[15], ptr
[14]);
7212 else if (hash_mode
== 7200)
7214 uint
*ptr
= digest_buf
;
7216 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7218 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7222 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7224 len_used
= strlen (out_buf
);
7226 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7228 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7230 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7233 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",
7241 ptr
[15], ptr
[14]);
7243 else if (hash_mode
== 7300)
7245 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7247 rakp_t
*rakp
= &rakps
[salt_pos
];
7249 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7251 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7254 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7261 else if (hash_mode
== 7400)
7263 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7265 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7266 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7267 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7268 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7269 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7270 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7271 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7272 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7274 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7276 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7278 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7282 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7285 else if (hash_mode
== 7500)
7287 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7289 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7291 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7292 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7294 char data
[128] = { 0 };
7296 char *ptr_data
= data
;
7298 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7300 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7303 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7305 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7310 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7312 (char *) krb5pa
->user
,
7313 (char *) krb5pa
->realm
,
7314 (char *) krb5pa
->salt
,
7317 else if (hash_mode
== 7700)
7319 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7320 (char *) salt
.salt_buf
,
7324 else if (hash_mode
== 7800)
7326 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7327 (char *) salt
.salt_buf
,
7334 else if (hash_mode
== 7900)
7336 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7340 char *tmp
= (char *) salt
.salt_buf_pc
;
7342 ptr_plain
[42] = tmp
[0];
7348 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7350 else if (hash_mode
== 8000)
7352 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7353 (unsigned char *) salt
.salt_buf
,
7363 else if (hash_mode
== 8100)
7365 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7366 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7368 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7369 (unsigned char *) salt
.salt_buf
,
7376 else if (hash_mode
== 8200)
7378 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7380 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7382 char data_buf
[4096] = { 0 };
7384 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7386 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7389 data_buf
[cloudkey
->data_len
* 2] = 0;
7391 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7392 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7393 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7394 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7395 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7396 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7397 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7398 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7400 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7401 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7402 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7403 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7405 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7421 else if (hash_mode
== 8300)
7423 char digest_buf_c
[34] = { 0 };
7425 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7426 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7427 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7428 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7429 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7431 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7433 digest_buf_c
[32] = 0;
7437 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7439 char domain_buf_c
[33] = { 0 };
7441 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7443 for (uint i
= 0; i
< salt_pc_len
; i
++)
7445 const char next
= domain_buf_c
[i
];
7447 domain_buf_c
[i
] = '.';
7452 domain_buf_c
[salt_pc_len
] = 0;
7456 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7458 else if (hash_mode
== 8500)
7460 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7462 else if (hash_mode
== 2612)
7464 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7466 (char *) salt
.salt_buf
,
7472 else if (hash_mode
== 3711)
7474 char *salt_ptr
= (char *) salt
.salt_buf
;
7476 salt_ptr
[salt
.salt_len
- 1] = 0;
7478 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7479 SIGNATURE_MEDIAWIKI_B
,
7486 else if (hash_mode
== 8800)
7488 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7490 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7492 char tmp
[3073] = { 0 };
7494 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7496 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7501 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7502 SIGNATURE_ANDROIDFDE
,
7503 byte_swap_32 (salt
.salt_buf
[0]),
7504 byte_swap_32 (salt
.salt_buf
[1]),
7505 byte_swap_32 (salt
.salt_buf
[2]),
7506 byte_swap_32 (salt
.salt_buf
[3]),
7507 byte_swap_32 (digest_buf
[0]),
7508 byte_swap_32 (digest_buf
[1]),
7509 byte_swap_32 (digest_buf
[2]),
7510 byte_swap_32 (digest_buf
[3]),
7513 else if (hash_mode
== 8900)
7515 uint N
= salt
.scrypt_N
;
7516 uint r
= salt
.scrypt_r
;
7517 uint p
= salt
.scrypt_p
;
7519 char base64_salt
[32] = { 0 };
7521 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7523 memset (tmp_buf
, 0, 46);
7525 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7526 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7527 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7528 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7529 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7530 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7531 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7532 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7533 digest_buf
[8] = 0; // needed for base64_encode ()
7535 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7537 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7545 else if (hash_mode
== 9000)
7547 snprintf (out_buf
, len
-1, "%s", hashfile
);
7549 else if (hash_mode
== 9200)
7553 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7555 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7557 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7561 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7562 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7563 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7564 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7565 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7566 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7567 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7568 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7569 digest_buf
[8] = 0; // needed for base64_encode ()
7571 char tmp_buf
[64] = { 0 };
7573 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7574 tmp_buf
[43] = 0; // cut it here
7578 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7580 else if (hash_mode
== 9300)
7582 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7583 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7584 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7585 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7586 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7587 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7588 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7589 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7590 digest_buf
[8] = 0; // needed for base64_encode ()
7592 char tmp_buf
[64] = { 0 };
7594 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7595 tmp_buf
[43] = 0; // cut it here
7597 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7599 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7601 else if (hash_mode
== 9400)
7603 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7605 office2007_t
*office2007
= &office2007s
[salt_pos
];
7607 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7608 SIGNATURE_OFFICE2007
,
7611 office2007
->keySize
,
7617 office2007
->encryptedVerifier
[0],
7618 office2007
->encryptedVerifier
[1],
7619 office2007
->encryptedVerifier
[2],
7620 office2007
->encryptedVerifier
[3],
7621 office2007
->encryptedVerifierHash
[0],
7622 office2007
->encryptedVerifierHash
[1],
7623 office2007
->encryptedVerifierHash
[2],
7624 office2007
->encryptedVerifierHash
[3],
7625 office2007
->encryptedVerifierHash
[4]);
7627 else if (hash_mode
== 9500)
7629 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7631 office2010_t
*office2010
= &office2010s
[salt_pos
];
7633 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,
7639 office2010
->encryptedVerifier
[0],
7640 office2010
->encryptedVerifier
[1],
7641 office2010
->encryptedVerifier
[2],
7642 office2010
->encryptedVerifier
[3],
7643 office2010
->encryptedVerifierHash
[0],
7644 office2010
->encryptedVerifierHash
[1],
7645 office2010
->encryptedVerifierHash
[2],
7646 office2010
->encryptedVerifierHash
[3],
7647 office2010
->encryptedVerifierHash
[4],
7648 office2010
->encryptedVerifierHash
[5],
7649 office2010
->encryptedVerifierHash
[6],
7650 office2010
->encryptedVerifierHash
[7]);
7652 else if (hash_mode
== 9600)
7654 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7656 office2013_t
*office2013
= &office2013s
[salt_pos
];
7658 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,
7664 office2013
->encryptedVerifier
[0],
7665 office2013
->encryptedVerifier
[1],
7666 office2013
->encryptedVerifier
[2],
7667 office2013
->encryptedVerifier
[3],
7668 office2013
->encryptedVerifierHash
[0],
7669 office2013
->encryptedVerifierHash
[1],
7670 office2013
->encryptedVerifierHash
[2],
7671 office2013
->encryptedVerifierHash
[3],
7672 office2013
->encryptedVerifierHash
[4],
7673 office2013
->encryptedVerifierHash
[5],
7674 office2013
->encryptedVerifierHash
[6],
7675 office2013
->encryptedVerifierHash
[7]);
7677 else if (hash_mode
== 9700)
7679 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7681 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7683 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7684 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7685 byte_swap_32 (salt
.salt_buf
[0]),
7686 byte_swap_32 (salt
.salt_buf
[1]),
7687 byte_swap_32 (salt
.salt_buf
[2]),
7688 byte_swap_32 (salt
.salt_buf
[3]),
7689 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7690 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7691 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7692 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7693 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7694 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7695 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7696 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7698 else if (hash_mode
== 9710)
7700 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7702 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7704 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7705 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7706 byte_swap_32 (salt
.salt_buf
[0]),
7707 byte_swap_32 (salt
.salt_buf
[1]),
7708 byte_swap_32 (salt
.salt_buf
[2]),
7709 byte_swap_32 (salt
.salt_buf
[3]),
7710 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7711 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7712 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7713 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7714 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7715 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7716 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7717 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7719 else if (hash_mode
== 9720)
7721 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7723 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7725 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7727 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7728 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7729 byte_swap_32 (salt
.salt_buf
[0]),
7730 byte_swap_32 (salt
.salt_buf
[1]),
7731 byte_swap_32 (salt
.salt_buf
[2]),
7732 byte_swap_32 (salt
.salt_buf
[3]),
7733 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7734 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7735 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7736 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7737 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7738 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7739 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7740 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7747 else if (hash_mode
== 9800)
7749 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7751 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7753 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7754 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7759 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7760 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7761 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7762 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7763 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7764 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7765 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7766 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7767 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7769 else if (hash_mode
== 9810)
7771 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7773 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7775 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7776 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7781 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7782 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7783 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7784 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7785 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7786 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7787 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7788 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7789 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7791 else if (hash_mode
== 9820)
7793 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7795 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7797 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7799 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7800 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7805 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7806 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7807 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7808 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7809 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7810 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7811 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7812 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7813 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7820 else if (hash_mode
== 10000)
7824 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7826 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7828 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7832 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7833 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7834 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7835 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7836 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7837 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7838 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7839 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7840 digest_buf
[8] = 0; // needed for base64_encode ()
7842 char tmp_buf
[64] = { 0 };
7844 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7848 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7850 else if (hash_mode
== 10100)
7852 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7857 byte_swap_32 (salt
.salt_buf
[0]),
7858 byte_swap_32 (salt
.salt_buf
[1]),
7859 byte_swap_32 (salt
.salt_buf
[2]),
7860 byte_swap_32 (salt
.salt_buf
[3]));
7862 else if (hash_mode
== 10200)
7864 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7866 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7870 char challenge
[100] = { 0 };
7872 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7876 char tmp_buf
[100] = { 0 };
7878 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7879 (char *) cram_md5
->user
,
7885 char response
[100] = { 0 };
7887 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7889 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7891 else if (hash_mode
== 10300)
7893 char tmp_buf
[100] = { 0 };
7895 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7896 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7898 uint tmp_len
= 20 + salt
.salt_len
;
7902 char base64_encoded
[100] = { 0 };
7904 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7906 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7908 else if (hash_mode
== 10400)
7910 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7912 pdf_t
*pdf
= &pdfs
[salt_pos
];
7914 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",
7922 byte_swap_32 (pdf
->id_buf
[0]),
7923 byte_swap_32 (pdf
->id_buf
[1]),
7924 byte_swap_32 (pdf
->id_buf
[2]),
7925 byte_swap_32 (pdf
->id_buf
[3]),
7927 byte_swap_32 (pdf
->u_buf
[0]),
7928 byte_swap_32 (pdf
->u_buf
[1]),
7929 byte_swap_32 (pdf
->u_buf
[2]),
7930 byte_swap_32 (pdf
->u_buf
[3]),
7931 byte_swap_32 (pdf
->u_buf
[4]),
7932 byte_swap_32 (pdf
->u_buf
[5]),
7933 byte_swap_32 (pdf
->u_buf
[6]),
7934 byte_swap_32 (pdf
->u_buf
[7]),
7936 byte_swap_32 (pdf
->o_buf
[0]),
7937 byte_swap_32 (pdf
->o_buf
[1]),
7938 byte_swap_32 (pdf
->o_buf
[2]),
7939 byte_swap_32 (pdf
->o_buf
[3]),
7940 byte_swap_32 (pdf
->o_buf
[4]),
7941 byte_swap_32 (pdf
->o_buf
[5]),
7942 byte_swap_32 (pdf
->o_buf
[6]),
7943 byte_swap_32 (pdf
->o_buf
[7])
7946 else if (hash_mode
== 10410)
7948 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7950 pdf_t
*pdf
= &pdfs
[salt_pos
];
7952 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",
7960 byte_swap_32 (pdf
->id_buf
[0]),
7961 byte_swap_32 (pdf
->id_buf
[1]),
7962 byte_swap_32 (pdf
->id_buf
[2]),
7963 byte_swap_32 (pdf
->id_buf
[3]),
7965 byte_swap_32 (pdf
->u_buf
[0]),
7966 byte_swap_32 (pdf
->u_buf
[1]),
7967 byte_swap_32 (pdf
->u_buf
[2]),
7968 byte_swap_32 (pdf
->u_buf
[3]),
7969 byte_swap_32 (pdf
->u_buf
[4]),
7970 byte_swap_32 (pdf
->u_buf
[5]),
7971 byte_swap_32 (pdf
->u_buf
[6]),
7972 byte_swap_32 (pdf
->u_buf
[7]),
7974 byte_swap_32 (pdf
->o_buf
[0]),
7975 byte_swap_32 (pdf
->o_buf
[1]),
7976 byte_swap_32 (pdf
->o_buf
[2]),
7977 byte_swap_32 (pdf
->o_buf
[3]),
7978 byte_swap_32 (pdf
->o_buf
[4]),
7979 byte_swap_32 (pdf
->o_buf
[5]),
7980 byte_swap_32 (pdf
->o_buf
[6]),
7981 byte_swap_32 (pdf
->o_buf
[7])
7984 else if (hash_mode
== 10420)
7986 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7988 pdf_t
*pdf
= &pdfs
[salt_pos
];
7990 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7992 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",
8000 byte_swap_32 (pdf
->id_buf
[0]),
8001 byte_swap_32 (pdf
->id_buf
[1]),
8002 byte_swap_32 (pdf
->id_buf
[2]),
8003 byte_swap_32 (pdf
->id_buf
[3]),
8005 byte_swap_32 (pdf
->u_buf
[0]),
8006 byte_swap_32 (pdf
->u_buf
[1]),
8007 byte_swap_32 (pdf
->u_buf
[2]),
8008 byte_swap_32 (pdf
->u_buf
[3]),
8009 byte_swap_32 (pdf
->u_buf
[4]),
8010 byte_swap_32 (pdf
->u_buf
[5]),
8011 byte_swap_32 (pdf
->u_buf
[6]),
8012 byte_swap_32 (pdf
->u_buf
[7]),
8014 byte_swap_32 (pdf
->o_buf
[0]),
8015 byte_swap_32 (pdf
->o_buf
[1]),
8016 byte_swap_32 (pdf
->o_buf
[2]),
8017 byte_swap_32 (pdf
->o_buf
[3]),
8018 byte_swap_32 (pdf
->o_buf
[4]),
8019 byte_swap_32 (pdf
->o_buf
[5]),
8020 byte_swap_32 (pdf
->o_buf
[6]),
8021 byte_swap_32 (pdf
->o_buf
[7]),
8029 else if (hash_mode
== 10500)
8031 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8033 pdf_t
*pdf
= &pdfs
[salt_pos
];
8035 if (pdf
->id_len
== 32)
8037 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",
8045 byte_swap_32 (pdf
->id_buf
[0]),
8046 byte_swap_32 (pdf
->id_buf
[1]),
8047 byte_swap_32 (pdf
->id_buf
[2]),
8048 byte_swap_32 (pdf
->id_buf
[3]),
8049 byte_swap_32 (pdf
->id_buf
[4]),
8050 byte_swap_32 (pdf
->id_buf
[5]),
8051 byte_swap_32 (pdf
->id_buf
[6]),
8052 byte_swap_32 (pdf
->id_buf
[7]),
8054 byte_swap_32 (pdf
->u_buf
[0]),
8055 byte_swap_32 (pdf
->u_buf
[1]),
8056 byte_swap_32 (pdf
->u_buf
[2]),
8057 byte_swap_32 (pdf
->u_buf
[3]),
8058 byte_swap_32 (pdf
->u_buf
[4]),
8059 byte_swap_32 (pdf
->u_buf
[5]),
8060 byte_swap_32 (pdf
->u_buf
[6]),
8061 byte_swap_32 (pdf
->u_buf
[7]),
8063 byte_swap_32 (pdf
->o_buf
[0]),
8064 byte_swap_32 (pdf
->o_buf
[1]),
8065 byte_swap_32 (pdf
->o_buf
[2]),
8066 byte_swap_32 (pdf
->o_buf
[3]),
8067 byte_swap_32 (pdf
->o_buf
[4]),
8068 byte_swap_32 (pdf
->o_buf
[5]),
8069 byte_swap_32 (pdf
->o_buf
[6]),
8070 byte_swap_32 (pdf
->o_buf
[7])
8075 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",
8083 byte_swap_32 (pdf
->id_buf
[0]),
8084 byte_swap_32 (pdf
->id_buf
[1]),
8085 byte_swap_32 (pdf
->id_buf
[2]),
8086 byte_swap_32 (pdf
->id_buf
[3]),
8088 byte_swap_32 (pdf
->u_buf
[0]),
8089 byte_swap_32 (pdf
->u_buf
[1]),
8090 byte_swap_32 (pdf
->u_buf
[2]),
8091 byte_swap_32 (pdf
->u_buf
[3]),
8092 byte_swap_32 (pdf
->u_buf
[4]),
8093 byte_swap_32 (pdf
->u_buf
[5]),
8094 byte_swap_32 (pdf
->u_buf
[6]),
8095 byte_swap_32 (pdf
->u_buf
[7]),
8097 byte_swap_32 (pdf
->o_buf
[0]),
8098 byte_swap_32 (pdf
->o_buf
[1]),
8099 byte_swap_32 (pdf
->o_buf
[2]),
8100 byte_swap_32 (pdf
->o_buf
[3]),
8101 byte_swap_32 (pdf
->o_buf
[4]),
8102 byte_swap_32 (pdf
->o_buf
[5]),
8103 byte_swap_32 (pdf
->o_buf
[6]),
8104 byte_swap_32 (pdf
->o_buf
[7])
8108 else if (hash_mode
== 10600)
8110 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8112 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8113 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8115 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8117 else if (hash_mode
== 10700)
8119 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8121 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8122 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8124 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8126 else if (hash_mode
== 10900)
8128 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8130 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8131 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8133 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8135 else if (hash_mode
== 11100)
8137 u32 salt_challenge
= salt
.salt_buf
[0];
8139 salt_challenge
= byte_swap_32 (salt_challenge
);
8141 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
8143 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
8144 SIGNATURE_POSTGRESQL_AUTH
,
8152 else if (hash_mode
== 11200)
8154 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
8155 SIGNATURE_MYSQL_AUTH
,
8156 (unsigned char *) salt
.salt_buf
,
8163 else if (hash_mode
== 11300)
8165 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
8167 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
8169 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
8170 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
8171 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
8173 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
8174 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
8175 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
8177 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
8179 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
8181 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
8184 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
8186 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
8188 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8191 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8193 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8195 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8198 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8199 SIGNATURE_BITCOIN_WALLET
,
8203 (unsigned char *) salt
.salt_buf
,
8211 free (cry_master_buf
);
8213 free (public_key_buf
);
8215 else if (hash_mode
== 11400)
8217 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8219 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8220 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8222 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8224 else if (hash_mode
== 11600)
8226 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8228 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8230 const uint data_len
= seven_zip
->data_len
;
8232 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8234 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8236 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8238 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8241 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8242 SIGNATURE_SEVEN_ZIP
,
8246 (char *) seven_zip
->salt_buf
,
8248 seven_zip
->iv_buf
[0],
8249 seven_zip
->iv_buf
[1],
8250 seven_zip
->iv_buf
[2],
8251 seven_zip
->iv_buf
[3],
8253 seven_zip
->data_len
,
8254 seven_zip
->unpack_size
,
8259 else if (hash_mode
== 11700)
8261 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8271 else if (hash_mode
== 11800)
8273 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8291 else if (hash_mode
== 11900)
8293 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8295 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8296 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8298 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8300 else if (hash_mode
== 12000)
8302 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8304 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8305 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8307 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8309 else if (hash_mode
== 12100)
8311 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8313 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8314 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8316 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8318 else if (hash_mode
== 12200)
8320 uint
*ptr_digest
= digest_buf
;
8321 uint
*ptr_salt
= salt
.salt_buf
;
8323 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8330 else if (hash_mode
== 12300)
8332 uint
*ptr_digest
= digest_buf
;
8333 uint
*ptr_salt
= salt
.salt_buf
;
8335 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",
8336 ptr_digest
[ 0], ptr_digest
[ 1],
8337 ptr_digest
[ 2], ptr_digest
[ 3],
8338 ptr_digest
[ 4], ptr_digest
[ 5],
8339 ptr_digest
[ 6], ptr_digest
[ 7],
8340 ptr_digest
[ 8], ptr_digest
[ 9],
8341 ptr_digest
[10], ptr_digest
[11],
8342 ptr_digest
[12], ptr_digest
[13],
8343 ptr_digest
[14], ptr_digest
[15],
8349 else if (hash_mode
== 12400)
8351 // encode iteration count
8353 char salt_iter
[5] = { 0 };
8355 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8356 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8357 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8358 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8363 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8364 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8365 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8366 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8371 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8373 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8374 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8376 memcpy (tmp_buf
, digest_buf
, 8);
8378 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8382 // fill the resulting buffer
8384 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8386 else if (hash_mode
== 12500)
8388 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8390 byte_swap_32 (salt
.salt_buf
[0]),
8391 byte_swap_32 (salt
.salt_buf
[1]),
8397 else if (hash_mode
== 12600)
8399 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8400 digest_buf
[0] + salt
.salt_buf_pc
[0],
8401 digest_buf
[1] + salt
.salt_buf_pc
[1],
8402 digest_buf
[2] + salt
.salt_buf_pc
[2],
8403 digest_buf
[3] + salt
.salt_buf_pc
[3],
8404 digest_buf
[4] + salt
.salt_buf_pc
[4],
8405 digest_buf
[5] + salt
.salt_buf_pc
[5],
8406 digest_buf
[6] + salt
.salt_buf_pc
[6],
8407 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8409 else if (hash_mode
== 12700)
8411 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8413 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8414 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8416 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8418 else if (hash_mode
== 12800)
8420 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8422 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",
8435 byte_swap_32 (digest_buf
[0]),
8436 byte_swap_32 (digest_buf
[1]),
8437 byte_swap_32 (digest_buf
[2]),
8438 byte_swap_32 (digest_buf
[3]),
8439 byte_swap_32 (digest_buf
[4]),
8440 byte_swap_32 (digest_buf
[5]),
8441 byte_swap_32 (digest_buf
[6]),
8442 byte_swap_32 (digest_buf
[7])
8445 else if (hash_mode
== 12900)
8447 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",
8456 byte_swap_32 (digest_buf
[0]),
8457 byte_swap_32 (digest_buf
[1]),
8458 byte_swap_32 (digest_buf
[2]),
8459 byte_swap_32 (digest_buf
[3]),
8460 byte_swap_32 (digest_buf
[4]),
8461 byte_swap_32 (digest_buf
[5]),
8462 byte_swap_32 (digest_buf
[6]),
8463 byte_swap_32 (digest_buf
[7]),
8470 else if (hash_mode
== 13000)
8472 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8474 rar5_t
*rar5
= &rar5s
[salt_pos
];
8476 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8486 byte_swap_32 (digest_buf
[0]),
8487 byte_swap_32 (digest_buf
[1])
8490 else if (hash_mode
== 13100)
8492 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8494 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8496 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8497 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8499 char data
[2560 * 4 * 2] = { 0 };
8501 char *ptr_data
= data
;
8503 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8504 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8509 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8510 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8512 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8514 (char *) krb5tgs
->account_info
,
8518 else if (hash_mode
== 13200)
8520 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8534 else if (hash_mode
== 13300)
8536 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8537 SIGNATURE_AXCRYPT_SHA1
,
8543 else if (hash_mode
== 13400)
8545 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8547 keepass_t
*keepass
= &keepasss
[salt_pos
];
8549 u32 version
= (u32
) keepass
->version
;
8550 u32 rounds
= salt
.salt_iter
;
8551 u32 algorithm
= (u32
) keepass
->algorithm
;
8552 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8554 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8555 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8556 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8557 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8558 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8560 /* specific to version 1 */
8564 /* specific to version 2 */
8565 u32 expected_bytes_len
;
8566 u32
*ptr_expected_bytes
;
8568 u32 final_random_seed_len
;
8569 u32 transf_random_seed_len
;
8571 u32 contents_hash_len
;
8573 transf_random_seed_len
= 8;
8575 contents_hash_len
= 8;
8576 final_random_seed_len
= 8;
8579 final_random_seed_len
= 4;
8581 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8587 char *ptr_data
= out_buf
;
8589 ptr_data
+= strlen(out_buf
);
8594 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8595 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8600 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8601 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8606 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8607 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8614 contents_len
= (u32
) keepass
->contents_len
;
8615 ptr_contents
= (u32
*) keepass
->contents
;
8617 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8618 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8630 char ptr_contents_len
[10] = { 0 };
8632 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8634 sprintf (ptr_data
, "%d", contents_len
);
8636 ptr_data
+= strlen(ptr_contents_len
);
8641 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8642 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8644 else if (version
== 2)
8646 expected_bytes_len
= 8;
8647 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8649 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8650 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8655 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8656 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8670 sprintf (ptr_data
, "%d", keyfile_len
);
8677 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8678 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8681 else if (hash_mode
== 13500)
8683 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8685 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8687 const u32 salt_len
= (pstoken
->salt_len
> 512) ? 512 : pstoken
->salt_len
;
8689 char pstoken_tmp
[1024 + 1] = { 0 };
8691 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8693 const u8
*ptr
= (const u8
*) pstoken
->salt_buf
;
8695 sprintf (pstoken_tmp
+ j
, "%02x", ptr
[i
]);
8698 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8706 else if (hash_mode
== 13600)
8708 zip2_t
*zip2s
= (zip2_t
*) data
.esalts_buf
;
8710 zip2_t
*zip2
= &zip2s
[salt_pos
];
8712 const u32 salt_len
= zip2
->salt_len
;
8714 char salt_tmp
[32 + 1] = { 0 };
8716 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8718 const u8
*ptr
= (const u8
*) zip2
->salt_buf
;
8720 sprintf (salt_tmp
+ j
, "%02x", ptr
[i
]);
8723 const u32 data_len
= zip2
->data_len
;
8725 char data_tmp
[8192 + 1] = { 0 };
8727 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8729 const u8
*ptr
= (const u8
*) zip2
->data_buf
;
8731 sprintf (data_tmp
+ j
, "%02x", ptr
[i
]);
8734 const u32 auth_len
= zip2
->auth_len
;
8736 char auth_tmp
[20 + 1] = { 0 };
8738 for (uint i
= 0, j
= 0; i
< auth_len
; i
+= 1, j
+= 2)
8740 const u8
*ptr
= (const u8
*) zip2
->auth_buf
;
8742 sprintf (auth_tmp
+ j
, "%02x", ptr
[i
]);
8745 snprintf (out_buf
, 255, "%s*%u*%u*%u*%s*%x*%u*%s*%s*%s",
8746 SIGNATURE_ZIP2_START
,
8752 zip2
->compress_length
,
8755 SIGNATURE_ZIP2_STOP
);
8757 else if ((hash_mode
>= 13700) && (hash_mode
<= 13799))
8759 snprintf (out_buf
, len
-1, "%s", hashfile
);
8761 else if (hash_mode
== 13800)
8763 win8phone_t
*esalts
= (win8phone_t
*) data
.esalts_buf
;
8765 win8phone_t
*esalt
= &esalts
[salt_pos
];
8767 char buf
[256 + 1] = { 0 };
8769 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
8771 sprintf (buf
+ j
, "%08x", esalt
->salt_buf
[i
]);
8774 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%s",
8787 if (hash_type
== HASH_TYPE_MD4
)
8789 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8795 else if (hash_type
== HASH_TYPE_MD5
)
8797 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8803 else if (hash_type
== HASH_TYPE_SHA1
)
8805 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8812 else if (hash_type
== HASH_TYPE_SHA256
)
8814 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8824 else if (hash_type
== HASH_TYPE_SHA384
)
8826 uint
*ptr
= digest_buf
;
8828 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8836 else if (hash_type
== HASH_TYPE_SHA512
)
8838 uint
*ptr
= digest_buf
;
8840 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8850 else if (hash_type
== HASH_TYPE_LM
)
8852 snprintf (out_buf
, len
-1, "%08x%08x",
8856 else if (hash_type
== HASH_TYPE_ORACLEH
)
8858 snprintf (out_buf
, len
-1, "%08X%08X",
8862 else if (hash_type
== HASH_TYPE_BCRYPT
)
8864 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8865 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8867 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8869 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8871 else if (hash_type
== HASH_TYPE_KECCAK
)
8873 uint
*ptr
= digest_buf
;
8875 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",
8903 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8905 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8907 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8914 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8916 digest_buf
[ 0] = digest_buf
[ 0];
8917 digest_buf
[ 1] = digest_buf
[ 1];
8918 digest_buf
[ 2] = digest_buf
[ 2];
8919 digest_buf
[ 3] = digest_buf
[ 3];
8920 digest_buf
[ 4] = digest_buf
[ 4];
8921 digest_buf
[ 5] = digest_buf
[ 5];
8922 digest_buf
[ 6] = digest_buf
[ 6];
8923 digest_buf
[ 7] = digest_buf
[ 7];
8924 digest_buf
[ 8] = digest_buf
[ 8];
8925 digest_buf
[ 9] = digest_buf
[ 9];
8926 digest_buf
[10] = digest_buf
[10];
8927 digest_buf
[11] = digest_buf
[11];
8928 digest_buf
[12] = digest_buf
[12];
8929 digest_buf
[13] = digest_buf
[13];
8930 digest_buf
[14] = digest_buf
[14];
8931 digest_buf
[15] = digest_buf
[15];
8933 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8951 else if (hash_type
== HASH_TYPE_GOST
)
8953 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8963 else if (hash_type
== HASH_TYPE_MYSQL
)
8965 snprintf (out_buf
, len
-1, "%08x%08x",
8969 else if (hash_type
== HASH_TYPE_LOTUS5
)
8971 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8977 else if (hash_type
== HASH_TYPE_LOTUS6
)
8979 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8980 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8981 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8982 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8984 char buf
[16] = { 0 };
8986 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8987 memcpy (buf
+ 5, digest_buf
, 9);
8991 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8993 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8996 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8998 else if (hash_type
== HASH_TYPE_LOTUS8
)
9000 char buf
[52] = { 0 };
9004 memcpy (buf
+ 0, salt
.salt_buf
, 16);
9010 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
9014 buf
[26] = salt
.salt_buf_pc
[0];
9015 buf
[27] = salt
.salt_buf_pc
[1];
9019 memcpy (buf
+ 28, digest_buf
, 8);
9021 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
9025 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
9027 else if (hash_type
== HASH_TYPE_CRC32
)
9029 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
9033 if (salt_type
== SALT_TYPE_INTERN
)
9035 size_t pos
= strlen (out_buf
);
9037 out_buf
[pos
] = data
.separator
;
9039 char *ptr
= (char *) salt
.salt_buf
;
9041 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
9043 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
9047 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
9049 memset (hccap
, 0, sizeof (hccap_t
));
9051 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
9053 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
9055 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
9056 wpa_t
*wpa
= &wpas
[salt_pos
];
9058 hccap
->keyver
= wpa
->keyver
;
9060 hccap
->eapol_size
= wpa
->eapol_size
;
9062 if (wpa
->keyver
!= 1)
9064 uint eapol_tmp
[64] = { 0 };
9066 for (uint i
= 0; i
< 64; i
++)
9068 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9071 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
9075 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
9078 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
9079 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
9080 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
9081 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
9083 char *digests_buf_ptr
= (char *) data
.digests_buf
;
9085 uint dgst_size
= data
.dgst_size
;
9087 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
9089 if (wpa
->keyver
!= 1)
9091 uint digest_tmp
[4] = { 0 };
9093 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
9094 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
9095 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
9096 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
9098 memcpy (hccap
->keymic
, digest_tmp
, 16);
9102 memcpy (hccap
->keymic
, digest_ptr
, 16);
9106 void SuspendThreads ()
9108 if (data
.devices_status
== STATUS_RUNNING
)
9110 hc_timer_set (&data
.timer_paused
);
9112 data
.devices_status
= STATUS_PAUSED
;
9114 log_info ("Paused");
9118 void ResumeThreads ()
9120 if (data
.devices_status
== STATUS_PAUSED
)
9124 hc_timer_get (data
.timer_paused
, ms_paused
);
9126 data
.ms_paused
+= ms_paused
;
9128 data
.devices_status
= STATUS_RUNNING
;
9130 log_info ("Resumed");
9136 if (data
.devices_status
!= STATUS_RUNNING
) return;
9138 data
.devices_status
= STATUS_BYPASS
;
9140 log_info ("Next dictionary / mask in queue selected, bypassing current one");
9143 void stop_at_checkpoint ()
9145 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9147 if (data
.devices_status
!= STATUS_RUNNING
) return;
9150 // this feature only makes sense if --restore-disable was not specified
9152 if (data
.restore_disable
== 1)
9154 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
9159 // check if monitoring of Restore Point updates should be enabled or disabled
9161 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9163 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
9165 // save the current restore point value
9167 data
.checkpoint_cur_words
= get_lowest_words_done ();
9169 log_info ("Checkpoint enabled: will quit at next Restore Point update");
9173 data
.devices_status
= STATUS_RUNNING
;
9175 // reset the global value for checkpoint checks
9177 data
.checkpoint_cur_words
= 0;
9179 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
9185 if (data
.devices_status
== STATUS_INIT
) return;
9186 if (data
.devices_status
== STATUS_STARTING
) return;
9188 data
.devices_status
= STATUS_ABORTED
;
9193 if (data
.devices_status
== STATUS_INIT
) return;
9194 if (data
.devices_status
== STATUS_STARTING
) return;
9196 data
.devices_status
= STATUS_QUIT
;
9199 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
9201 FILE *fp
= fopen (kernel_file
, "rb");
9207 memset (&st
, 0, sizeof (st
));
9209 stat (kernel_file
, &st
);
9211 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
9213 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
9215 if (num_read
!= (size_t) st
.st_size
)
9217 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9224 buf
[st
.st_size
] = 0;
9226 for (int i
= 0; i
< num_devices
; i
++)
9228 kernel_lengths
[i
] = (size_t) st
.st_size
;
9230 kernel_sources
[i
] = buf
;
9235 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9243 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
9245 if (binary_size
> 0)
9247 FILE *fp
= fopen (dst
, "wb");
9250 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
9261 restore_data_t
*init_restore (int argc
, char **argv
)
9263 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
9265 if (data
.restore_disable
== 0)
9267 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
9271 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
9275 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
9284 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9286 int pidbin_len
= -1;
9289 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9291 FILE *fd
= fopen (pidbin
, "rb");
9295 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9297 pidbin
[pidbin_len
] = 0;
9301 char *argv0_r
= strrchr (argv
[0], '/');
9303 char *pidbin_r
= strrchr (pidbin
, '/');
9305 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9307 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9309 if (strcmp (argv0_r
, pidbin_r
) == 0)
9311 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
9318 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9320 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9322 int pidbin2_len
= -1;
9324 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9325 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9327 pidbin
[pidbin_len
] = 0;
9328 pidbin2
[pidbin2_len
] = 0;
9332 if (strcmp (pidbin
, pidbin2
) == 0)
9334 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9347 if (rd
->version_bin
< RESTORE_MIN
)
9349 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9356 memset (rd
, 0, sizeof (restore_data_t
));
9358 rd
->version_bin
= VERSION_BIN
;
9361 rd
->pid
= getpid ();
9363 rd
->pid
= GetCurrentProcessId ();
9366 if (getcwd (rd
->cwd
, 255) == NULL
)
9379 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9381 FILE *fp
= fopen (eff_restore_file
, "rb");
9385 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
9390 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9392 log_error ("ERROR: cannot read %s", eff_restore_file
);
9397 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9399 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9401 for (uint i
= 0; i
< rd
->argc
; i
++)
9403 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9405 log_error ("ERROR: cannot read %s", eff_restore_file
);
9410 size_t len
= strlen (buf
);
9412 if (len
) buf
[len
- 1] = 0;
9414 rd
->argv
[i
] = mystrdup (buf
);
9421 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9423 if (chdir (rd
->cwd
))
9425 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9426 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9427 " https://github.com/philsmd/analyze_hc_restore\n"
9428 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9434 u64
get_lowest_words_done ()
9438 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9440 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9442 if (device_param
->skipped
) continue;
9444 const u64 words_done
= device_param
->words_done
;
9446 if (words_done
< words_cur
) words_cur
= words_done
;
9449 // It's possible that a device's workload isn't finished right after a restore-case.
9450 // In that case, this function would return 0 and overwrite the real restore point
9451 // There's also data.words_cur which is set to rd->words_cur but it changes while
9452 // the attack is running therefore we should stick to rd->words_cur.
9453 // Note that -s influences rd->words_cur we should keep a close look on that.
9455 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9460 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9462 u64 words_cur
= get_lowest_words_done ();
9464 rd
->words_cur
= words_cur
;
9466 FILE *fp
= fopen (new_restore_file
, "wb");
9470 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9475 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9477 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9482 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9484 for (uint i
= 0; i
< rd
->argc
; i
++)
9486 fprintf (fp
, "%s", rd
->argv
[i
]);
9492 fsync (fileno (fp
));
9497 void cycle_restore ()
9499 const char *eff_restore_file
= data
.eff_restore_file
;
9500 const char *new_restore_file
= data
.new_restore_file
;
9502 restore_data_t
*rd
= data
.rd
;
9504 write_restore (new_restore_file
, rd
);
9508 memset (&st
, 0, sizeof(st
));
9510 if (stat (eff_restore_file
, &st
) == 0)
9512 if (unlink (eff_restore_file
))
9514 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9518 if (rename (new_restore_file
, eff_restore_file
))
9520 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9524 void check_checkpoint ()
9526 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9528 u64 words_cur
= get_lowest_words_done ();
9530 if (words_cur
!= data
.checkpoint_cur_words
)
9540 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9544 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9546 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9548 myfree (alias
->device_name
);
9549 myfree (alias
->alias_name
);
9552 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9554 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9556 myfree (entry
->device_name
);
9559 myfree (tuning_db
->alias_buf
);
9560 myfree (tuning_db
->entry_buf
);
9565 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9567 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9569 int num_lines
= count_lines (fp
);
9571 // a bit over-allocated
9573 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9574 tuning_db
->alias_cnt
= 0;
9576 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9577 tuning_db
->entry_cnt
= 0;
9582 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9584 FILE *fp
= fopen (tuning_db_file
, "rb");
9588 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9593 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9599 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9603 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9605 if (line_buf
== NULL
) break;
9609 const int line_len
= in_superchop (line_buf
);
9611 if (line_len
== 0) continue;
9613 if (line_buf
[0] == '#') continue;
9617 char *token_ptr
[7] = { NULL
};
9621 char *next
= strtok (line_buf
, "\t ");
9623 token_ptr
[token_cnt
] = next
;
9627 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9629 token_ptr
[token_cnt
] = next
;
9636 char *device_name
= token_ptr
[0];
9637 char *alias_name
= token_ptr
[1];
9639 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9641 alias
->device_name
= mystrdup (device_name
);
9642 alias
->alias_name
= mystrdup (alias_name
);
9644 tuning_db
->alias_cnt
++;
9646 else if (token_cnt
== 6)
9648 if ((token_ptr
[1][0] != '0') &&
9649 (token_ptr
[1][0] != '1') &&
9650 (token_ptr
[1][0] != '3') &&
9651 (token_ptr
[1][0] != '*'))
9653 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9658 if ((token_ptr
[3][0] != '1') &&
9659 (token_ptr
[3][0] != '2') &&
9660 (token_ptr
[3][0] != '4') &&
9661 (token_ptr
[3][0] != '8') &&
9662 (token_ptr
[3][0] != 'N'))
9664 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9669 char *device_name
= token_ptr
[0];
9671 int attack_mode
= -1;
9673 int vector_width
= -1;
9674 int kernel_accel
= -1;
9675 int kernel_loops
= -1;
9677 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9678 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9679 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9681 if (token_ptr
[4][0] != 'A')
9683 kernel_accel
= atoi (token_ptr
[4]);
9685 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9687 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9697 if (token_ptr
[5][0] != 'A')
9699 kernel_loops
= atoi (token_ptr
[5]);
9701 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9703 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9713 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9715 entry
->device_name
= mystrdup (device_name
);
9716 entry
->attack_mode
= attack_mode
;
9717 entry
->hash_type
= hash_type
;
9718 entry
->vector_width
= vector_width
;
9719 entry
->kernel_accel
= kernel_accel
;
9720 entry
->kernel_loops
= kernel_loops
;
9722 tuning_db
->entry_cnt
++;
9726 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9736 // todo: print loaded 'cnt' message
9738 // sort the database
9740 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9741 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9746 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9748 static tuning_db_entry_t s
;
9750 // first we need to convert all spaces in the device_name to underscore
9752 char *device_name_nospace
= strdup (device_param
->device_name
);
9754 int device_name_length
= strlen (device_name_nospace
);
9758 for (i
= 0; i
< device_name_length
; i
++)
9760 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9763 // find out if there's an alias configured
9765 tuning_db_alias_t a
;
9767 a
.device_name
= device_name_nospace
;
9769 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
);
9771 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9773 // attack-mode 6 and 7 are attack-mode 1 basically
9775 if (attack_mode
== 6) attack_mode
= 1;
9776 if (attack_mode
== 7) attack_mode
= 1;
9778 // bsearch is not ideal but fast enough
9780 s
.device_name
= device_name_nospace
;
9781 s
.attack_mode
= attack_mode
;
9782 s
.hash_type
= hash_type
;
9784 tuning_db_entry_t
*entry
= NULL
;
9786 // this will produce all 2^3 combinations required
9788 for (i
= 0; i
< 8; i
++)
9790 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9791 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9792 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9794 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9796 if (entry
!= NULL
) break;
9798 // in non-wildcard mode do some additional checks:
9802 // in case we have an alias-name
9804 if (alias_name
!= NULL
)
9806 s
.device_name
= alias_name
;
9808 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9810 if (entry
!= NULL
) break;
9813 // or by device type
9815 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9817 s
.device_name
= "DEVICE_TYPE_CPU";
9819 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9821 s
.device_name
= "DEVICE_TYPE_GPU";
9823 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9825 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9828 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9830 if (entry
!= NULL
) break;
9834 // free converted device_name
9836 myfree (device_name_nospace
);
9845 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9847 u8 tmp
[256] = { 0 };
9849 if (salt_len
> sizeof (tmp
))
9854 memcpy (tmp
, in
, salt_len
);
9856 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9858 if ((salt_len
% 2) == 0)
9860 u32 new_salt_len
= salt_len
/ 2;
9862 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9867 tmp
[i
] = hex_convert (p1
) << 0;
9868 tmp
[i
] |= hex_convert (p0
) << 4;
9871 salt_len
= new_salt_len
;
9878 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9880 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9883 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9885 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9889 u32
*tmp_uint
= (u32
*) tmp
;
9891 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9892 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9893 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9894 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9895 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9896 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9897 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9898 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9899 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9900 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9902 salt_len
= salt_len
* 2;
9910 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9912 lowercase (tmp
, salt_len
);
9915 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9917 uppercase (tmp
, salt_len
);
9922 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9927 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9932 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9934 u32
*tmp_uint
= (uint
*) tmp
;
9940 for (u32 i
= 0; i
< max
; i
++)
9942 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9945 // Important: we may need to increase the length of memcpy since
9946 // we don't want to "loose" some swapped bytes (could happen if
9947 // they do not perfectly fit in the 4-byte blocks)
9948 // Memcpy does always copy the bytes in the BE order, but since
9949 // we swapped them, some important bytes could be in positions
9950 // we normally skip with the original len
9952 if (len
% 4) len
+= 4 - (len
% 4);
9955 memcpy (out
, tmp
, len
);
9960 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9962 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9964 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9966 u32
*digest
= (u32
*) hash_buf
->digest
;
9968 salt_t
*salt
= hash_buf
->salt
;
9970 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9972 char *iter_pos
= input_buf
+ 4;
9974 salt
->salt_iter
= 1 << atoi (iter_pos
);
9976 char *salt_pos
= strchr (iter_pos
, '$');
9978 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9984 salt
->salt_len
= salt_len
;
9986 u8 tmp_buf
[100] = { 0 };
9988 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9990 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9992 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9994 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9995 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9996 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9997 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9999 char *hash_pos
= salt_pos
+ 22;
10001 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10003 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
10005 memcpy (digest
, tmp_buf
, 24);
10007 digest
[0] = byte_swap_32 (digest
[0]);
10008 digest
[1] = byte_swap_32 (digest
[1]);
10009 digest
[2] = byte_swap_32 (digest
[2]);
10010 digest
[3] = byte_swap_32 (digest
[3]);
10011 digest
[4] = byte_swap_32 (digest
[4]);
10012 digest
[5] = byte_swap_32 (digest
[5]);
10014 digest
[5] &= ~0xff; // its just 23 not 24 !
10016 return (PARSER_OK
);
10019 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10021 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
10023 u32
*digest
= (u32
*) hash_buf
->digest
;
10025 u8 tmp_buf
[100] = { 0 };
10027 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
10029 memcpy (digest
, tmp_buf
, 32);
10031 digest
[0] = byte_swap_32 (digest
[0]);
10032 digest
[1] = byte_swap_32 (digest
[1]);
10033 digest
[2] = byte_swap_32 (digest
[2]);
10034 digest
[3] = byte_swap_32 (digest
[3]);
10035 digest
[4] = byte_swap_32 (digest
[4]);
10036 digest
[5] = byte_swap_32 (digest
[5]);
10037 digest
[6] = byte_swap_32 (digest
[6]);
10038 digest
[7] = byte_swap_32 (digest
[7]);
10040 digest
[0] -= SHA256M_A
;
10041 digest
[1] -= SHA256M_B
;
10042 digest
[2] -= SHA256M_C
;
10043 digest
[3] -= SHA256M_D
;
10044 digest
[4] -= SHA256M_E
;
10045 digest
[5] -= SHA256M_F
;
10046 digest
[6] -= SHA256M_G
;
10047 digest
[7] -= SHA256M_H
;
10049 return (PARSER_OK
);
10052 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10054 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
10056 u32
*digest
= (u32
*) hash_buf
->digest
;
10058 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10059 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10061 digest
[0] = byte_swap_32 (digest
[0]);
10062 digest
[1] = byte_swap_32 (digest
[1]);
10066 IP (digest
[0], digest
[1], tt
);
10068 digest
[0] = digest
[0];
10069 digest
[1] = digest
[1];
10073 return (PARSER_OK
);
10076 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10078 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
10080 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
10082 u32
*digest
= (u32
*) hash_buf
->digest
;
10084 salt_t
*salt
= hash_buf
->salt
;
10086 char *hash_pos
= input_buf
+ 10;
10088 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10089 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10090 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10091 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10092 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10094 digest
[0] -= SHA1M_A
;
10095 digest
[1] -= SHA1M_B
;
10096 digest
[2] -= SHA1M_C
;
10097 digest
[3] -= SHA1M_D
;
10098 digest
[4] -= SHA1M_E
;
10100 uint salt_len
= 10;
10102 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10104 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10106 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10108 salt
->salt_len
= salt_len
;
10110 return (PARSER_OK
);
10113 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10115 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
10117 u32
*digest
= (u32
*) hash_buf
->digest
;
10119 salt_t
*salt
= hash_buf
->salt
;
10121 char *hash_pos
= input_buf
+ 8;
10123 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10124 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10125 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10126 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10127 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10129 digest
[0] -= SHA1M_A
;
10130 digest
[1] -= SHA1M_B
;
10131 digest
[2] -= SHA1M_C
;
10132 digest
[3] -= SHA1M_D
;
10133 digest
[4] -= SHA1M_E
;
10137 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10139 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10141 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10143 salt
->salt_len
= salt_len
;
10145 return (PARSER_OK
);
10148 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10150 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
10152 u64
*digest
= (u64
*) hash_buf
->digest
;
10154 salt_t
*salt
= hash_buf
->salt
;
10156 char *hash_pos
= input_buf
+ 8;
10158 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
10159 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
10160 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
10161 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
10162 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
10163 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
10164 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
10165 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
10167 digest
[0] -= SHA512M_A
;
10168 digest
[1] -= SHA512M_B
;
10169 digest
[2] -= SHA512M_C
;
10170 digest
[3] -= SHA512M_D
;
10171 digest
[4] -= SHA512M_E
;
10172 digest
[5] -= SHA512M_F
;
10173 digest
[6] -= SHA512M_G
;
10174 digest
[7] -= SHA512M_H
;
10178 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10180 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10182 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10184 salt
->salt_len
= salt_len
;
10186 return (PARSER_OK
);
10189 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10191 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10193 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
10197 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
10200 u32
*digest
= (u32
*) hash_buf
->digest
;
10202 salt_t
*salt
= hash_buf
->salt
;
10204 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10205 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10206 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10207 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10209 digest
[0] = byte_swap_32 (digest
[0]);
10210 digest
[1] = byte_swap_32 (digest
[1]);
10211 digest
[2] = byte_swap_32 (digest
[2]);
10212 digest
[3] = byte_swap_32 (digest
[3]);
10214 digest
[0] -= MD5M_A
;
10215 digest
[1] -= MD5M_B
;
10216 digest
[2] -= MD5M_C
;
10217 digest
[3] -= MD5M_D
;
10219 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10221 uint salt_len
= input_len
- 32 - 1;
10223 char *salt_buf
= input_buf
+ 32 + 1;
10225 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10227 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10229 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10231 salt
->salt_len
= salt_len
;
10233 return (PARSER_OK
);
10236 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10238 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10240 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
10244 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
10249 char clean_input_buf
[32] = { 0 };
10251 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
10252 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
10254 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
10258 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
10264 clean_input_buf
[k
] = input_buf
[i
];
10272 u32
*digest
= (u32
*) hash_buf
->digest
;
10274 salt_t
*salt
= hash_buf
->salt
;
10276 u32 a
, b
, c
, d
, e
, f
;
10278 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10279 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10280 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10281 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10282 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10283 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10285 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10286 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10288 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10289 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10290 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10291 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10292 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10293 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10295 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10296 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10298 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10299 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10300 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10301 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10302 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10303 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10305 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10306 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10308 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10309 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10310 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10311 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10312 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10313 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10315 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10316 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10318 digest
[0] = byte_swap_32 (digest
[0]);
10319 digest
[1] = byte_swap_32 (digest
[1]);
10320 digest
[2] = byte_swap_32 (digest
[2]);
10321 digest
[3] = byte_swap_32 (digest
[3]);
10323 digest
[0] -= MD5M_A
;
10324 digest
[1] -= MD5M_B
;
10325 digest
[2] -= MD5M_C
;
10326 digest
[3] -= MD5M_D
;
10328 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10330 uint salt_len
= input_len
- 30 - 1;
10332 char *salt_buf
= input_buf
+ 30 + 1;
10334 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10336 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10338 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10339 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10341 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10343 salt
->salt_len
= salt_len
;
10345 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10347 salt
->salt_len
+= 22;
10349 return (PARSER_OK
);
10352 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10354 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10356 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10360 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10363 u32
*digest
= (u32
*) hash_buf
->digest
;
10365 salt_t
*salt
= hash_buf
->salt
;
10367 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10368 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10369 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10370 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10371 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10373 digest
[0] -= SHA1M_A
;
10374 digest
[1] -= SHA1M_B
;
10375 digest
[2] -= SHA1M_C
;
10376 digest
[3] -= SHA1M_D
;
10377 digest
[4] -= SHA1M_E
;
10379 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10381 uint salt_len
= input_len
- 40 - 1;
10383 char *salt_buf
= input_buf
+ 40 + 1;
10385 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10387 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10389 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10391 salt
->salt_len
= salt_len
;
10393 return (PARSER_OK
);
10396 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10398 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10400 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10404 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10407 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10409 char *iter_pos
= input_buf
+ 6;
10411 salt_t
*salt
= hash_buf
->salt
;
10413 uint iter
= atoi (iter_pos
);
10417 iter
= ROUNDS_DCC2
;
10420 salt
->salt_iter
= iter
- 1;
10422 char *salt_pos
= strchr (iter_pos
, '#');
10424 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10428 char *digest_pos
= strchr (salt_pos
, '#');
10430 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10434 uint salt_len
= digest_pos
- salt_pos
- 1;
10436 u32
*digest
= (u32
*) hash_buf
->digest
;
10438 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10439 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10440 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10441 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10443 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10445 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10447 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10449 salt
->salt_len
= salt_len
;
10451 return (PARSER_OK
);
10454 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10456 u32
*digest
= (u32
*) hash_buf
->digest
;
10458 salt_t
*salt
= hash_buf
->salt
;
10460 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10464 memcpy (&in
, input_buf
, input_len
);
10466 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10468 memcpy (digest
, in
.keymic
, 16);
10471 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10472 The phrase "Pairwise key expansion"
10473 Access Point Address (referred to as Authenticator Address AA)
10474 Supplicant Address (referred to as Supplicant Address SA)
10475 Access Point Nonce (referred to as Authenticator Anonce)
10476 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10479 uint salt_len
= strlen (in
.essid
);
10483 log_info ("WARNING: the length of the ESSID is too long. The hccap file may be invalid or corrupted");
10485 return (PARSER_SALT_LENGTH
);
10488 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10490 salt
->salt_len
= salt_len
;
10492 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10494 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10496 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10498 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10500 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10501 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10505 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10506 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10509 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10511 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10512 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10516 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10517 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10520 for (int i
= 0; i
< 25; i
++)
10522 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10525 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10526 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10527 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10528 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10530 wpa
->keyver
= in
.keyver
;
10532 if (wpa
->keyver
> 255)
10534 log_info ("ATTENTION!");
10535 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10536 log_info (" This could be due to a recent aircrack-ng bug.");
10537 log_info (" The key version was automatically reset to a reasonable value.");
10540 wpa
->keyver
&= 0xff;
10543 wpa
->eapol_size
= in
.eapol_size
;
10545 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10547 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10549 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10551 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10553 if (wpa
->keyver
== 1)
10559 digest
[0] = byte_swap_32 (digest
[0]);
10560 digest
[1] = byte_swap_32 (digest
[1]);
10561 digest
[2] = byte_swap_32 (digest
[2]);
10562 digest
[3] = byte_swap_32 (digest
[3]);
10564 for (int i
= 0; i
< 64; i
++)
10566 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10570 uint32_t *p0
= (uint32_t *) in
.essid
;
10574 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10575 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10577 salt
->salt_buf
[10] = c0
;
10578 salt
->salt_buf
[11] = c1
;
10580 return (PARSER_OK
);
10583 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10585 u32
*digest
= (u32
*) hash_buf
->digest
;
10587 salt_t
*salt
= hash_buf
->salt
;
10589 if (input_len
== 0)
10591 log_error ("Password Safe v2 container not specified");
10596 FILE *fp
= fopen (input_buf
, "rb");
10600 log_error ("%s: %s", input_buf
, strerror (errno
));
10607 memset (&buf
, 0, sizeof (psafe2_hdr
));
10609 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10613 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10615 salt
->salt_buf
[0] = buf
.random
[0];
10616 salt
->salt_buf
[1] = buf
.random
[1];
10618 salt
->salt_len
= 8;
10619 salt
->salt_iter
= 1000;
10621 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10622 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10623 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10624 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10625 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10627 return (PARSER_OK
);
10630 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10632 u32
*digest
= (u32
*) hash_buf
->digest
;
10634 salt_t
*salt
= hash_buf
->salt
;
10636 if (input_len
== 0)
10638 log_error (".psafe3 not specified");
10643 FILE *fp
= fopen (input_buf
, "rb");
10647 log_error ("%s: %s", input_buf
, strerror (errno
));
10654 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10658 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10660 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10662 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10664 salt
->salt_iter
= in
.iterations
+ 1;
10666 salt
->salt_buf
[0] = in
.salt_buf
[0];
10667 salt
->salt_buf
[1] = in
.salt_buf
[1];
10668 salt
->salt_buf
[2] = in
.salt_buf
[2];
10669 salt
->salt_buf
[3] = in
.salt_buf
[3];
10670 salt
->salt_buf
[4] = in
.salt_buf
[4];
10671 salt
->salt_buf
[5] = in
.salt_buf
[5];
10672 salt
->salt_buf
[6] = in
.salt_buf
[6];
10673 salt
->salt_buf
[7] = in
.salt_buf
[7];
10675 salt
->salt_len
= 32;
10677 digest
[0] = in
.hash_buf
[0];
10678 digest
[1] = in
.hash_buf
[1];
10679 digest
[2] = in
.hash_buf
[2];
10680 digest
[3] = in
.hash_buf
[3];
10681 digest
[4] = in
.hash_buf
[4];
10682 digest
[5] = in
.hash_buf
[5];
10683 digest
[6] = in
.hash_buf
[6];
10684 digest
[7] = in
.hash_buf
[7];
10686 digest
[0] = byte_swap_32 (digest
[0]);
10687 digest
[1] = byte_swap_32 (digest
[1]);
10688 digest
[2] = byte_swap_32 (digest
[2]);
10689 digest
[3] = byte_swap_32 (digest
[3]);
10690 digest
[4] = byte_swap_32 (digest
[4]);
10691 digest
[5] = byte_swap_32 (digest
[5]);
10692 digest
[6] = byte_swap_32 (digest
[6]);
10693 digest
[7] = byte_swap_32 (digest
[7]);
10695 return (PARSER_OK
);
10698 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10700 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10702 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10704 u32
*digest
= (u32
*) hash_buf
->digest
;
10706 salt_t
*salt
= hash_buf
->salt
;
10708 char *iter_pos
= input_buf
+ 3;
10710 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10712 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10714 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10716 salt
->salt_iter
= salt_iter
;
10718 char *salt_pos
= iter_pos
+ 1;
10722 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10724 salt
->salt_len
= salt_len
;
10726 char *hash_pos
= salt_pos
+ salt_len
;
10728 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10730 return (PARSER_OK
);
10733 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10735 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10737 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10739 u32
*digest
= (u32
*) hash_buf
->digest
;
10741 salt_t
*salt
= hash_buf
->salt
;
10743 char *salt_pos
= input_buf
+ 3;
10745 uint iterations_len
= 0;
10747 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10751 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10753 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10754 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10758 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10762 iterations_len
+= 8;
10766 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10769 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10771 char *hash_pos
= strchr (salt_pos
, '$');
10773 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10775 uint salt_len
= hash_pos
- salt_pos
;
10777 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10779 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10781 salt
->salt_len
= salt_len
;
10785 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10787 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10789 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10791 return (PARSER_OK
);
10794 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10796 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10798 u32
*digest
= (u32
*) hash_buf
->digest
;
10800 salt_t
*salt
= hash_buf
->salt
;
10802 char *salt_pos
= input_buf
+ 6;
10804 uint iterations_len
= 0;
10806 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10810 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10812 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10813 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10817 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10821 iterations_len
+= 8;
10825 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10828 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10830 char *hash_pos
= strchr (salt_pos
, '$');
10832 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10834 uint salt_len
= hash_pos
- salt_pos
;
10836 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10838 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10840 salt
->salt_len
= salt_len
;
10844 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10846 return (PARSER_OK
);
10849 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10851 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10853 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10855 u32
*digest
= (u32
*) hash_buf
->digest
;
10857 salt_t
*salt
= hash_buf
->salt
;
10859 char *salt_pos
= input_buf
+ 14;
10861 char *hash_pos
= strchr (salt_pos
, '*');
10863 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10867 uint salt_len
= hash_pos
- salt_pos
- 1;
10869 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10871 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10873 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10875 salt
->salt_len
= salt_len
;
10877 u8 tmp_buf
[100] = { 0 };
10879 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10881 memcpy (digest
, tmp_buf
, 20);
10883 digest
[0] = byte_swap_32 (digest
[0]);
10884 digest
[1] = byte_swap_32 (digest
[1]);
10885 digest
[2] = byte_swap_32 (digest
[2]);
10886 digest
[3] = byte_swap_32 (digest
[3]);
10887 digest
[4] = byte_swap_32 (digest
[4]);
10889 digest
[0] -= SHA1M_A
;
10890 digest
[1] -= SHA1M_B
;
10891 digest
[2] -= SHA1M_C
;
10892 digest
[3] -= SHA1M_D
;
10893 digest
[4] -= SHA1M_E
;
10895 return (PARSER_OK
);
10898 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10900 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10902 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10904 if (c12
& 3) return (PARSER_HASH_VALUE
);
10906 u32
*digest
= (u32
*) hash_buf
->digest
;
10908 salt_t
*salt
= hash_buf
->salt
;
10910 // for ascii_digest
10911 salt
->salt_sign
[0] = input_buf
[0];
10912 salt
->salt_sign
[1] = input_buf
[1];
10914 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10915 | itoa64_to_int (input_buf
[1]) << 6;
10917 salt
->salt_len
= 2;
10919 u8 tmp_buf
[100] = { 0 };
10921 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10923 memcpy (digest
, tmp_buf
, 8);
10927 IP (digest
[0], digest
[1], tt
);
10932 return (PARSER_OK
);
10935 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10937 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10939 u32
*digest
= (u32
*) hash_buf
->digest
;
10941 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10942 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10943 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10944 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10946 digest
[0] = byte_swap_32 (digest
[0]);
10947 digest
[1] = byte_swap_32 (digest
[1]);
10948 digest
[2] = byte_swap_32 (digest
[2]);
10949 digest
[3] = byte_swap_32 (digest
[3]);
10951 digest
[0] -= MD4M_A
;
10952 digest
[1] -= MD4M_B
;
10953 digest
[2] -= MD4M_C
;
10954 digest
[3] -= MD4M_D
;
10956 return (PARSER_OK
);
10959 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10961 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10963 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10967 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10970 u32
*digest
= (u32
*) hash_buf
->digest
;
10972 salt_t
*salt
= hash_buf
->salt
;
10974 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10975 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10976 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10977 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10979 digest
[0] = byte_swap_32 (digest
[0]);
10980 digest
[1] = byte_swap_32 (digest
[1]);
10981 digest
[2] = byte_swap_32 (digest
[2]);
10982 digest
[3] = byte_swap_32 (digest
[3]);
10984 digest
[0] -= MD4M_A
;
10985 digest
[1] -= MD4M_B
;
10986 digest
[2] -= MD4M_C
;
10987 digest
[3] -= MD4M_D
;
10989 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10991 uint salt_len
= input_len
- 32 - 1;
10993 char *salt_buf
= input_buf
+ 32 + 1;
10995 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10997 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10999 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11001 salt
->salt_len
= salt_len
;
11003 return (PARSER_OK
);
11006 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11008 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
11010 u32
*digest
= (u32
*) hash_buf
->digest
;
11012 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11013 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11014 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11015 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11017 digest
[0] = byte_swap_32 (digest
[0]);
11018 digest
[1] = byte_swap_32 (digest
[1]);
11019 digest
[2] = byte_swap_32 (digest
[2]);
11020 digest
[3] = byte_swap_32 (digest
[3]);
11022 digest
[0] -= MD5M_A
;
11023 digest
[1] -= MD5M_B
;
11024 digest
[2] -= MD5M_C
;
11025 digest
[3] -= MD5M_D
;
11027 return (PARSER_OK
);
11030 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11032 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
11034 u32
*digest
= (u32
*) hash_buf
->digest
;
11036 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
11037 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
11041 digest
[0] = byte_swap_32 (digest
[0]);
11042 digest
[1] = byte_swap_32 (digest
[1]);
11044 return (PARSER_OK
);
11047 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11049 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11051 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
11055 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
11058 u32
*digest
= (u32
*) hash_buf
->digest
;
11060 salt_t
*salt
= hash_buf
->salt
;
11062 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11063 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11064 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11065 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11067 digest
[0] = byte_swap_32 (digest
[0]);
11068 digest
[1] = byte_swap_32 (digest
[1]);
11069 digest
[2] = byte_swap_32 (digest
[2]);
11070 digest
[3] = byte_swap_32 (digest
[3]);
11072 digest
[0] -= MD5M_A
;
11073 digest
[1] -= MD5M_B
;
11074 digest
[2] -= MD5M_C
;
11075 digest
[3] -= MD5M_D
;
11077 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11079 uint salt_len
= input_len
- 32 - 1;
11081 char *salt_buf
= input_buf
+ 32 + 1;
11083 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11085 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11087 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11089 salt
->salt_len
= salt_len
;
11091 return (PARSER_OK
);
11094 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11096 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
11098 u32
*digest
= (u32
*) hash_buf
->digest
;
11100 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11101 | itoa64_to_int (input_buf
[ 1]) << 6
11102 | itoa64_to_int (input_buf
[ 2]) << 12
11103 | itoa64_to_int (input_buf
[ 3]) << 18;
11104 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11105 | itoa64_to_int (input_buf
[ 5]) << 6
11106 | itoa64_to_int (input_buf
[ 6]) << 12
11107 | itoa64_to_int (input_buf
[ 7]) << 18;
11108 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11109 | itoa64_to_int (input_buf
[ 9]) << 6
11110 | itoa64_to_int (input_buf
[10]) << 12
11111 | itoa64_to_int (input_buf
[11]) << 18;
11112 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11113 | itoa64_to_int (input_buf
[13]) << 6
11114 | itoa64_to_int (input_buf
[14]) << 12
11115 | itoa64_to_int (input_buf
[15]) << 18;
11117 digest
[0] -= MD5M_A
;
11118 digest
[1] -= MD5M_B
;
11119 digest
[2] -= MD5M_C
;
11120 digest
[3] -= MD5M_D
;
11122 digest
[0] &= 0x00ffffff;
11123 digest
[1] &= 0x00ffffff;
11124 digest
[2] &= 0x00ffffff;
11125 digest
[3] &= 0x00ffffff;
11127 return (PARSER_OK
);
11130 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11132 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11134 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
11138 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
11141 u32
*digest
= (u32
*) hash_buf
->digest
;
11143 salt_t
*salt
= hash_buf
->salt
;
11145 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11146 | itoa64_to_int (input_buf
[ 1]) << 6
11147 | itoa64_to_int (input_buf
[ 2]) << 12
11148 | itoa64_to_int (input_buf
[ 3]) << 18;
11149 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11150 | itoa64_to_int (input_buf
[ 5]) << 6
11151 | itoa64_to_int (input_buf
[ 6]) << 12
11152 | itoa64_to_int (input_buf
[ 7]) << 18;
11153 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11154 | itoa64_to_int (input_buf
[ 9]) << 6
11155 | itoa64_to_int (input_buf
[10]) << 12
11156 | itoa64_to_int (input_buf
[11]) << 18;
11157 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11158 | itoa64_to_int (input_buf
[13]) << 6
11159 | itoa64_to_int (input_buf
[14]) << 12
11160 | itoa64_to_int (input_buf
[15]) << 18;
11162 digest
[0] -= MD5M_A
;
11163 digest
[1] -= MD5M_B
;
11164 digest
[2] -= MD5M_C
;
11165 digest
[3] -= MD5M_D
;
11167 digest
[0] &= 0x00ffffff;
11168 digest
[1] &= 0x00ffffff;
11169 digest
[2] &= 0x00ffffff;
11170 digest
[3] &= 0x00ffffff;
11172 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11174 uint salt_len
= input_len
- 16 - 1;
11176 char *salt_buf
= input_buf
+ 16 + 1;
11178 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11180 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11182 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11184 salt
->salt_len
= salt_len
;
11186 return (PARSER_OK
);
11189 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
11191 key
[0] = (nthash
[0] >> 0);
11192 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
11193 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
11194 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
11195 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
11196 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
11197 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
11198 key
[7] = (nthash
[6] << 1);
11210 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11212 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
11214 u32
*digest
= (u32
*) hash_buf
->digest
;
11216 salt_t
*salt
= hash_buf
->salt
;
11218 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11224 char *user_pos
= input_buf
;
11226 char *unused_pos
= strchr (user_pos
, ':');
11228 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11230 uint user_len
= unused_pos
- user_pos
;
11232 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11236 char *domain_pos
= strchr (unused_pos
, ':');
11238 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11240 uint unused_len
= domain_pos
- unused_pos
;
11242 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11246 char *srvchall_pos
= strchr (domain_pos
, ':');
11248 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11250 uint domain_len
= srvchall_pos
- domain_pos
;
11252 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11256 char *hash_pos
= strchr (srvchall_pos
, ':');
11258 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11260 uint srvchall_len
= hash_pos
- srvchall_pos
;
11262 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
11266 char *clichall_pos
= strchr (hash_pos
, ':');
11268 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11270 uint hash_len
= clichall_pos
- hash_pos
;
11272 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11276 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11278 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11281 * store some data for later use
11284 netntlm
->user_len
= user_len
* 2;
11285 netntlm
->domain_len
= domain_len
* 2;
11286 netntlm
->srvchall_len
= srvchall_len
/ 2;
11287 netntlm
->clichall_len
= clichall_len
/ 2;
11289 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11290 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11293 * handle username and domainname
11296 for (uint i
= 0; i
< user_len
; i
++)
11298 *userdomain_ptr
++ = user_pos
[i
];
11299 *userdomain_ptr
++ = 0;
11302 for (uint i
= 0; i
< domain_len
; i
++)
11304 *userdomain_ptr
++ = domain_pos
[i
];
11305 *userdomain_ptr
++ = 0;
11309 * handle server challenge encoding
11312 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11314 const char p0
= srvchall_pos
[i
+ 0];
11315 const char p1
= srvchall_pos
[i
+ 1];
11317 *chall_ptr
++ = hex_convert (p1
) << 0
11318 | hex_convert (p0
) << 4;
11322 * handle client challenge encoding
11325 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11327 const char p0
= clichall_pos
[i
+ 0];
11328 const char p1
= clichall_pos
[i
+ 1];
11330 *chall_ptr
++ = hex_convert (p1
) << 0
11331 | hex_convert (p0
) << 4;
11338 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11340 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11342 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11344 salt
->salt_len
= salt_len
;
11346 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11347 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11348 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11349 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11351 digest
[0] = byte_swap_32 (digest
[0]);
11352 digest
[1] = byte_swap_32 (digest
[1]);
11353 digest
[2] = byte_swap_32 (digest
[2]);
11354 digest
[3] = byte_swap_32 (digest
[3]);
11356 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11358 uint digest_tmp
[2] = { 0 };
11360 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11361 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11363 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11364 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11366 /* special case 2: ESS */
11368 if (srvchall_len
== 48)
11370 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11372 uint w
[16] = { 0 };
11374 w
[ 0] = netntlm
->chall_buf
[6];
11375 w
[ 1] = netntlm
->chall_buf
[7];
11376 w
[ 2] = netntlm
->chall_buf
[0];
11377 w
[ 3] = netntlm
->chall_buf
[1];
11381 uint dgst
[4] = { 0 };
11390 salt
->salt_buf
[0] = dgst
[0];
11391 salt
->salt_buf
[1] = dgst
[1];
11395 /* precompute netntlmv1 exploit start */
11397 for (uint i
= 0; i
< 0x10000; i
++)
11399 uint key_md4
[2] = { i
, 0 };
11400 uint key_des
[2] = { 0, 0 };
11402 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11404 uint Kc
[16] = { 0 };
11405 uint Kd
[16] = { 0 };
11407 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11409 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11411 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11413 if (data3
[0] != digest_tmp
[0]) continue;
11414 if (data3
[1] != digest_tmp
[1]) continue;
11416 salt
->salt_buf
[2] = i
;
11418 salt
->salt_len
= 24;
11423 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11424 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11426 /* precompute netntlmv1 exploit stop */
11430 IP (digest
[0], digest
[1], tt
);
11431 IP (digest
[2], digest
[3], tt
);
11433 digest
[0] = rotr32 (digest
[0], 29);
11434 digest
[1] = rotr32 (digest
[1], 29);
11435 digest
[2] = rotr32 (digest
[2], 29);
11436 digest
[3] = rotr32 (digest
[3], 29);
11438 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11440 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11441 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11443 return (PARSER_OK
);
11446 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11448 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11450 u32
*digest
= (u32
*) hash_buf
->digest
;
11452 salt_t
*salt
= hash_buf
->salt
;
11454 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11460 char *user_pos
= input_buf
;
11462 char *unused_pos
= strchr (user_pos
, ':');
11464 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11466 uint user_len
= unused_pos
- user_pos
;
11468 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11472 char *domain_pos
= strchr (unused_pos
, ':');
11474 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11476 uint unused_len
= domain_pos
- unused_pos
;
11478 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11482 char *srvchall_pos
= strchr (domain_pos
, ':');
11484 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11486 uint domain_len
= srvchall_pos
- domain_pos
;
11488 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11492 char *hash_pos
= strchr (srvchall_pos
, ':');
11494 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11496 uint srvchall_len
= hash_pos
- srvchall_pos
;
11498 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11502 char *clichall_pos
= strchr (hash_pos
, ':');
11504 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11506 uint hash_len
= clichall_pos
- hash_pos
;
11508 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11512 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11514 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11516 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11519 * store some data for later use
11522 netntlm
->user_len
= user_len
* 2;
11523 netntlm
->domain_len
= domain_len
* 2;
11524 netntlm
->srvchall_len
= srvchall_len
/ 2;
11525 netntlm
->clichall_len
= clichall_len
/ 2;
11527 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11528 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11531 * handle username and domainname
11534 for (uint i
= 0; i
< user_len
; i
++)
11536 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11537 *userdomain_ptr
++ = 0;
11540 for (uint i
= 0; i
< domain_len
; i
++)
11542 *userdomain_ptr
++ = domain_pos
[i
];
11543 *userdomain_ptr
++ = 0;
11546 *userdomain_ptr
++ = 0x80;
11549 * handle server challenge encoding
11552 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11554 const char p0
= srvchall_pos
[i
+ 0];
11555 const char p1
= srvchall_pos
[i
+ 1];
11557 *chall_ptr
++ = hex_convert (p1
) << 0
11558 | hex_convert (p0
) << 4;
11562 * handle client challenge encoding
11565 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11567 const char p0
= clichall_pos
[i
+ 0];
11568 const char p1
= clichall_pos
[i
+ 1];
11570 *chall_ptr
++ = hex_convert (p1
) << 0
11571 | hex_convert (p0
) << 4;
11574 *chall_ptr
++ = 0x80;
11577 * handle hash itself
11580 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11581 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11582 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11583 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11585 digest
[0] = byte_swap_32 (digest
[0]);
11586 digest
[1] = byte_swap_32 (digest
[1]);
11587 digest
[2] = byte_swap_32 (digest
[2]);
11588 digest
[3] = byte_swap_32 (digest
[3]);
11591 * reuse challange data as salt_buf, its the buffer that is most likely unique
11594 salt
->salt_buf
[0] = 0;
11595 salt
->salt_buf
[1] = 0;
11596 salt
->salt_buf
[2] = 0;
11597 salt
->salt_buf
[3] = 0;
11598 salt
->salt_buf
[4] = 0;
11599 salt
->salt_buf
[5] = 0;
11600 salt
->salt_buf
[6] = 0;
11601 salt
->salt_buf
[7] = 0;
11605 uptr
= (uint
*) netntlm
->userdomain_buf
;
11607 for (uint i
= 0; i
< 16; i
+= 16)
11609 md5_64 (uptr
, salt
->salt_buf
);
11612 uptr
= (uint
*) netntlm
->chall_buf
;
11614 for (uint i
= 0; i
< 256; i
+= 16)
11616 md5_64 (uptr
, salt
->salt_buf
);
11619 salt
->salt_len
= 16;
11621 return (PARSER_OK
);
11624 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11626 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11628 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11632 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11635 u32
*digest
= (u32
*) hash_buf
->digest
;
11637 salt_t
*salt
= hash_buf
->salt
;
11639 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11640 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11641 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11642 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11644 digest
[0] = byte_swap_32 (digest
[0]);
11645 digest
[1] = byte_swap_32 (digest
[1]);
11646 digest
[2] = byte_swap_32 (digest
[2]);
11647 digest
[3] = byte_swap_32 (digest
[3]);
11649 digest
[0] -= MD5M_A
;
11650 digest
[1] -= MD5M_B
;
11651 digest
[2] -= MD5M_C
;
11652 digest
[3] -= MD5M_D
;
11654 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11656 uint salt_len
= input_len
- 32 - 1;
11658 char *salt_buf
= input_buf
+ 32 + 1;
11660 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11662 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11664 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11666 salt
->salt_len
= salt_len
;
11668 return (PARSER_OK
);
11671 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11673 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11675 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11679 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11682 u32
*digest
= (u32
*) hash_buf
->digest
;
11684 salt_t
*salt
= hash_buf
->salt
;
11686 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11687 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11688 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11689 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11691 digest
[0] = byte_swap_32 (digest
[0]);
11692 digest
[1] = byte_swap_32 (digest
[1]);
11693 digest
[2] = byte_swap_32 (digest
[2]);
11694 digest
[3] = byte_swap_32 (digest
[3]);
11696 digest
[0] -= MD5M_A
;
11697 digest
[1] -= MD5M_B
;
11698 digest
[2] -= MD5M_C
;
11699 digest
[3] -= MD5M_D
;
11701 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11703 uint salt_len
= input_len
- 32 - 1;
11705 char *salt_buf
= input_buf
+ 32 + 1;
11707 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11709 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11711 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11713 salt
->salt_len
= salt_len
;
11715 return (PARSER_OK
);
11718 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11720 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11722 u32
*digest
= (u32
*) hash_buf
->digest
;
11724 salt_t
*salt
= hash_buf
->salt
;
11726 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11727 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11728 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11729 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11731 digest
[0] = byte_swap_32 (digest
[0]);
11732 digest
[1] = byte_swap_32 (digest
[1]);
11733 digest
[2] = byte_swap_32 (digest
[2]);
11734 digest
[3] = byte_swap_32 (digest
[3]);
11736 digest
[0] -= MD5M_A
;
11737 digest
[1] -= MD5M_B
;
11738 digest
[2] -= MD5M_C
;
11739 digest
[3] -= MD5M_D
;
11742 * This is a virtual salt. While the algorithm is basically not salted
11743 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11744 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11747 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11749 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11751 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11753 salt
->salt_len
= salt_len
;
11755 return (PARSER_OK
);
11758 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11760 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11762 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11766 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11769 u32
*digest
= (u32
*) hash_buf
->digest
;
11771 salt_t
*salt
= hash_buf
->salt
;
11773 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11774 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11775 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11776 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11778 digest
[0] = byte_swap_32 (digest
[0]);
11779 digest
[1] = byte_swap_32 (digest
[1]);
11780 digest
[2] = byte_swap_32 (digest
[2]);
11781 digest
[3] = byte_swap_32 (digest
[3]);
11783 digest
[0] -= MD5M_A
;
11784 digest
[1] -= MD5M_B
;
11785 digest
[2] -= MD5M_C
;
11786 digest
[3] -= MD5M_D
;
11788 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11790 uint salt_len
= input_len
- 32 - 1;
11792 char *salt_buf
= input_buf
+ 32 + 1;
11794 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11796 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11798 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11800 salt
->salt_len
= salt_len
;
11802 return (PARSER_OK
);
11805 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11807 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11809 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11813 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11816 u32
*digest
= (u32
*) hash_buf
->digest
;
11818 salt_t
*salt
= hash_buf
->salt
;
11820 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11821 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11822 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11823 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11825 digest
[0] = byte_swap_32 (digest
[0]);
11826 digest
[1] = byte_swap_32 (digest
[1]);
11827 digest
[2] = byte_swap_32 (digest
[2]);
11828 digest
[3] = byte_swap_32 (digest
[3]);
11830 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11832 uint salt_len
= input_len
- 32 - 1;
11834 char *salt_buf
= input_buf
+ 32 + 1;
11836 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11838 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11840 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11842 salt
->salt_len
= salt_len
;
11844 return (PARSER_OK
);
11847 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11849 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11851 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11855 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11858 u32
*digest
= (u32
*) hash_buf
->digest
;
11860 salt_t
*salt
= hash_buf
->salt
;
11862 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11863 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11864 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11865 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11867 digest
[0] = byte_swap_32 (digest
[0]);
11868 digest
[1] = byte_swap_32 (digest
[1]);
11869 digest
[2] = byte_swap_32 (digest
[2]);
11870 digest
[3] = byte_swap_32 (digest
[3]);
11872 digest
[0] -= MD4M_A
;
11873 digest
[1] -= MD4M_B
;
11874 digest
[2] -= MD4M_C
;
11875 digest
[3] -= MD4M_D
;
11877 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11879 uint salt_len
= input_len
- 32 - 1;
11881 char *salt_buf
= input_buf
+ 32 + 1;
11883 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11885 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11887 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11889 salt
->salt_len
= salt_len
;
11891 return (PARSER_OK
);
11894 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11896 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11898 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11902 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11905 u32
*digest
= (u32
*) hash_buf
->digest
;
11907 salt_t
*salt
= hash_buf
->salt
;
11909 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11910 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11911 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11912 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11914 digest
[0] = byte_swap_32 (digest
[0]);
11915 digest
[1] = byte_swap_32 (digest
[1]);
11916 digest
[2] = byte_swap_32 (digest
[2]);
11917 digest
[3] = byte_swap_32 (digest
[3]);
11919 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11921 uint salt_len
= input_len
- 32 - 1;
11923 char *salt_buf
= input_buf
+ 32 + 1;
11925 uint salt_pc_block
[16] = { 0 };
11927 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11929 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11931 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11933 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11935 salt_pc_block
[14] = salt_len
* 8;
11937 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11939 md5_64 (salt_pc_block
, salt_pc_digest
);
11941 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11942 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11943 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11944 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11946 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11948 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11950 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11952 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11953 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11954 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11955 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11957 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11959 return (PARSER_OK
);
11962 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11964 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11966 u32
*digest
= (u32
*) hash_buf
->digest
;
11968 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11969 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11970 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11971 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11972 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11974 digest
[0] -= SHA1M_A
;
11975 digest
[1] -= SHA1M_B
;
11976 digest
[2] -= SHA1M_C
;
11977 digest
[3] -= SHA1M_D
;
11978 digest
[4] -= SHA1M_E
;
11980 return (PARSER_OK
);
11983 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11985 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11987 u32
*digest
= (u32
*) hash_buf
->digest
;
11989 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11990 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11991 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11992 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11993 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11995 return (PARSER_OK
);
11998 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12000 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
12002 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
12004 u32
*digest
= (u32
*) hash_buf
->digest
;
12008 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12009 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12010 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12011 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12014 return (PARSER_OK
);
12017 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12019 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12021 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
12025 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
12028 u32
*digest
= (u32
*) hash_buf
->digest
;
12030 salt_t
*salt
= hash_buf
->salt
;
12032 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12033 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12034 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12035 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12036 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12038 digest
[0] -= SHA1M_A
;
12039 digest
[1] -= SHA1M_B
;
12040 digest
[2] -= SHA1M_C
;
12041 digest
[3] -= SHA1M_D
;
12042 digest
[4] -= SHA1M_E
;
12044 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12046 uint salt_len
= input_len
- 40 - 1;
12048 char *salt_buf
= input_buf
+ 40 + 1;
12050 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12052 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12054 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12056 salt
->salt_len
= salt_len
;
12058 return (PARSER_OK
);
12061 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12063 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
12065 u32
*digest
= (u32
*) hash_buf
->digest
;
12067 salt_t
*salt
= hash_buf
->salt
;
12069 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
12071 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12072 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12073 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12074 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12075 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12077 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12079 uint salt_len
= input_len
- 40 - 1;
12081 char *salt_buf
= input_buf
+ 40 + 1;
12083 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
12085 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
12087 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
12089 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
12092 pstoken
->salt_len
= salt_len
/ 2;
12094 /* some fake salt for the sorting mechanisms */
12096 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
12097 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
12098 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
12099 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
12100 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
12101 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
12102 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
12103 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
12105 salt
->salt_len
= 32;
12107 /* we need to check if we can precompute some of the data --
12108 this is possible since the scheme is badly designed */
12110 pstoken
->pc_digest
[0] = SHA1M_A
;
12111 pstoken
->pc_digest
[1] = SHA1M_B
;
12112 pstoken
->pc_digest
[2] = SHA1M_C
;
12113 pstoken
->pc_digest
[3] = SHA1M_D
;
12114 pstoken
->pc_digest
[4] = SHA1M_E
;
12116 pstoken
->pc_offset
= 0;
12118 for (int i
= 0; i
< (int) pstoken
->salt_len
- 63; i
+= 64)
12122 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
12123 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
12124 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
12125 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
12126 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
12127 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
12128 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
12129 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
12130 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
12131 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
12132 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
12133 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
12134 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
12135 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
12136 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
12137 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
12139 sha1_64 (w
, pstoken
->pc_digest
);
12141 pstoken
->pc_offset
+= 16;
12144 return (PARSER_OK
);
12147 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12149 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
12151 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
12153 u32
*digest
= (u32
*) hash_buf
->digest
;
12155 u8 tmp_buf
[100] = { 0 };
12157 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
12159 memcpy (digest
, tmp_buf
, 20);
12161 digest
[0] = byte_swap_32 (digest
[0]);
12162 digest
[1] = byte_swap_32 (digest
[1]);
12163 digest
[2] = byte_swap_32 (digest
[2]);
12164 digest
[3] = byte_swap_32 (digest
[3]);
12165 digest
[4] = byte_swap_32 (digest
[4]);
12167 digest
[0] -= SHA1M_A
;
12168 digest
[1] -= SHA1M_B
;
12169 digest
[2] -= SHA1M_C
;
12170 digest
[3] -= SHA1M_D
;
12171 digest
[4] -= SHA1M_E
;
12173 return (PARSER_OK
);
12176 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12178 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
12180 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12182 u32
*digest
= (u32
*) hash_buf
->digest
;
12184 salt_t
*salt
= hash_buf
->salt
;
12186 u8 tmp_buf
[100] = { 0 };
12188 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
12190 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
12192 memcpy (digest
, tmp_buf
, 20);
12194 int salt_len
= tmp_len
- 20;
12196 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
12198 salt
->salt_len
= salt_len
;
12200 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
12202 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12204 char *ptr
= (char *) salt
->salt_buf
;
12206 ptr
[salt
->salt_len
] = 0x80;
12209 digest
[0] = byte_swap_32 (digest
[0]);
12210 digest
[1] = byte_swap_32 (digest
[1]);
12211 digest
[2] = byte_swap_32 (digest
[2]);
12212 digest
[3] = byte_swap_32 (digest
[3]);
12213 digest
[4] = byte_swap_32 (digest
[4]);
12215 digest
[0] -= SHA1M_A
;
12216 digest
[1] -= SHA1M_B
;
12217 digest
[2] -= SHA1M_C
;
12218 digest
[3] -= SHA1M_D
;
12219 digest
[4] -= SHA1M_E
;
12221 return (PARSER_OK
);
12224 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12226 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
12228 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12230 u32
*digest
= (u32
*) hash_buf
->digest
;
12232 salt_t
*salt
= hash_buf
->salt
;
12234 char *salt_buf
= input_buf
+ 6;
12238 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12240 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12242 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12244 salt
->salt_len
= salt_len
;
12246 char *hash_pos
= input_buf
+ 6 + 8 + 40;
12248 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12249 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12250 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12251 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12252 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12254 digest
[0] -= SHA1M_A
;
12255 digest
[1] -= SHA1M_B
;
12256 digest
[2] -= SHA1M_C
;
12257 digest
[3] -= SHA1M_D
;
12258 digest
[4] -= SHA1M_E
;
12260 return (PARSER_OK
);
12263 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12265 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
12267 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12269 u32
*digest
= (u32
*) hash_buf
->digest
;
12271 salt_t
*salt
= hash_buf
->salt
;
12273 char *salt_buf
= input_buf
+ 6;
12277 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12279 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12281 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12283 salt
->salt_len
= salt_len
;
12285 char *hash_pos
= input_buf
+ 6 + 8;
12287 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12288 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12289 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12290 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12291 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12293 digest
[0] -= SHA1M_A
;
12294 digest
[1] -= SHA1M_B
;
12295 digest
[2] -= SHA1M_C
;
12296 digest
[3] -= SHA1M_D
;
12297 digest
[4] -= SHA1M_E
;
12299 return (PARSER_OK
);
12302 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12304 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12306 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12308 u64
*digest
= (u64
*) hash_buf
->digest
;
12310 salt_t
*salt
= hash_buf
->salt
;
12312 char *salt_buf
= input_buf
+ 6;
12316 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12318 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12320 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12322 salt
->salt_len
= salt_len
;
12324 char *hash_pos
= input_buf
+ 6 + 8;
12326 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12327 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12328 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12329 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12330 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12331 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12332 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12333 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12335 digest
[0] -= SHA512M_A
;
12336 digest
[1] -= SHA512M_B
;
12337 digest
[2] -= SHA512M_C
;
12338 digest
[3] -= SHA512M_D
;
12339 digest
[4] -= SHA512M_E
;
12340 digest
[5] -= SHA512M_F
;
12341 digest
[6] -= SHA512M_G
;
12342 digest
[7] -= SHA512M_H
;
12344 return (PARSER_OK
);
12347 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12349 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12351 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12355 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12358 u32
*digest
= (u32
*) hash_buf
->digest
;
12360 salt_t
*salt
= hash_buf
->salt
;
12362 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12363 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12367 digest
[0] = byte_swap_32 (digest
[0]);
12368 digest
[1] = byte_swap_32 (digest
[1]);
12370 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12372 uint salt_len
= input_len
- 16 - 1;
12374 char *salt_buf
= input_buf
+ 16 + 1;
12376 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12378 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12380 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12382 salt
->salt_len
= salt_len
;
12384 return (PARSER_OK
);
12387 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12389 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12391 u32
*digest
= (u32
*) hash_buf
->digest
;
12393 salt_t
*salt
= hash_buf
->salt
;
12395 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12396 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12397 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12398 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12399 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12401 digest
[0] -= SHA1M_A
;
12402 digest
[1] -= SHA1M_B
;
12403 digest
[2] -= SHA1M_C
;
12404 digest
[3] -= SHA1M_D
;
12405 digest
[4] -= SHA1M_E
;
12407 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12409 uint salt_len
= input_len
- 40 - 1;
12411 char *salt_buf
= input_buf
+ 40 + 1;
12413 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12415 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12417 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12419 salt
->salt_len
= salt_len
;
12421 return (PARSER_OK
);
12424 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12426 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12428 u32
*digest
= (u32
*) hash_buf
->digest
;
12430 salt_t
*salt
= hash_buf
->salt
;
12432 char *hash_pos
= input_buf
;
12434 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12435 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12436 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12437 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12438 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12439 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12440 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12441 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12442 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12443 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12444 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12445 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12446 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12447 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12448 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12449 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12451 char *salt_pos
= input_buf
+ 128;
12453 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12454 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12455 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12456 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12458 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12459 salt
->salt_len
= 16;
12461 return (PARSER_OK
);
12464 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12466 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12468 u32
*digest
= (u32
*) hash_buf
->digest
;
12470 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12471 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12472 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12473 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12474 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12475 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12476 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12477 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12479 digest
[0] -= SHA256M_A
;
12480 digest
[1] -= SHA256M_B
;
12481 digest
[2] -= SHA256M_C
;
12482 digest
[3] -= SHA256M_D
;
12483 digest
[4] -= SHA256M_E
;
12484 digest
[5] -= SHA256M_F
;
12485 digest
[6] -= SHA256M_G
;
12486 digest
[7] -= SHA256M_H
;
12488 return (PARSER_OK
);
12491 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12493 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12495 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12499 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12502 u32
*digest
= (u32
*) hash_buf
->digest
;
12504 salt_t
*salt
= hash_buf
->salt
;
12506 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12507 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12508 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12509 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12510 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12511 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12512 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12513 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12515 digest
[0] -= SHA256M_A
;
12516 digest
[1] -= SHA256M_B
;
12517 digest
[2] -= SHA256M_C
;
12518 digest
[3] -= SHA256M_D
;
12519 digest
[4] -= SHA256M_E
;
12520 digest
[5] -= SHA256M_F
;
12521 digest
[6] -= SHA256M_G
;
12522 digest
[7] -= SHA256M_H
;
12524 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12526 uint salt_len
= input_len
- 64 - 1;
12528 char *salt_buf
= input_buf
+ 64 + 1;
12530 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12532 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12534 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12536 salt
->salt_len
= salt_len
;
12538 return (PARSER_OK
);
12541 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12543 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12545 u64
*digest
= (u64
*) hash_buf
->digest
;
12547 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12548 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12549 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12550 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12551 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12552 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12556 digest
[0] -= SHA384M_A
;
12557 digest
[1] -= SHA384M_B
;
12558 digest
[2] -= SHA384M_C
;
12559 digest
[3] -= SHA384M_D
;
12560 digest
[4] -= SHA384M_E
;
12561 digest
[5] -= SHA384M_F
;
12565 return (PARSER_OK
);
12568 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12570 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12572 u64
*digest
= (u64
*) hash_buf
->digest
;
12574 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12575 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12576 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12577 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12578 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12579 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12580 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12581 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12583 digest
[0] -= SHA512M_A
;
12584 digest
[1] -= SHA512M_B
;
12585 digest
[2] -= SHA512M_C
;
12586 digest
[3] -= SHA512M_D
;
12587 digest
[4] -= SHA512M_E
;
12588 digest
[5] -= SHA512M_F
;
12589 digest
[6] -= SHA512M_G
;
12590 digest
[7] -= SHA512M_H
;
12592 return (PARSER_OK
);
12595 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12597 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12599 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12603 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12606 u64
*digest
= (u64
*) hash_buf
->digest
;
12608 salt_t
*salt
= hash_buf
->salt
;
12610 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12611 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12612 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12613 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12614 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12615 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12616 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12617 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12619 digest
[0] -= SHA512M_A
;
12620 digest
[1] -= SHA512M_B
;
12621 digest
[2] -= SHA512M_C
;
12622 digest
[3] -= SHA512M_D
;
12623 digest
[4] -= SHA512M_E
;
12624 digest
[5] -= SHA512M_F
;
12625 digest
[6] -= SHA512M_G
;
12626 digest
[7] -= SHA512M_H
;
12628 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12630 uint salt_len
= input_len
- 128 - 1;
12632 char *salt_buf
= input_buf
+ 128 + 1;
12634 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12636 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12638 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12640 salt
->salt_len
= salt_len
;
12642 return (PARSER_OK
);
12645 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12647 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12649 u64
*digest
= (u64
*) hash_buf
->digest
;
12651 salt_t
*salt
= hash_buf
->salt
;
12653 char *salt_pos
= input_buf
+ 3;
12655 uint iterations_len
= 0;
12657 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12661 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12663 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12664 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12668 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12672 iterations_len
+= 8;
12676 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12679 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12681 char *hash_pos
= strchr (salt_pos
, '$');
12683 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12685 uint salt_len
= hash_pos
- salt_pos
;
12687 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12689 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12691 salt
->salt_len
= salt_len
;
12695 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12697 return (PARSER_OK
);
12700 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12702 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12704 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12706 u64
*digest
= (u64
*) hash_buf
->digest
;
12708 salt_t
*salt
= hash_buf
->salt
;
12710 uint keccak_mdlen
= input_len
/ 2;
12712 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12714 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12716 digest
[i
] = byte_swap_64 (digest
[i
]);
12719 salt
->keccak_mdlen
= keccak_mdlen
;
12721 return (PARSER_OK
);
12724 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12726 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12728 u32
*digest
= (u32
*) hash_buf
->digest
;
12730 salt_t
*salt
= hash_buf
->salt
;
12732 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12735 * Parse that strange long line
12740 size_t in_len
[9] = { 0 };
12742 in_off
[0] = strtok (input_buf
, ":");
12744 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12746 in_len
[0] = strlen (in_off
[0]);
12750 for (i
= 1; i
< 9; i
++)
12752 in_off
[i
] = strtok (NULL
, ":");
12754 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12756 in_len
[i
] = strlen (in_off
[i
]);
12759 char *ptr
= (char *) ikepsk
->msg_buf
;
12761 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12762 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12763 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12764 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12765 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12766 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12770 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12772 ptr
= (char *) ikepsk
->nr_buf
;
12774 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12775 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12779 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12782 * Store to database
12787 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12788 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12789 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12790 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12792 digest
[0] = byte_swap_32 (digest
[0]);
12793 digest
[1] = byte_swap_32 (digest
[1]);
12794 digest
[2] = byte_swap_32 (digest
[2]);
12795 digest
[3] = byte_swap_32 (digest
[3]);
12797 salt
->salt_len
= 32;
12799 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12800 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12801 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12802 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12803 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12804 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12805 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12806 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12808 return (PARSER_OK
);
12811 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12813 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12815 u32
*digest
= (u32
*) hash_buf
->digest
;
12817 salt_t
*salt
= hash_buf
->salt
;
12819 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12822 * Parse that strange long line
12827 size_t in_len
[9] = { 0 };
12829 in_off
[0] = strtok (input_buf
, ":");
12831 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12833 in_len
[0] = strlen (in_off
[0]);
12837 for (i
= 1; i
< 9; i
++)
12839 in_off
[i
] = strtok (NULL
, ":");
12841 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12843 in_len
[i
] = strlen (in_off
[i
]);
12846 char *ptr
= (char *) ikepsk
->msg_buf
;
12848 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12849 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12850 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12851 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12852 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12853 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12857 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12859 ptr
= (char *) ikepsk
->nr_buf
;
12861 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12862 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12866 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12869 * Store to database
12874 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12875 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12876 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12877 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12878 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12880 salt
->salt_len
= 32;
12882 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12883 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12884 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12885 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12886 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12887 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12888 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12889 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12891 return (PARSER_OK
);
12894 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12896 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12898 u32
*digest
= (u32
*) hash_buf
->digest
;
12900 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12901 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12902 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12903 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12904 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12906 digest
[0] = byte_swap_32 (digest
[0]);
12907 digest
[1] = byte_swap_32 (digest
[1]);
12908 digest
[2] = byte_swap_32 (digest
[2]);
12909 digest
[3] = byte_swap_32 (digest
[3]);
12910 digest
[4] = byte_swap_32 (digest
[4]);
12912 return (PARSER_OK
);
12915 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12917 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12919 u32
*digest
= (u32
*) hash_buf
->digest
;
12921 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12922 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12923 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12924 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12925 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12926 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12927 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12928 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12929 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12930 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12931 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12932 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12933 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12934 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12935 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12936 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12938 return (PARSER_OK
);
12941 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12943 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12945 u32
*digest
= (u32
*) hash_buf
->digest
;
12947 salt_t
*salt
= hash_buf
->salt
;
12949 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12950 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12951 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12952 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12953 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12955 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12957 uint salt_len
= input_len
- 40 - 1;
12959 char *salt_buf
= input_buf
+ 40 + 1;
12961 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12963 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12965 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12967 salt
->salt_len
= salt_len
;
12969 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12971 return (PARSER_OK
);
12974 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12976 u32
*digest
= (u32
*) hash_buf
->digest
;
12978 salt_t
*salt
= hash_buf
->salt
;
12980 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12982 if (input_len
== 0)
12984 log_error ("TrueCrypt container not specified");
12989 FILE *fp
= fopen (input_buf
, "rb");
12993 log_error ("%s: %s", input_buf
, strerror (errno
));
12998 char buf
[512] = { 0 };
13000 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13004 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13006 memcpy (tc
->salt_buf
, buf
, 64);
13008 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13010 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13012 salt
->salt_len
= 4;
13014 salt
->salt_iter
= ROUNDS_TRUECRYPT_1K
- 1;
13016 tc
->signature
= 0x45555254; // "TRUE"
13018 digest
[0] = tc
->data_buf
[0];
13020 return (PARSER_OK
);
13023 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13025 u32
*digest
= (u32
*) hash_buf
->digest
;
13027 salt_t
*salt
= hash_buf
->salt
;
13029 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13031 if (input_len
== 0)
13033 log_error ("TrueCrypt container not specified");
13038 FILE *fp
= fopen (input_buf
, "rb");
13042 log_error ("%s: %s", input_buf
, strerror (errno
));
13047 char buf
[512] = { 0 };
13049 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13053 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13055 memcpy (tc
->salt_buf
, buf
, 64);
13057 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13059 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13061 salt
->salt_len
= 4;
13063 salt
->salt_iter
= ROUNDS_TRUECRYPT_2K
- 1;
13065 tc
->signature
= 0x45555254; // "TRUE"
13067 digest
[0] = tc
->data_buf
[0];
13069 return (PARSER_OK
);
13072 int veracrypt_parse_hash_200000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13074 u32
*digest
= (u32
*) hash_buf
->digest
;
13076 salt_t
*salt
= hash_buf
->salt
;
13078 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13080 if (input_len
== 0)
13082 log_error ("VeraCrypt container not specified");
13087 FILE *fp
= fopen (input_buf
, "rb");
13091 log_error ("%s: %s", input_buf
, strerror (errno
));
13096 char buf
[512] = { 0 };
13098 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13102 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13104 memcpy (tc
->salt_buf
, buf
, 64);
13106 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13108 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13110 salt
->salt_len
= 4;
13112 salt
->salt_iter
= ROUNDS_VERACRYPT_200000
- 1;
13114 tc
->signature
= 0x41524556; // "VERA"
13116 digest
[0] = tc
->data_buf
[0];
13118 return (PARSER_OK
);
13121 int veracrypt_parse_hash_500000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13123 u32
*digest
= (u32
*) hash_buf
->digest
;
13125 salt_t
*salt
= hash_buf
->salt
;
13127 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13129 if (input_len
== 0)
13131 log_error ("VeraCrypt container not specified");
13136 FILE *fp
= fopen (input_buf
, "rb");
13140 log_error ("%s: %s", input_buf
, strerror (errno
));
13145 char buf
[512] = { 0 };
13147 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13151 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13153 memcpy (tc
->salt_buf
, buf
, 64);
13155 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13157 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13159 salt
->salt_len
= 4;
13161 salt
->salt_iter
= ROUNDS_VERACRYPT_500000
- 1;
13163 tc
->signature
= 0x41524556; // "VERA"
13165 digest
[0] = tc
->data_buf
[0];
13167 return (PARSER_OK
);
13170 int veracrypt_parse_hash_327661 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13172 u32
*digest
= (u32
*) hash_buf
->digest
;
13174 salt_t
*salt
= hash_buf
->salt
;
13176 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13178 if (input_len
== 0)
13180 log_error ("VeraCrypt container not specified");
13185 FILE *fp
= fopen (input_buf
, "rb");
13189 log_error ("%s: %s", input_buf
, strerror (errno
));
13194 char buf
[512] = { 0 };
13196 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13200 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13202 memcpy (tc
->salt_buf
, buf
, 64);
13204 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13206 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13208 salt
->salt_len
= 4;
13210 salt
->salt_iter
= ROUNDS_VERACRYPT_327661
- 1;
13212 tc
->signature
= 0x41524556; // "VERA"
13214 digest
[0] = tc
->data_buf
[0];
13216 return (PARSER_OK
);
13219 int veracrypt_parse_hash_655331 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13221 u32
*digest
= (u32
*) hash_buf
->digest
;
13223 salt_t
*salt
= hash_buf
->salt
;
13225 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13227 if (input_len
== 0)
13229 log_error ("VeraCrypt container not specified");
13234 FILE *fp
= fopen (input_buf
, "rb");
13238 log_error ("%s: %s", input_buf
, strerror (errno
));
13243 char buf
[512] = { 0 };
13245 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13249 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13251 memcpy (tc
->salt_buf
, buf
, 64);
13253 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13255 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13257 salt
->salt_len
= 4;
13259 salt
->salt_iter
= ROUNDS_VERACRYPT_655331
- 1;
13261 tc
->signature
= 0x41524556; // "VERA"
13263 digest
[0] = tc
->data_buf
[0];
13265 return (PARSER_OK
);
13268 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13270 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
13272 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13274 u32
*digest
= (u32
*) hash_buf
->digest
;
13276 salt_t
*salt
= hash_buf
->salt
;
13278 char *salt_pos
= input_buf
+ 6;
13280 char *hash_pos
= strchr (salt_pos
, '$');
13282 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13284 uint salt_len
= hash_pos
- salt_pos
;
13286 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
13288 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13290 salt
->salt_len
= salt_len
;
13292 salt
->salt_iter
= 1000;
13296 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13298 return (PARSER_OK
);
13301 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13303 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
13305 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
13307 u32
*digest
= (u32
*) hash_buf
->digest
;
13309 salt_t
*salt
= hash_buf
->salt
;
13311 char *iter_pos
= input_buf
+ 7;
13313 char *salt_pos
= strchr (iter_pos
, '$');
13315 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13319 char *hash_pos
= strchr (salt_pos
, '$');
13321 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13323 uint salt_len
= hash_pos
- salt_pos
;
13325 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13327 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13329 salt
->salt_len
= salt_len
;
13331 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13333 salt
->salt_sign
[0] = atoi (salt_iter
);
13335 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13339 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13341 digest
[0] = byte_swap_32 (digest
[0]);
13342 digest
[1] = byte_swap_32 (digest
[1]);
13343 digest
[2] = byte_swap_32 (digest
[2]);
13344 digest
[3] = byte_swap_32 (digest
[3]);
13345 digest
[4] = byte_swap_32 (digest
[4]);
13347 return (PARSER_OK
);
13350 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13352 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
13354 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13356 u32
*digest
= (u32
*) hash_buf
->digest
;
13358 salt_t
*salt
= hash_buf
->salt
;
13360 char *iter_pos
= input_buf
+ 9;
13362 char *salt_pos
= strchr (iter_pos
, '$');
13364 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13368 char *hash_pos
= strchr (salt_pos
, '$');
13370 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13372 uint salt_len
= hash_pos
- salt_pos
;
13374 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13376 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13378 salt
->salt_len
= salt_len
;
13380 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13382 salt
->salt_sign
[0] = atoi (salt_iter
);
13384 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13388 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13390 digest
[0] = byte_swap_32 (digest
[0]);
13391 digest
[1] = byte_swap_32 (digest
[1]);
13392 digest
[2] = byte_swap_32 (digest
[2]);
13393 digest
[3] = byte_swap_32 (digest
[3]);
13394 digest
[4] = byte_swap_32 (digest
[4]);
13395 digest
[5] = byte_swap_32 (digest
[5]);
13396 digest
[6] = byte_swap_32 (digest
[6]);
13397 digest
[7] = byte_swap_32 (digest
[7]);
13399 return (PARSER_OK
);
13402 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13404 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
13406 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13408 u64
*digest
= (u64
*) hash_buf
->digest
;
13410 salt_t
*salt
= hash_buf
->salt
;
13412 char *iter_pos
= input_buf
+ 9;
13414 char *salt_pos
= strchr (iter_pos
, '$');
13416 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13420 char *hash_pos
= strchr (salt_pos
, '$');
13422 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13424 uint salt_len
= hash_pos
- salt_pos
;
13426 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13428 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13430 salt
->salt_len
= salt_len
;
13432 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13434 salt
->salt_sign
[0] = atoi (salt_iter
);
13436 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13440 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13442 digest
[0] = byte_swap_64 (digest
[0]);
13443 digest
[1] = byte_swap_64 (digest
[1]);
13444 digest
[2] = byte_swap_64 (digest
[2]);
13445 digest
[3] = byte_swap_64 (digest
[3]);
13446 digest
[4] = byte_swap_64 (digest
[4]);
13447 digest
[5] = byte_swap_64 (digest
[5]);
13448 digest
[6] = byte_swap_64 (digest
[6]);
13449 digest
[7] = byte_swap_64 (digest
[7]);
13451 return (PARSER_OK
);
13454 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13456 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
13458 u32
*digest
= (u32
*) hash_buf
->digest
;
13460 salt_t
*salt
= hash_buf
->salt
;
13462 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
13468 char *iterations_pos
= input_buf
;
13470 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13472 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13474 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13476 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13480 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13482 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13484 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13486 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13488 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13490 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13495 * pbkdf2 iterations
13498 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13501 * handle salt encoding
13504 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13506 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13508 const char p0
= saltbuf_pos
[i
+ 0];
13509 const char p1
= saltbuf_pos
[i
+ 1];
13511 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13512 | hex_convert (p0
) << 4;
13515 salt
->salt_len
= saltbuf_len
/ 2;
13518 * handle cipher encoding
13521 uint
*tmp
= (uint
*) mymalloc (32);
13523 char *cipherbuf_ptr
= (char *) tmp
;
13525 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13527 const char p0
= cipherbuf_pos
[i
+ 0];
13528 const char p1
= cipherbuf_pos
[i
+ 1];
13530 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13531 | hex_convert (p0
) << 4;
13534 // iv is stored at salt_buf 4 (length 16)
13535 // data is stored at salt_buf 8 (length 16)
13537 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13538 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13539 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13540 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13542 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13543 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13544 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13545 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13549 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13551 const char p0
= cipherbuf_pos
[j
+ 0];
13552 const char p1
= cipherbuf_pos
[j
+ 1];
13554 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13555 | hex_convert (p0
) << 4;
13562 digest
[0] = 0x10101010;
13563 digest
[1] = 0x10101010;
13564 digest
[2] = 0x10101010;
13565 digest
[3] = 0x10101010;
13567 return (PARSER_OK
);
13570 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13572 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13574 u32
*digest
= (u32
*) hash_buf
->digest
;
13576 salt_t
*salt
= hash_buf
->salt
;
13578 char *hashbuf_pos
= input_buf
;
13580 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13582 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13584 uint hash_len
= iterations_pos
- hashbuf_pos
;
13586 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13590 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13592 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13594 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13598 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13600 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13602 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13604 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13606 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13608 salt
->salt_len
= salt_len
;
13610 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13612 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13613 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13614 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13615 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13617 return (PARSER_OK
);
13620 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13622 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13624 u32
*digest
= (u32
*) hash_buf
->digest
;
13626 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13627 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13628 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13629 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13630 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13631 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13632 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13633 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13635 digest
[0] = byte_swap_32 (digest
[0]);
13636 digest
[1] = byte_swap_32 (digest
[1]);
13637 digest
[2] = byte_swap_32 (digest
[2]);
13638 digest
[3] = byte_swap_32 (digest
[3]);
13639 digest
[4] = byte_swap_32 (digest
[4]);
13640 digest
[5] = byte_swap_32 (digest
[5]);
13641 digest
[6] = byte_swap_32 (digest
[6]);
13642 digest
[7] = byte_swap_32 (digest
[7]);
13644 return (PARSER_OK
);
13647 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13649 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13651 u32
*digest
= (u32
*) hash_buf
->digest
;
13653 salt_t
*salt
= hash_buf
->salt
;
13655 char *salt_pos
= input_buf
+ 3;
13657 uint iterations_len
= 0;
13659 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13663 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13665 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13666 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13670 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13674 iterations_len
+= 8;
13678 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13681 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13683 char *hash_pos
= strchr (salt_pos
, '$');
13685 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13687 uint salt_len
= hash_pos
- salt_pos
;
13689 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13691 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13693 salt
->salt_len
= salt_len
;
13697 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13699 return (PARSER_OK
);
13702 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13704 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13706 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13708 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13710 u64
*digest
= (u64
*) hash_buf
->digest
;
13712 salt_t
*salt
= hash_buf
->salt
;
13714 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13716 char *iter_pos
= input_buf
+ 4;
13718 char *salt_pos
= strchr (iter_pos
, '$');
13720 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13724 char *hash_pos
= strchr (salt_pos
, '$');
13726 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13728 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13732 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13733 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13734 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13735 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13736 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13737 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13738 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13739 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13741 uint salt_len
= hash_pos
- salt_pos
- 1;
13743 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13745 salt
->salt_len
= salt_len
/ 2;
13747 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13748 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13749 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13750 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13751 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13752 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13753 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13754 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13756 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13757 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13758 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13759 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13760 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13761 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13762 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13763 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13764 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13765 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13767 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13769 salt
->salt_iter
= atoi (iter_pos
) - 1;
13771 return (PARSER_OK
);
13774 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13776 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13778 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13780 u32
*digest
= (u32
*) hash_buf
->digest
;
13782 salt_t
*salt
= hash_buf
->salt
;
13784 char *salt_pos
= input_buf
+ 14;
13786 char *hash_pos
= strchr (salt_pos
, '*');
13788 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13792 uint salt_len
= hash_pos
- salt_pos
- 1;
13794 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13796 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13798 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13800 salt
->salt_len
= salt_len
;
13802 u8 tmp_buf
[100] = { 0 };
13804 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13806 memcpy (digest
, tmp_buf
, 32);
13808 digest
[0] = byte_swap_32 (digest
[0]);
13809 digest
[1] = byte_swap_32 (digest
[1]);
13810 digest
[2] = byte_swap_32 (digest
[2]);
13811 digest
[3] = byte_swap_32 (digest
[3]);
13812 digest
[4] = byte_swap_32 (digest
[4]);
13813 digest
[5] = byte_swap_32 (digest
[5]);
13814 digest
[6] = byte_swap_32 (digest
[6]);
13815 digest
[7] = byte_swap_32 (digest
[7]);
13817 digest
[0] -= SHA256M_A
;
13818 digest
[1] -= SHA256M_B
;
13819 digest
[2] -= SHA256M_C
;
13820 digest
[3] -= SHA256M_D
;
13821 digest
[4] -= SHA256M_E
;
13822 digest
[5] -= SHA256M_F
;
13823 digest
[6] -= SHA256M_G
;
13824 digest
[7] -= SHA256M_H
;
13826 return (PARSER_OK
);
13829 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13831 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13833 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13835 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13837 u64
*digest
= (u64
*) hash_buf
->digest
;
13839 salt_t
*salt
= hash_buf
->salt
;
13841 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13843 char *iter_pos
= input_buf
+ 19;
13845 char *salt_pos
= strchr (iter_pos
, '.');
13847 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13851 char *hash_pos
= strchr (salt_pos
, '.');
13853 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13855 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13859 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13860 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13861 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13862 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13863 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13864 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13865 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13866 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13868 uint salt_len
= hash_pos
- salt_pos
- 1;
13872 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13876 for (i
= 0; i
< salt_len
; i
++)
13878 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13881 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13882 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13884 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13886 salt
->salt_len
= salt_len
;
13888 salt
->salt_iter
= atoi (iter_pos
) - 1;
13890 return (PARSER_OK
);
13893 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13895 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13897 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13899 u64
*digest
= (u64
*) hash_buf
->digest
;
13901 salt_t
*salt
= hash_buf
->salt
;
13903 u8 tmp_buf
[120] = { 0 };
13905 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13907 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13909 memcpy (digest
, tmp_buf
, 64);
13911 digest
[0] = byte_swap_64 (digest
[0]);
13912 digest
[1] = byte_swap_64 (digest
[1]);
13913 digest
[2] = byte_swap_64 (digest
[2]);
13914 digest
[3] = byte_swap_64 (digest
[3]);
13915 digest
[4] = byte_swap_64 (digest
[4]);
13916 digest
[5] = byte_swap_64 (digest
[5]);
13917 digest
[6] = byte_swap_64 (digest
[6]);
13918 digest
[7] = byte_swap_64 (digest
[7]);
13920 digest
[0] -= SHA512M_A
;
13921 digest
[1] -= SHA512M_B
;
13922 digest
[2] -= SHA512M_C
;
13923 digest
[3] -= SHA512M_D
;
13924 digest
[4] -= SHA512M_E
;
13925 digest
[5] -= SHA512M_F
;
13926 digest
[6] -= SHA512M_G
;
13927 digest
[7] -= SHA512M_H
;
13929 int salt_len
= tmp_len
- 64;
13931 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13933 salt
->salt_len
= salt_len
;
13935 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13937 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13939 char *ptr
= (char *) salt
->salt_buf
;
13941 ptr
[salt
->salt_len
] = 0x80;
13944 return (PARSER_OK
);
13947 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13949 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13951 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13955 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13958 u32
*digest
= (u32
*) hash_buf
->digest
;
13960 salt_t
*salt
= hash_buf
->salt
;
13962 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13963 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13964 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13965 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13967 digest
[0] = byte_swap_32 (digest
[0]);
13968 digest
[1] = byte_swap_32 (digest
[1]);
13969 digest
[2] = byte_swap_32 (digest
[2]);
13970 digest
[3] = byte_swap_32 (digest
[3]);
13972 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13974 uint salt_len
= input_len
- 32 - 1;
13976 char *salt_buf
= input_buf
+ 32 + 1;
13978 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13980 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13982 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13984 salt
->salt_len
= salt_len
;
13986 return (PARSER_OK
);
13989 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13991 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13993 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13997 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
14000 u32
*digest
= (u32
*) hash_buf
->digest
;
14002 salt_t
*salt
= hash_buf
->salt
;
14004 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14005 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14006 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14007 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14008 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14010 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14012 uint salt_len
= input_len
- 40 - 1;
14014 char *salt_buf
= input_buf
+ 40 + 1;
14016 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14018 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14020 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14022 salt
->salt_len
= salt_len
;
14024 return (PARSER_OK
);
14027 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14029 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14031 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
14035 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
14038 u32
*digest
= (u32
*) hash_buf
->digest
;
14040 salt_t
*salt
= hash_buf
->salt
;
14042 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14043 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14044 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14045 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14046 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14047 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
14048 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
14049 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
14051 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14053 uint salt_len
= input_len
- 64 - 1;
14055 char *salt_buf
= input_buf
+ 64 + 1;
14057 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14059 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14061 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14063 salt
->salt_len
= salt_len
;
14065 return (PARSER_OK
);
14068 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14070 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14072 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
14076 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
14079 u64
*digest
= (u64
*) hash_buf
->digest
;
14081 salt_t
*salt
= hash_buf
->salt
;
14083 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
14084 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
14085 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
14086 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
14087 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
14088 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
14089 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
14090 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
14092 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14094 uint salt_len
= input_len
- 128 - 1;
14096 char *salt_buf
= input_buf
+ 128 + 1;
14098 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14100 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14102 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14104 salt
->salt_len
= salt_len
;
14106 return (PARSER_OK
);
14109 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14111 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
14113 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
14115 u32
*digest
= (u32
*) hash_buf
->digest
;
14117 salt_t
*salt
= hash_buf
->salt
;
14119 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
14125 char *user_pos
= input_buf
+ 10 + 1;
14127 char *realm_pos
= strchr (user_pos
, '$');
14129 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14131 uint user_len
= realm_pos
- user_pos
;
14133 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
14137 char *salt_pos
= strchr (realm_pos
, '$');
14139 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14141 uint realm_len
= salt_pos
- realm_pos
;
14143 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
14147 char *data_pos
= strchr (salt_pos
, '$');
14149 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14151 uint salt_len
= data_pos
- salt_pos
;
14153 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
14157 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
14159 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
14165 memcpy (krb5pa
->user
, user_pos
, user_len
);
14166 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
14167 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
14169 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
14171 for (uint i
= 0; i
< (36 * 2); i
+= 2)
14173 const char p0
= data_pos
[i
+ 0];
14174 const char p1
= data_pos
[i
+ 1];
14176 *timestamp_ptr
++ = hex_convert (p1
) << 0
14177 | hex_convert (p0
) << 4;
14180 char *checksum_ptr
= (char *) krb5pa
->checksum
;
14182 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
14184 const char p0
= data_pos
[i
+ 0];
14185 const char p1
= data_pos
[i
+ 1];
14187 *checksum_ptr
++ = hex_convert (p1
) << 0
14188 | hex_convert (p0
) << 4;
14192 * copy some data to generic buffers to make sorting happy
14195 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
14196 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
14197 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
14198 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
14199 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
14200 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
14201 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
14202 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
14203 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
14205 salt
->salt_len
= 36;
14207 digest
[0] = krb5pa
->checksum
[0];
14208 digest
[1] = krb5pa
->checksum
[1];
14209 digest
[2] = krb5pa
->checksum
[2];
14210 digest
[3] = krb5pa
->checksum
[3];
14212 return (PARSER_OK
);
14215 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14217 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
14219 u32
*digest
= (u32
*) hash_buf
->digest
;
14221 salt_t
*salt
= hash_buf
->salt
;
14227 char *salt_pos
= input_buf
;
14229 char *hash_pos
= strchr (salt_pos
, '$');
14231 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14233 uint salt_len
= hash_pos
- salt_pos
;
14235 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14239 uint hash_len
= input_len
- 1 - salt_len
;
14241 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14249 for (uint i
= 0; i
< salt_len
; i
++)
14251 if (salt_pos
[i
] == ' ') continue;
14256 // SAP user names cannot be longer than 12 characters
14257 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14259 // SAP user name cannot start with ! or ?
14260 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14266 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14268 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14270 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14272 salt
->salt_len
= salt_len
;
14274 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
14275 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
14279 digest
[0] = byte_swap_32 (digest
[0]);
14280 digest
[1] = byte_swap_32 (digest
[1]);
14282 return (PARSER_OK
);
14285 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14287 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
14289 u32
*digest
= (u32
*) hash_buf
->digest
;
14291 salt_t
*salt
= hash_buf
->salt
;
14297 char *salt_pos
= input_buf
;
14299 char *hash_pos
= strchr (salt_pos
, '$');
14301 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14303 uint salt_len
= hash_pos
- salt_pos
;
14305 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14309 uint hash_len
= input_len
- 1 - salt_len
;
14311 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
14319 for (uint i
= 0; i
< salt_len
; i
++)
14321 if (salt_pos
[i
] == ' ') continue;
14326 // SAP user names cannot be longer than 12 characters
14327 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
14328 // so far nobody complained so we stay with this because it helps in optimization
14329 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
14331 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14333 // SAP user name cannot start with ! or ?
14334 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14340 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14342 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14344 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14346 salt
->salt_len
= salt_len
;
14348 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14349 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14350 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14351 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14352 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14354 return (PARSER_OK
);
14357 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14359 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
14361 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14363 u64
*digest
= (u64
*) hash_buf
->digest
;
14365 salt_t
*salt
= hash_buf
->salt
;
14367 char *iter_pos
= input_buf
+ 3;
14369 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
14371 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
14373 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
14375 salt
->salt_iter
= salt_iter
;
14377 char *salt_pos
= iter_pos
+ 1;
14381 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
14383 salt
->salt_len
= salt_len
;
14385 char *hash_pos
= salt_pos
+ salt_len
;
14387 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14391 char *tmp
= (char *) salt
->salt_buf_pc
;
14393 tmp
[0] = hash_pos
[42];
14397 digest
[ 0] = byte_swap_64 (digest
[ 0]);
14398 digest
[ 1] = byte_swap_64 (digest
[ 1]);
14399 digest
[ 2] = byte_swap_64 (digest
[ 2]);
14400 digest
[ 3] = byte_swap_64 (digest
[ 3]);
14406 return (PARSER_OK
);
14409 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14411 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
14413 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14415 u32
*digest
= (u32
*) hash_buf
->digest
;
14417 salt_t
*salt
= hash_buf
->salt
;
14419 char *salt_buf
= input_buf
+ 6;
14421 uint salt_len
= 16;
14423 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14425 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14427 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14429 salt
->salt_len
= salt_len
;
14431 char *hash_pos
= input_buf
+ 6 + 16;
14433 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14434 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14435 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14436 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14437 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14438 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
14439 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
14440 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
14442 return (PARSER_OK
);
14445 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14447 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
14449 u32
*digest
= (u32
*) hash_buf
->digest
;
14451 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14452 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14456 return (PARSER_OK
);
14459 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14461 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
14463 u32
*digest
= (u32
*) hash_buf
->digest
;
14465 salt_t
*salt
= hash_buf
->salt
;
14467 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
14469 char *saltbuf_pos
= input_buf
;
14471 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
14473 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14475 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14477 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14478 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14480 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14484 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14486 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14488 char *salt_ptr
= (char *) saltbuf_pos
;
14489 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14494 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14496 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14499 rakp_ptr
[j
] = 0x80;
14501 rakp
->salt_len
= j
;
14503 for (i
= 0; i
< 64; i
++)
14505 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14508 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14509 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14510 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14511 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14512 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14513 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14514 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14515 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14517 salt
->salt_len
= 32; // muss min. 32 haben
14519 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14520 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14521 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14522 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14523 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14525 return (PARSER_OK
);
14528 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14530 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14532 u32
*digest
= (u32
*) hash_buf
->digest
;
14534 salt_t
*salt
= hash_buf
->salt
;
14536 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14538 char *salt_pos
= input_buf
+ 1;
14540 memcpy (salt
->salt_buf
, salt_pos
, 8);
14542 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14543 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14545 salt
->salt_len
= 8;
14547 char *hash_pos
= salt_pos
+ 8;
14549 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14550 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14551 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14552 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14553 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14555 digest
[0] -= SHA1M_A
;
14556 digest
[1] -= SHA1M_B
;
14557 digest
[2] -= SHA1M_C
;
14558 digest
[3] -= SHA1M_D
;
14559 digest
[4] -= SHA1M_E
;
14561 return (PARSER_OK
);
14564 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14566 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14568 u32
*digest
= (u32
*) hash_buf
->digest
;
14570 salt_t
*salt
= hash_buf
->salt
;
14572 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14573 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14574 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14575 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14577 digest
[0] = byte_swap_32 (digest
[0]);
14578 digest
[1] = byte_swap_32 (digest
[1]);
14579 digest
[2] = byte_swap_32 (digest
[2]);
14580 digest
[3] = byte_swap_32 (digest
[3]);
14582 digest
[0] -= MD5M_A
;
14583 digest
[1] -= MD5M_B
;
14584 digest
[2] -= MD5M_C
;
14585 digest
[3] -= MD5M_D
;
14587 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14589 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14591 u32
*salt_buf
= salt
->salt_buf
;
14593 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14594 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14595 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14596 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14598 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14599 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14600 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14601 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14603 salt
->salt_len
= 16 + 1;
14605 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14607 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14609 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14611 return (PARSER_OK
);
14614 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14616 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14618 u32
*digest
= (u32
*) hash_buf
->digest
;
14620 salt_t
*salt
= hash_buf
->salt
;
14622 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14628 char *hashbuf_pos
= input_buf
;
14630 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14632 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14634 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14636 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14640 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14642 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14644 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14646 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14650 char *databuf_pos
= strchr (iteration_pos
, ':');
14652 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14654 const uint iteration_len
= databuf_pos
- iteration_pos
;
14656 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14657 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14659 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14661 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14662 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14668 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14669 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14670 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14671 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14672 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14673 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14674 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14675 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14679 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14681 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14683 const char p0
= saltbuf_pos
[i
+ 0];
14684 const char p1
= saltbuf_pos
[i
+ 1];
14686 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14687 | hex_convert (p0
) << 4;
14690 salt
->salt_buf
[4] = 0x01000000;
14691 salt
->salt_buf
[5] = 0x80;
14693 salt
->salt_len
= saltbuf_len
/ 2;
14697 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14701 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14703 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14705 const char p0
= databuf_pos
[i
+ 0];
14706 const char p1
= databuf_pos
[i
+ 1];
14708 *databuf_ptr
++ = hex_convert (p1
) << 0
14709 | hex_convert (p0
) << 4;
14712 *databuf_ptr
++ = 0x80;
14714 for (uint i
= 0; i
< 512; i
++)
14716 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14719 cloudkey
->data_len
= databuf_len
/ 2;
14721 return (PARSER_OK
);
14724 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14726 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14728 u32
*digest
= (u32
*) hash_buf
->digest
;
14730 salt_t
*salt
= hash_buf
->salt
;
14736 char *hashbuf_pos
= input_buf
;
14738 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14740 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14742 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14744 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14748 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14750 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14752 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14754 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14756 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14760 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14762 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14764 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14766 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14768 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14772 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14774 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14775 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14777 // ok, the plan for this algorithm is the following:
14778 // we have 2 salts here, the domain-name and a random salt
14779 // while both are used in the initial transformation,
14780 // only the random salt is used in the following iterations
14781 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14782 // and one that includes only the real salt (stored into salt_buf[]).
14783 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14785 u8 tmp_buf
[100] = { 0 };
14787 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14789 memcpy (digest
, tmp_buf
, 20);
14791 digest
[0] = byte_swap_32 (digest
[0]);
14792 digest
[1] = byte_swap_32 (digest
[1]);
14793 digest
[2] = byte_swap_32 (digest
[2]);
14794 digest
[3] = byte_swap_32 (digest
[3]);
14795 digest
[4] = byte_swap_32 (digest
[4]);
14799 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14801 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14803 char *len_ptr
= NULL
;
14805 for (uint i
= 0; i
< domainbuf_len
; i
++)
14807 if (salt_buf_pc_ptr
[i
] == '.')
14809 len_ptr
= &salt_buf_pc_ptr
[i
];
14819 salt
->salt_buf_pc
[7] = domainbuf_len
;
14823 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14825 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14827 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14829 salt
->salt_len
= salt_len
;
14833 salt
->salt_iter
= atoi (iteration_pos
);
14835 return (PARSER_OK
);
14838 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14840 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14842 u32
*digest
= (u32
*) hash_buf
->digest
;
14844 salt_t
*salt
= hash_buf
->salt
;
14846 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14847 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14848 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14849 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14850 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14852 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14854 uint salt_len
= input_len
- 40 - 1;
14856 char *salt_buf
= input_buf
+ 40 + 1;
14858 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14860 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14862 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14864 salt
->salt_len
= salt_len
;
14866 return (PARSER_OK
);
14869 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14871 const u8 ascii_to_ebcdic
[] =
14873 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14874 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14875 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14876 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14877 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14878 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14879 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14880 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14881 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14882 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14883 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14884 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14885 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14886 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14887 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14888 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14891 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14893 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14895 u32
*digest
= (u32
*) hash_buf
->digest
;
14897 salt_t
*salt
= hash_buf
->salt
;
14899 char *salt_pos
= input_buf
+ 6 + 1;
14901 char *digest_pos
= strchr (salt_pos
, '*');
14903 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14905 uint salt_len
= digest_pos
- salt_pos
;
14907 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14909 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14911 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14915 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14916 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14918 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14920 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14922 salt
->salt_len
= salt_len
;
14924 for (uint i
= 0; i
< salt_len
; i
++)
14926 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14928 for (uint i
= salt_len
; i
< 8; i
++)
14930 salt_buf_pc_ptr
[i
] = 0x40;
14935 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14937 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14938 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14940 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14941 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14943 digest
[0] = byte_swap_32 (digest
[0]);
14944 digest
[1] = byte_swap_32 (digest
[1]);
14946 IP (digest
[0], digest
[1], tt
);
14948 digest
[0] = rotr32 (digest
[0], 29);
14949 digest
[1] = rotr32 (digest
[1], 29);
14953 return (PARSER_OK
);
14956 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14958 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14960 u32
*digest
= (u32
*) hash_buf
->digest
;
14962 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14963 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14964 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14965 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14967 digest
[0] = byte_swap_32 (digest
[0]);
14968 digest
[1] = byte_swap_32 (digest
[1]);
14969 digest
[2] = byte_swap_32 (digest
[2]);
14970 digest
[3] = byte_swap_32 (digest
[3]);
14972 return (PARSER_OK
);
14975 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14977 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14979 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14981 u32
*digest
= (u32
*) hash_buf
->digest
;
14983 salt_t
*salt
= hash_buf
->salt
;
14985 u8 tmp_buf
[120] = { 0 };
14987 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14989 tmp_buf
[3] += -4; // dont ask!
14991 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14993 salt
->salt_len
= 5;
14995 memcpy (digest
, tmp_buf
+ 5, 9);
14997 // yes, only 9 byte are needed to crack, but 10 to display
14999 salt
->salt_buf_pc
[7] = input_buf
[20];
15001 return (PARSER_OK
);
15004 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15006 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
15008 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15010 u32
*digest
= (u32
*) hash_buf
->digest
;
15012 salt_t
*salt
= hash_buf
->salt
;
15014 u8 tmp_buf
[120] = { 0 };
15016 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15018 tmp_buf
[3] += -4; // dont ask!
15022 memcpy (salt
->salt_buf
, tmp_buf
, 16);
15024 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)
15028 char tmp_iter_buf
[11] = { 0 };
15030 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
15032 tmp_iter_buf
[10] = 0;
15034 salt
->salt_iter
= atoi (tmp_iter_buf
);
15036 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
15038 return (PARSER_SALT_ITERATION
);
15041 salt
->salt_iter
--; // first round in init
15043 // 2 additional bytes for display only
15045 salt
->salt_buf_pc
[0] = tmp_buf
[26];
15046 salt
->salt_buf_pc
[1] = tmp_buf
[27];
15050 memcpy (digest
, tmp_buf
+ 28, 8);
15052 digest
[0] = byte_swap_32 (digest
[0]);
15053 digest
[1] = byte_swap_32 (digest
[1]);
15057 return (PARSER_OK
);
15060 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15062 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
15064 u32
*digest
= (u32
*) hash_buf
->digest
;
15066 salt_t
*salt
= hash_buf
->salt
;
15068 char *salt_buf_pos
= input_buf
;
15070 char *hash_buf_pos
= salt_buf_pos
+ 6;
15072 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
15073 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
15074 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
15075 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
15076 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
15077 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
15078 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
15079 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
15081 digest
[0] -= SHA256M_A
;
15082 digest
[1] -= SHA256M_B
;
15083 digest
[2] -= SHA256M_C
;
15084 digest
[3] -= SHA256M_D
;
15085 digest
[4] -= SHA256M_E
;
15086 digest
[5] -= SHA256M_F
;
15087 digest
[6] -= SHA256M_G
;
15088 digest
[7] -= SHA256M_H
;
15090 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15092 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
15094 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15096 salt
->salt_len
= salt_len
;
15098 return (PARSER_OK
);
15101 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15103 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
15105 u32
*digest
= (u32
*) hash_buf
->digest
;
15107 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15109 salt_t
*salt
= hash_buf
->salt
;
15111 char *salt_buf
= input_buf
+ 6;
15113 char *digest_buf
= strchr (salt_buf
, '$');
15115 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15117 uint salt_len
= digest_buf
- salt_buf
;
15119 digest_buf
++; // skip the '$' symbol
15121 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15123 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15125 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15127 salt
->salt_len
= salt_len
;
15129 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15130 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15131 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15132 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15134 digest
[0] = byte_swap_32 (digest
[0]);
15135 digest
[1] = byte_swap_32 (digest
[1]);
15136 digest
[2] = byte_swap_32 (digest
[2]);
15137 digest
[3] = byte_swap_32 (digest
[3]);
15139 digest
[0] -= MD5M_A
;
15140 digest
[1] -= MD5M_B
;
15141 digest
[2] -= MD5M_C
;
15142 digest
[3] -= MD5M_D
;
15144 return (PARSER_OK
);
15147 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15149 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
15151 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15153 u32
*digest
= (u32
*) hash_buf
->digest
;
15155 salt_t
*salt
= hash_buf
->salt
;
15157 char *salt_buf
= input_buf
+ 3;
15159 char *digest_buf
= strchr (salt_buf
, '$');
15161 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15163 uint salt_len
= digest_buf
- salt_buf
;
15165 digest_buf
++; // skip the '$' symbol
15167 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15169 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15171 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15173 salt_buf_ptr
[salt_len
] = 0x2d;
15175 salt
->salt_len
= salt_len
+ 1;
15177 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15178 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15179 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15180 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15182 digest
[0] = byte_swap_32 (digest
[0]);
15183 digest
[1] = byte_swap_32 (digest
[1]);
15184 digest
[2] = byte_swap_32 (digest
[2]);
15185 digest
[3] = byte_swap_32 (digest
[3]);
15187 digest
[0] -= MD5M_A
;
15188 digest
[1] -= MD5M_B
;
15189 digest
[2] -= MD5M_C
;
15190 digest
[3] -= MD5M_D
;
15192 return (PARSER_OK
);
15195 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15197 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
15199 u32
*digest
= (u32
*) hash_buf
->digest
;
15201 salt_t
*salt
= hash_buf
->salt
;
15203 u8 tmp_buf
[100] = { 0 };
15205 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
15207 memcpy (digest
, tmp_buf
, 20);
15209 digest
[0] = byte_swap_32 (digest
[0]);
15210 digest
[1] = byte_swap_32 (digest
[1]);
15211 digest
[2] = byte_swap_32 (digest
[2]);
15212 digest
[3] = byte_swap_32 (digest
[3]);
15213 digest
[4] = byte_swap_32 (digest
[4]);
15215 digest
[0] -= SHA1M_A
;
15216 digest
[1] -= SHA1M_B
;
15217 digest
[2] -= SHA1M_C
;
15218 digest
[3] -= SHA1M_D
;
15219 digest
[4] -= SHA1M_E
;
15221 salt
->salt_buf
[0] = 0x80;
15223 salt
->salt_len
= 0;
15225 return (PARSER_OK
);
15228 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15230 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
15232 u32
*digest
= (u32
*) hash_buf
->digest
;
15234 salt_t
*salt
= hash_buf
->salt
;
15236 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15237 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15238 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15239 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15241 digest
[0] = byte_swap_32 (digest
[0]);
15242 digest
[1] = byte_swap_32 (digest
[1]);
15243 digest
[2] = byte_swap_32 (digest
[2]);
15244 digest
[3] = byte_swap_32 (digest
[3]);
15246 digest
[0] -= MD5M_A
;
15247 digest
[1] -= MD5M_B
;
15248 digest
[2] -= MD5M_C
;
15249 digest
[3] -= MD5M_D
;
15251 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15253 uint salt_len
= input_len
- 32 - 1;
15255 char *salt_buf
= input_buf
+ 32 + 1;
15257 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15259 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15261 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15264 * add static "salt" part
15267 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
15271 salt
->salt_len
= salt_len
;
15273 return (PARSER_OK
);
15276 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15278 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
15280 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
15282 u32
*digest
= (u32
*) hash_buf
->digest
;
15284 salt_t
*salt
= hash_buf
->salt
;
15286 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
15292 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
15294 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
15296 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15298 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
15300 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
15304 char *keylen_pos
= strchr (saltbuf_pos
, '$');
15306 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15308 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
15310 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15314 char *keybuf_pos
= strchr (keylen_pos
, '$');
15316 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15318 uint keylen_len
= keybuf_pos
- keylen_pos
;
15320 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
15324 char *databuf_pos
= strchr (keybuf_pos
, '$');
15326 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15328 uint keybuf_len
= databuf_pos
- keybuf_pos
;
15330 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15334 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
15336 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
15342 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
15343 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
15344 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
15345 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
15347 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
15348 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
15349 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
15350 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
15352 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15353 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15354 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15355 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15357 salt
->salt_len
= 16;
15358 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
15360 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
15362 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
15365 return (PARSER_OK
);
15368 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15370 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
15372 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15374 u32
*digest
= (u32
*) hash_buf
->digest
;
15376 salt_t
*salt
= hash_buf
->salt
;
15382 // first is the N salt parameter
15384 char *N_pos
= input_buf
+ 6;
15386 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15390 salt
->scrypt_N
= atoi (N_pos
);
15394 char *r_pos
= strchr (N_pos
, ':');
15396 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15400 salt
->scrypt_r
= atoi (r_pos
);
15404 char *p_pos
= strchr (r_pos
, ':');
15406 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15410 salt
->scrypt_p
= atoi (p_pos
);
15414 char *saltbuf_pos
= strchr (p_pos
, ':');
15416 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15420 char *hash_pos
= strchr (saltbuf_pos
, ':');
15422 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15428 int salt_len_base64
= hash_pos
- saltbuf_pos
;
15430 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
15432 u8 tmp_buf
[33] = { 0 };
15434 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
15436 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15438 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
15440 salt
->salt_len
= tmp_len
;
15441 salt
->salt_iter
= 1;
15443 // digest - base64 decode
15445 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15447 tmp_len
= input_len
- (hash_pos
- input_buf
);
15449 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
15451 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
15453 memcpy (digest
, tmp_buf
, 32);
15455 return (PARSER_OK
);
15458 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15460 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
15462 u32
*digest
= (u32
*) hash_buf
->digest
;
15464 salt_t
*salt
= hash_buf
->salt
;
15470 char decrypted
[76] = { 0 }; // iv + hash
15472 juniper_decrypt_hash (input_buf
, decrypted
);
15474 char *md5crypt_hash
= decrypted
+ 12;
15476 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15478 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15480 char *salt_pos
= md5crypt_hash
+ 3;
15482 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15484 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15486 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15490 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15492 return (PARSER_OK
);
15495 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15497 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15499 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15501 u32
*digest
= (u32
*) hash_buf
->digest
;
15503 salt_t
*salt
= hash_buf
->salt
;
15505 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15511 // first is *raw* salt
15513 char *salt_pos
= input_buf
+ 3;
15515 char *hash_pos
= strchr (salt_pos
, '$');
15517 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15519 uint salt_len
= hash_pos
- salt_pos
;
15521 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15525 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15527 memcpy (salt_buf_ptr
, salt_pos
, 14);
15529 salt_buf_ptr
[17] = 0x01;
15530 salt_buf_ptr
[18] = 0x80;
15532 // add some stuff to normal salt to make sorted happy
15534 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15535 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15536 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15537 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15539 salt
->salt_len
= salt_len
;
15540 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15542 // base64 decode hash
15544 u8 tmp_buf
[100] = { 0 };
15546 uint hash_len
= input_len
- 3 - salt_len
- 1;
15548 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15550 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15552 memcpy (digest
, tmp_buf
, 32);
15554 digest
[0] = byte_swap_32 (digest
[0]);
15555 digest
[1] = byte_swap_32 (digest
[1]);
15556 digest
[2] = byte_swap_32 (digest
[2]);
15557 digest
[3] = byte_swap_32 (digest
[3]);
15558 digest
[4] = byte_swap_32 (digest
[4]);
15559 digest
[5] = byte_swap_32 (digest
[5]);
15560 digest
[6] = byte_swap_32 (digest
[6]);
15561 digest
[7] = byte_swap_32 (digest
[7]);
15563 return (PARSER_OK
);
15566 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15568 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15570 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15572 u32
*digest
= (u32
*) hash_buf
->digest
;
15574 salt_t
*salt
= hash_buf
->salt
;
15580 // first is *raw* salt
15582 char *salt_pos
= input_buf
+ 3;
15584 char *hash_pos
= strchr (salt_pos
, '$');
15586 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15588 uint salt_len
= hash_pos
- salt_pos
;
15590 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15592 salt
->salt_len
= salt_len
;
15595 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15597 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15598 salt_buf_ptr
[salt_len
] = 0;
15600 // base64 decode hash
15602 u8 tmp_buf
[100] = { 0 };
15604 uint hash_len
= input_len
- 3 - salt_len
- 1;
15606 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15608 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15610 memcpy (digest
, tmp_buf
, 32);
15613 salt
->scrypt_N
= 16384;
15614 salt
->scrypt_r
= 1;
15615 salt
->scrypt_p
= 1;
15616 salt
->salt_iter
= 1;
15618 return (PARSER_OK
);
15621 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15623 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15625 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15627 u32
*digest
= (u32
*) hash_buf
->digest
;
15629 salt_t
*salt
= hash_buf
->salt
;
15631 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15637 char *version_pos
= input_buf
+ 8 + 1;
15639 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15641 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15643 u32 version_len
= verifierHashSize_pos
- version_pos
;
15645 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15647 verifierHashSize_pos
++;
15649 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15651 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15653 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15655 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15659 char *saltSize_pos
= strchr (keySize_pos
, '*');
15661 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15663 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15665 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15669 char *osalt_pos
= strchr (saltSize_pos
, '*');
15671 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15673 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15675 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15679 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15681 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15683 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15685 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15687 encryptedVerifier_pos
++;
15689 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15691 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15693 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15695 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15697 encryptedVerifierHash_pos
++;
15699 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;
15701 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15703 const uint version
= atoi (version_pos
);
15705 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15707 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15709 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15711 const uint keySize
= atoi (keySize_pos
);
15713 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15715 office2007
->keySize
= keySize
;
15717 const uint saltSize
= atoi (saltSize_pos
);
15719 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15725 salt
->salt_len
= 16;
15726 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15728 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15729 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15730 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15731 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15737 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15738 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15739 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15740 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15742 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15743 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15744 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15745 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15746 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15752 digest
[0] = office2007
->encryptedVerifierHash
[0];
15753 digest
[1] = office2007
->encryptedVerifierHash
[1];
15754 digest
[2] = office2007
->encryptedVerifierHash
[2];
15755 digest
[3] = office2007
->encryptedVerifierHash
[3];
15757 return (PARSER_OK
);
15760 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15762 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15764 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15766 u32
*digest
= (u32
*) hash_buf
->digest
;
15768 salt_t
*salt
= hash_buf
->salt
;
15770 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15776 char *version_pos
= input_buf
+ 8 + 1;
15778 char *spinCount_pos
= strchr (version_pos
, '*');
15780 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15782 u32 version_len
= spinCount_pos
- version_pos
;
15784 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15788 char *keySize_pos
= strchr (spinCount_pos
, '*');
15790 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15792 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15794 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15798 char *saltSize_pos
= strchr (keySize_pos
, '*');
15800 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15802 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15804 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15808 char *osalt_pos
= strchr (saltSize_pos
, '*');
15810 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15812 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15814 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15818 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15820 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15822 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15824 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15826 encryptedVerifier_pos
++;
15828 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15830 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15832 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15834 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15836 encryptedVerifierHash_pos
++;
15838 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;
15840 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15842 const uint version
= atoi (version_pos
);
15844 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15846 const uint spinCount
= atoi (spinCount_pos
);
15848 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15850 const uint keySize
= atoi (keySize_pos
);
15852 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15854 const uint saltSize
= atoi (saltSize_pos
);
15856 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15862 salt
->salt_len
= 16;
15863 salt
->salt_iter
= spinCount
;
15865 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15866 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15867 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15868 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15874 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15875 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15876 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15877 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15879 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15880 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15881 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15882 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15883 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15884 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15885 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15886 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15892 digest
[0] = office2010
->encryptedVerifierHash
[0];
15893 digest
[1] = office2010
->encryptedVerifierHash
[1];
15894 digest
[2] = office2010
->encryptedVerifierHash
[2];
15895 digest
[3] = office2010
->encryptedVerifierHash
[3];
15897 return (PARSER_OK
);
15900 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15902 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15904 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15906 u32
*digest
= (u32
*) hash_buf
->digest
;
15908 salt_t
*salt
= hash_buf
->salt
;
15910 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15916 char *version_pos
= input_buf
+ 8 + 1;
15918 char *spinCount_pos
= strchr (version_pos
, '*');
15920 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15922 u32 version_len
= spinCount_pos
- version_pos
;
15924 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15928 char *keySize_pos
= strchr (spinCount_pos
, '*');
15930 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15932 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15934 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15938 char *saltSize_pos
= strchr (keySize_pos
, '*');
15940 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15942 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15944 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15948 char *osalt_pos
= strchr (saltSize_pos
, '*');
15950 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15952 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15954 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15958 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15960 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15962 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15964 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15966 encryptedVerifier_pos
++;
15968 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15970 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15972 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15974 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15976 encryptedVerifierHash_pos
++;
15978 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;
15980 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15982 const uint version
= atoi (version_pos
);
15984 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15986 const uint spinCount
= atoi (spinCount_pos
);
15988 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15990 const uint keySize
= atoi (keySize_pos
);
15992 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15994 const uint saltSize
= atoi (saltSize_pos
);
15996 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
16002 salt
->salt_len
= 16;
16003 salt
->salt_iter
= spinCount
;
16005 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16006 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16007 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16008 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16014 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16015 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16016 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16017 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16019 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16020 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16021 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16022 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16023 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16024 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
16025 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
16026 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
16032 digest
[0] = office2013
->encryptedVerifierHash
[0];
16033 digest
[1] = office2013
->encryptedVerifierHash
[1];
16034 digest
[2] = office2013
->encryptedVerifierHash
[2];
16035 digest
[3] = office2013
->encryptedVerifierHash
[3];
16037 return (PARSER_OK
);
16040 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16042 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
16044 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16046 u32
*digest
= (u32
*) hash_buf
->digest
;
16048 salt_t
*salt
= hash_buf
->salt
;
16050 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16056 char *version_pos
= input_buf
+ 11;
16058 char *osalt_pos
= strchr (version_pos
, '*');
16060 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16062 u32 version_len
= osalt_pos
- version_pos
;
16064 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16068 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16070 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16072 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16074 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16076 encryptedVerifier_pos
++;
16078 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16080 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16082 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16084 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16086 encryptedVerifierHash_pos
++;
16088 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16090 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16092 const uint version
= *version_pos
- 0x30;
16094 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16100 oldoffice01
->version
= version
;
16102 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16103 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16104 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16105 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16107 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16108 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16109 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16110 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16112 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16113 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16114 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16115 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16117 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16118 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16119 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16120 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16126 salt
->salt_len
= 16;
16128 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16129 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16130 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16131 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16133 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16134 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16135 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16136 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16138 // this is a workaround as office produces multiple documents with the same salt
16140 salt
->salt_len
+= 32;
16142 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16143 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16144 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16145 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16146 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16147 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16148 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16149 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16155 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
16156 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
16157 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
16158 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
16160 return (PARSER_OK
);
16163 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16165 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
16168 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16170 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
16172 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16174 u32
*digest
= (u32
*) hash_buf
->digest
;
16176 salt_t
*salt
= hash_buf
->salt
;
16178 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16184 char *version_pos
= input_buf
+ 11;
16186 char *osalt_pos
= strchr (version_pos
, '*');
16188 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16190 u32 version_len
= osalt_pos
- version_pos
;
16192 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16196 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16198 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16200 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16202 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16204 encryptedVerifier_pos
++;
16206 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16208 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16210 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16212 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16214 encryptedVerifierHash_pos
++;
16216 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16218 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16220 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16222 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16226 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16228 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16230 const uint version
= *version_pos
- 0x30;
16232 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16238 oldoffice01
->version
= version
;
16240 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16241 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16242 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16243 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16245 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16246 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16247 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16248 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16250 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16251 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16252 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16253 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16255 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16256 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16257 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16258 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16260 oldoffice01
->rc4key
[1] = 0;
16261 oldoffice01
->rc4key
[0] = 0;
16263 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16264 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16265 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16266 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16267 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16268 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16269 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16270 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16271 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16272 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16274 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
16275 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
16281 salt
->salt_len
= 16;
16283 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16284 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16285 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16286 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16288 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16289 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16290 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16291 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16293 // this is a workaround as office produces multiple documents with the same salt
16295 salt
->salt_len
+= 32;
16297 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16298 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16299 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16300 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16301 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16302 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16303 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16304 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16310 digest
[0] = oldoffice01
->rc4key
[0];
16311 digest
[1] = oldoffice01
->rc4key
[1];
16315 return (PARSER_OK
);
16318 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16320 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
16322 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16324 u32
*digest
= (u32
*) hash_buf
->digest
;
16326 salt_t
*salt
= hash_buf
->salt
;
16328 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16334 char *version_pos
= input_buf
+ 11;
16336 char *osalt_pos
= strchr (version_pos
, '*');
16338 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16340 u32 version_len
= osalt_pos
- version_pos
;
16342 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16346 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16348 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16350 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16352 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16354 encryptedVerifier_pos
++;
16356 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16358 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16360 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16362 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16364 encryptedVerifierHash_pos
++;
16366 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16368 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16370 const uint version
= *version_pos
- 0x30;
16372 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16378 oldoffice34
->version
= version
;
16380 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16381 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16382 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16383 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16385 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16386 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16387 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16388 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16390 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16391 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16392 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16393 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16394 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16396 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16397 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16398 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16399 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16400 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16406 salt
->salt_len
= 16;
16408 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16409 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16410 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16411 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16413 // this is a workaround as office produces multiple documents with the same salt
16415 salt
->salt_len
+= 32;
16417 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16418 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16419 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16420 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16421 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16422 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16423 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16424 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16430 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
16431 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
16432 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
16433 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
16435 return (PARSER_OK
);
16438 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16440 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16442 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
16445 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16447 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
16449 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16451 u32
*digest
= (u32
*) hash_buf
->digest
;
16453 salt_t
*salt
= hash_buf
->salt
;
16455 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16461 char *version_pos
= input_buf
+ 11;
16463 char *osalt_pos
= strchr (version_pos
, '*');
16465 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16467 u32 version_len
= osalt_pos
- version_pos
;
16469 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16473 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16475 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16477 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16479 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16481 encryptedVerifier_pos
++;
16483 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16485 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16487 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16489 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16491 encryptedVerifierHash_pos
++;
16493 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16495 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16497 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16499 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16503 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16505 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16507 const uint version
= *version_pos
- 0x30;
16509 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16515 oldoffice34
->version
= version
;
16517 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16518 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16519 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16520 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16522 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16523 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16524 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16525 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16527 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16528 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16529 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16530 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16531 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16533 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16534 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16535 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16536 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16537 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16539 oldoffice34
->rc4key
[1] = 0;
16540 oldoffice34
->rc4key
[0] = 0;
16542 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16543 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16544 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16545 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16546 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16547 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16548 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16549 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16550 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16551 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16553 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16554 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16560 salt
->salt_len
= 16;
16562 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16563 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16564 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16565 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16567 // this is a workaround as office produces multiple documents with the same salt
16569 salt
->salt_len
+= 32;
16571 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16572 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16573 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16574 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16575 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16576 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16577 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16578 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16584 digest
[0] = oldoffice34
->rc4key
[0];
16585 digest
[1] = oldoffice34
->rc4key
[1];
16589 return (PARSER_OK
);
16592 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16594 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16596 u32
*digest
= (u32
*) hash_buf
->digest
;
16598 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16599 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16600 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16601 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16603 digest
[0] = byte_swap_32 (digest
[0]);
16604 digest
[1] = byte_swap_32 (digest
[1]);
16605 digest
[2] = byte_swap_32 (digest
[2]);
16606 digest
[3] = byte_swap_32 (digest
[3]);
16608 return (PARSER_OK
);
16611 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16613 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16615 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16617 u32
*digest
= (u32
*) hash_buf
->digest
;
16619 salt_t
*salt
= hash_buf
->salt
;
16621 char *signature_pos
= input_buf
;
16623 char *salt_pos
= strchr (signature_pos
, '$');
16625 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16627 u32 signature_len
= salt_pos
- signature_pos
;
16629 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16633 char *hash_pos
= strchr (salt_pos
, '$');
16635 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16637 u32 salt_len
= hash_pos
- salt_pos
;
16639 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16643 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16645 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16647 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16648 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16649 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16650 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16651 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16653 digest
[0] -= SHA1M_A
;
16654 digest
[1] -= SHA1M_B
;
16655 digest
[2] -= SHA1M_C
;
16656 digest
[3] -= SHA1M_D
;
16657 digest
[4] -= SHA1M_E
;
16659 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16661 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16663 salt
->salt_len
= salt_len
;
16665 return (PARSER_OK
);
16668 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16670 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16672 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16674 u32
*digest
= (u32
*) hash_buf
->digest
;
16676 salt_t
*salt
= hash_buf
->salt
;
16678 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16684 char *iter_pos
= input_buf
+ 14;
16686 const int iter
= atoi (iter_pos
);
16688 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16690 salt
->salt_iter
= iter
- 1;
16692 char *salt_pos
= strchr (iter_pos
, '$');
16694 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16698 char *hash_pos
= strchr (salt_pos
, '$');
16700 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16702 const uint salt_len
= hash_pos
- salt_pos
;
16706 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16708 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16710 salt
->salt_len
= salt_len
;
16712 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16713 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16715 // add some stuff to normal salt to make sorted happy
16717 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16718 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16719 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16720 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16721 salt
->salt_buf
[4] = salt
->salt_iter
;
16723 // base64 decode hash
16725 u8 tmp_buf
[100] = { 0 };
16727 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16729 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16731 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16733 memcpy (digest
, tmp_buf
, 32);
16735 digest
[0] = byte_swap_32 (digest
[0]);
16736 digest
[1] = byte_swap_32 (digest
[1]);
16737 digest
[2] = byte_swap_32 (digest
[2]);
16738 digest
[3] = byte_swap_32 (digest
[3]);
16739 digest
[4] = byte_swap_32 (digest
[4]);
16740 digest
[5] = byte_swap_32 (digest
[5]);
16741 digest
[6] = byte_swap_32 (digest
[6]);
16742 digest
[7] = byte_swap_32 (digest
[7]);
16744 return (PARSER_OK
);
16747 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16749 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16751 u32
*digest
= (u32
*) hash_buf
->digest
;
16753 salt_t
*salt
= hash_buf
->salt
;
16755 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16756 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16760 digest
[0] = byte_swap_32 (digest
[0]);
16761 digest
[1] = byte_swap_32 (digest
[1]);
16763 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16764 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16765 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16767 char iter_c
= input_buf
[17];
16768 char iter_d
= input_buf
[19];
16770 // atm only defaults, let's see if there's more request
16771 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16772 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16774 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16776 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16777 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16778 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16779 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16781 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16782 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16783 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16784 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16786 salt
->salt_len
= 16;
16788 return (PARSER_OK
);
16791 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16793 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16795 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16797 u32
*digest
= (u32
*) hash_buf
->digest
;
16799 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16801 salt_t
*salt
= hash_buf
->salt
;
16803 char *salt_pos
= input_buf
+ 10;
16805 char *hash_pos
= strchr (salt_pos
, '$');
16807 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16809 uint salt_len
= hash_pos
- salt_pos
;
16813 uint hash_len
= input_len
- 10 - salt_len
- 1;
16815 // base64 decode salt
16817 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16819 u8 tmp_buf
[100] = { 0 };
16821 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16823 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16825 tmp_buf
[salt_len
] = 0x80;
16827 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16829 salt
->salt_len
= salt_len
;
16831 // base64 decode hash
16833 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16835 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16837 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16839 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16841 uint user_len
= hash_len
- 32;
16843 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16845 user_len
--; // skip the trailing space
16847 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16848 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16849 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16850 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16852 digest
[0] = byte_swap_32 (digest
[0]);
16853 digest
[1] = byte_swap_32 (digest
[1]);
16854 digest
[2] = byte_swap_32 (digest
[2]);
16855 digest
[3] = byte_swap_32 (digest
[3]);
16857 // store username for host only (output hash if cracked)
16859 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16860 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16862 return (PARSER_OK
);
16865 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16867 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16869 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16871 u32
*digest
= (u32
*) hash_buf
->digest
;
16873 salt_t
*salt
= hash_buf
->salt
;
16875 char *iter_pos
= input_buf
+ 10;
16877 u32 iter
= atoi (iter_pos
);
16881 return (PARSER_SALT_ITERATION
);
16884 iter
--; // first iteration is special
16886 salt
->salt_iter
= iter
;
16888 char *base64_pos
= strchr (iter_pos
, '}');
16890 if (base64_pos
== NULL
)
16892 return (PARSER_SIGNATURE_UNMATCHED
);
16897 // base64 decode salt
16899 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16901 u8 tmp_buf
[100] = { 0 };
16903 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16905 if (decoded_len
< 24)
16907 return (PARSER_SALT_LENGTH
);
16912 uint salt_len
= decoded_len
- 20;
16914 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16915 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16917 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16919 salt
->salt_len
= salt_len
;
16923 u32
*digest_ptr
= (u32
*) tmp_buf
;
16925 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16926 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16927 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16928 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16929 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16931 return (PARSER_OK
);
16934 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16936 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16938 u32
*digest
= (u32
*) hash_buf
->digest
;
16940 salt_t
*salt
= hash_buf
->salt
;
16942 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16943 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16944 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16945 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16946 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16948 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16950 uint salt_len
= input_len
- 40 - 1;
16952 char *salt_buf
= input_buf
+ 40 + 1;
16954 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16956 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16958 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16960 salt
->salt_len
= salt_len
;
16962 return (PARSER_OK
);
16965 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16967 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16969 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16971 u32
*digest
= (u32
*) hash_buf
->digest
;
16973 salt_t
*salt
= hash_buf
->salt
;
16975 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16981 char *V_pos
= input_buf
+ 5;
16983 char *R_pos
= strchr (V_pos
, '*');
16985 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16987 u32 V_len
= R_pos
- V_pos
;
16991 char *bits_pos
= strchr (R_pos
, '*');
16993 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16995 u32 R_len
= bits_pos
- R_pos
;
16999 char *P_pos
= strchr (bits_pos
, '*');
17001 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17003 u32 bits_len
= P_pos
- bits_pos
;
17007 char *enc_md_pos
= strchr (P_pos
, '*');
17009 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17011 u32 P_len
= enc_md_pos
- P_pos
;
17015 char *id_len_pos
= strchr (enc_md_pos
, '*');
17017 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17019 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17023 char *id_buf_pos
= strchr (id_len_pos
, '*');
17025 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17027 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17031 char *u_len_pos
= strchr (id_buf_pos
, '*');
17033 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17035 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17037 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17041 char *u_buf_pos
= strchr (u_len_pos
, '*');
17043 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17045 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17049 char *o_len_pos
= strchr (u_buf_pos
, '*');
17051 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17053 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17055 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17059 char *o_buf_pos
= strchr (o_len_pos
, '*');
17061 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17063 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17067 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;
17069 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17073 const int V
= atoi (V_pos
);
17074 const int R
= atoi (R_pos
);
17075 const int P
= atoi (P_pos
);
17077 if (V
!= 1) return (PARSER_SALT_VALUE
);
17078 if (R
!= 2) return (PARSER_SALT_VALUE
);
17080 const int enc_md
= atoi (enc_md_pos
);
17082 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17084 const int id_len
= atoi (id_len_pos
);
17085 const int u_len
= atoi (u_len_pos
);
17086 const int o_len
= atoi (o_len_pos
);
17088 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17089 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17090 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17092 const int bits
= atoi (bits_pos
);
17094 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17096 // copy data to esalt
17102 pdf
->enc_md
= enc_md
;
17104 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17105 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17106 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17107 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17108 pdf
->id_len
= id_len
;
17110 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17111 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17112 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17113 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17114 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17115 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17116 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17117 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17118 pdf
->u_len
= u_len
;
17120 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17121 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17122 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17123 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17124 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17125 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17126 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17127 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17128 pdf
->o_len
= o_len
;
17130 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17131 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17132 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17133 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17135 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17136 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17137 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17138 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17139 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17140 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17141 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17142 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17144 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17145 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17146 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17147 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17148 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17149 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17150 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17151 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17153 // we use ID for salt, maybe needs to change, we will see...
17155 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17156 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17157 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17158 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17159 salt
->salt_len
= pdf
->id_len
;
17161 digest
[0] = pdf
->u_buf
[0];
17162 digest
[1] = pdf
->u_buf
[1];
17163 digest
[2] = pdf
->u_buf
[2];
17164 digest
[3] = pdf
->u_buf
[3];
17166 return (PARSER_OK
);
17169 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17171 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
17174 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17176 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
17178 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17180 u32
*digest
= (u32
*) hash_buf
->digest
;
17182 salt_t
*salt
= hash_buf
->salt
;
17184 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17190 char *V_pos
= input_buf
+ 5;
17192 char *R_pos
= strchr (V_pos
, '*');
17194 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17196 u32 V_len
= R_pos
- V_pos
;
17200 char *bits_pos
= strchr (R_pos
, '*');
17202 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17204 u32 R_len
= bits_pos
- R_pos
;
17208 char *P_pos
= strchr (bits_pos
, '*');
17210 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17212 u32 bits_len
= P_pos
- bits_pos
;
17216 char *enc_md_pos
= strchr (P_pos
, '*');
17218 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17220 u32 P_len
= enc_md_pos
- P_pos
;
17224 char *id_len_pos
= strchr (enc_md_pos
, '*');
17226 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17228 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17232 char *id_buf_pos
= strchr (id_len_pos
, '*');
17234 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17236 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17240 char *u_len_pos
= strchr (id_buf_pos
, '*');
17242 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17244 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17246 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17250 char *u_buf_pos
= strchr (u_len_pos
, '*');
17252 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17254 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17258 char *o_len_pos
= strchr (u_buf_pos
, '*');
17260 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17262 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17264 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17268 char *o_buf_pos
= strchr (o_len_pos
, '*');
17270 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17272 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17276 char *rc4key_pos
= strchr (o_buf_pos
, ':');
17278 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17280 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
17282 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17286 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;
17288 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
17292 const int V
= atoi (V_pos
);
17293 const int R
= atoi (R_pos
);
17294 const int P
= atoi (P_pos
);
17296 if (V
!= 1) return (PARSER_SALT_VALUE
);
17297 if (R
!= 2) return (PARSER_SALT_VALUE
);
17299 const int enc_md
= atoi (enc_md_pos
);
17301 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17303 const int id_len
= atoi (id_len_pos
);
17304 const int u_len
= atoi (u_len_pos
);
17305 const int o_len
= atoi (o_len_pos
);
17307 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17308 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17309 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17311 const int bits
= atoi (bits_pos
);
17313 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17315 // copy data to esalt
17321 pdf
->enc_md
= enc_md
;
17323 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17324 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17325 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17326 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17327 pdf
->id_len
= id_len
;
17329 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17330 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17331 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17332 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17333 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17334 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17335 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17336 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17337 pdf
->u_len
= u_len
;
17339 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17340 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17341 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17342 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17343 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17344 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17345 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17346 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17347 pdf
->o_len
= o_len
;
17349 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17350 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17351 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17352 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17354 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17355 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17356 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17357 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17358 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17359 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17360 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17361 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17363 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17364 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17365 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17366 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17367 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17368 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17369 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17370 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17372 pdf
->rc4key
[1] = 0;
17373 pdf
->rc4key
[0] = 0;
17375 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
17376 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
17377 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
17378 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
17379 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
17380 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
17381 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
17382 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
17383 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
17384 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
17386 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
17387 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
17389 // we use ID for salt, maybe needs to change, we will see...
17391 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17392 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17393 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17394 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17395 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17396 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17397 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17398 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17399 salt
->salt_len
= pdf
->id_len
+ 16;
17401 digest
[0] = pdf
->rc4key
[0];
17402 digest
[1] = pdf
->rc4key
[1];
17406 return (PARSER_OK
);
17409 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17411 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
17413 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17415 u32
*digest
= (u32
*) hash_buf
->digest
;
17417 salt_t
*salt
= hash_buf
->salt
;
17419 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17425 char *V_pos
= input_buf
+ 5;
17427 char *R_pos
= strchr (V_pos
, '*');
17429 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17431 u32 V_len
= R_pos
- V_pos
;
17435 char *bits_pos
= strchr (R_pos
, '*');
17437 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17439 u32 R_len
= bits_pos
- R_pos
;
17443 char *P_pos
= strchr (bits_pos
, '*');
17445 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17447 u32 bits_len
= P_pos
- bits_pos
;
17451 char *enc_md_pos
= strchr (P_pos
, '*');
17453 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17455 u32 P_len
= enc_md_pos
- P_pos
;
17459 char *id_len_pos
= strchr (enc_md_pos
, '*');
17461 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17463 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17467 char *id_buf_pos
= strchr (id_len_pos
, '*');
17469 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17471 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17475 char *u_len_pos
= strchr (id_buf_pos
, '*');
17477 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17479 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17481 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17485 char *u_buf_pos
= strchr (u_len_pos
, '*');
17487 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17489 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17493 char *o_len_pos
= strchr (u_buf_pos
, '*');
17495 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17497 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17499 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17503 char *o_buf_pos
= strchr (o_len_pos
, '*');
17505 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17507 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17511 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;
17513 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17517 const int V
= atoi (V_pos
);
17518 const int R
= atoi (R_pos
);
17519 const int P
= atoi (P_pos
);
17523 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17524 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17526 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17528 const int id_len
= atoi (id_len_pos
);
17529 const int u_len
= atoi (u_len_pos
);
17530 const int o_len
= atoi (o_len_pos
);
17532 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17534 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17535 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17537 const int bits
= atoi (bits_pos
);
17539 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17545 enc_md
= atoi (enc_md_pos
);
17548 // copy data to esalt
17554 pdf
->enc_md
= enc_md
;
17556 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17557 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17558 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17559 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17563 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17564 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17565 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17566 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17569 pdf
->id_len
= id_len
;
17571 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17572 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17573 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17574 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17575 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17576 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17577 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17578 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17579 pdf
->u_len
= u_len
;
17581 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17582 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17583 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17584 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17585 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17586 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17587 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17588 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17589 pdf
->o_len
= o_len
;
17591 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17592 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17593 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17594 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17598 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17599 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17600 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17601 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17604 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17605 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17606 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17607 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17608 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17609 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17610 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17611 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17613 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17614 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17615 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17616 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17617 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17618 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17619 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17620 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17622 // precompute rc4 data for later use
17638 uint salt_pc_block
[32] = { 0 };
17640 char *salt_pc_ptr
= (char *) salt_pc_block
;
17642 memcpy (salt_pc_ptr
, padding
, 32);
17643 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17645 uint salt_pc_digest
[4] = { 0 };
17647 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17649 pdf
->rc4data
[0] = salt_pc_digest
[0];
17650 pdf
->rc4data
[1] = salt_pc_digest
[1];
17652 // we use ID for salt, maybe needs to change, we will see...
17654 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17655 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17656 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17657 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17658 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17659 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17660 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17661 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17662 salt
->salt_len
= pdf
->id_len
+ 16;
17664 salt
->salt_iter
= ROUNDS_PDF14
;
17666 digest
[0] = pdf
->u_buf
[0];
17667 digest
[1] = pdf
->u_buf
[1];
17671 return (PARSER_OK
);
17674 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17676 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17678 if (ret
!= PARSER_OK
)
17683 u32
*digest
= (u32
*) hash_buf
->digest
;
17685 salt_t
*salt
= hash_buf
->salt
;
17687 digest
[0] -= SHA256M_A
;
17688 digest
[1] -= SHA256M_B
;
17689 digest
[2] -= SHA256M_C
;
17690 digest
[3] -= SHA256M_D
;
17691 digest
[4] -= SHA256M_E
;
17692 digest
[5] -= SHA256M_F
;
17693 digest
[6] -= SHA256M_G
;
17694 digest
[7] -= SHA256M_H
;
17696 salt
->salt_buf
[2] = 0x80;
17698 return (PARSER_OK
);
17701 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17703 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17705 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17707 u32
*digest
= (u32
*) hash_buf
->digest
;
17709 salt_t
*salt
= hash_buf
->salt
;
17711 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17717 char *V_pos
= input_buf
+ 5;
17719 char *R_pos
= strchr (V_pos
, '*');
17721 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17723 u32 V_len
= R_pos
- V_pos
;
17727 char *bits_pos
= strchr (R_pos
, '*');
17729 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17731 u32 R_len
= bits_pos
- R_pos
;
17735 char *P_pos
= strchr (bits_pos
, '*');
17737 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17739 u32 bits_len
= P_pos
- bits_pos
;
17743 char *enc_md_pos
= strchr (P_pos
, '*');
17745 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17747 u32 P_len
= enc_md_pos
- P_pos
;
17751 char *id_len_pos
= strchr (enc_md_pos
, '*');
17753 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17755 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17759 char *id_buf_pos
= strchr (id_len_pos
, '*');
17761 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17763 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17767 char *u_len_pos
= strchr (id_buf_pos
, '*');
17769 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17771 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17775 char *u_buf_pos
= strchr (u_len_pos
, '*');
17777 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17779 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17783 char *o_len_pos
= strchr (u_buf_pos
, '*');
17785 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17787 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17791 char *o_buf_pos
= strchr (o_len_pos
, '*');
17793 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17795 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17799 char *last
= strchr (o_buf_pos
, '*');
17801 if (last
== NULL
) last
= input_buf
+ input_len
;
17803 u32 o_buf_len
= last
- o_buf_pos
;
17807 const int V
= atoi (V_pos
);
17808 const int R
= atoi (R_pos
);
17812 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17813 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17815 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17817 const int bits
= atoi (bits_pos
);
17819 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17821 int enc_md
= atoi (enc_md_pos
);
17823 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17825 const uint id_len
= atoi (id_len_pos
);
17826 const uint u_len
= atoi (u_len_pos
);
17827 const uint o_len
= atoi (o_len_pos
);
17829 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17830 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17831 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17832 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17833 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17834 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17835 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17836 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17838 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17839 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17840 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17842 // copy data to esalt
17844 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17846 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17848 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17851 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17852 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17854 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17855 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17857 salt
->salt_len
= 8;
17858 salt
->salt_iter
= ROUNDS_PDF17L8
;
17860 digest
[0] = pdf
->u_buf
[0];
17861 digest
[1] = pdf
->u_buf
[1];
17862 digest
[2] = pdf
->u_buf
[2];
17863 digest
[3] = pdf
->u_buf
[3];
17864 digest
[4] = pdf
->u_buf
[4];
17865 digest
[5] = pdf
->u_buf
[5];
17866 digest
[6] = pdf
->u_buf
[6];
17867 digest
[7] = pdf
->u_buf
[7];
17869 return (PARSER_OK
);
17872 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17874 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17876 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17878 u32
*digest
= (u32
*) hash_buf
->digest
;
17880 salt_t
*salt
= hash_buf
->salt
;
17882 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17890 char *iter_pos
= input_buf
+ 7;
17892 u32 iter
= atoi (iter_pos
);
17894 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17895 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17897 // first is *raw* salt
17899 char *salt_pos
= strchr (iter_pos
, ':');
17901 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17905 char *hash_pos
= strchr (salt_pos
, ':');
17907 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17909 u32 salt_len
= hash_pos
- salt_pos
;
17911 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17915 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17917 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17921 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17923 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17925 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17927 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17928 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17930 salt
->salt_len
= salt_len
;
17931 salt
->salt_iter
= iter
- 1;
17935 u8 tmp_buf
[100] = { 0 };
17937 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17939 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17941 memcpy (digest
, tmp_buf
, 16);
17943 digest
[0] = byte_swap_32 (digest
[0]);
17944 digest
[1] = byte_swap_32 (digest
[1]);
17945 digest
[2] = byte_swap_32 (digest
[2]);
17946 digest
[3] = byte_swap_32 (digest
[3]);
17948 // add some stuff to normal salt to make sorted happy
17950 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17951 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17952 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17953 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17954 salt
->salt_buf
[4] = salt
->salt_iter
;
17956 return (PARSER_OK
);
17959 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17961 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17963 u32
*digest
= (u32
*) hash_buf
->digest
;
17965 salt_t
*salt
= hash_buf
->salt
;
17967 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17968 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17969 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17970 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17972 digest
[0] = byte_swap_32 (digest
[0]);
17973 digest
[1] = byte_swap_32 (digest
[1]);
17974 digest
[2] = byte_swap_32 (digest
[2]);
17975 digest
[3] = byte_swap_32 (digest
[3]);
17977 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17979 uint salt_len
= input_len
- 32 - 1;
17981 char *salt_buf
= input_buf
+ 32 + 1;
17983 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17985 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17987 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17989 salt
->salt_len
= salt_len
;
17991 return (PARSER_OK
);
17994 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17996 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17998 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18000 u32
*digest
= (u32
*) hash_buf
->digest
;
18002 salt_t
*salt
= hash_buf
->salt
;
18004 char *user_pos
= input_buf
+ 10;
18006 char *salt_pos
= strchr (user_pos
, '*');
18008 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18012 char *hash_pos
= strchr (salt_pos
, '*');
18016 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18018 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
18020 uint user_len
= salt_pos
- user_pos
- 1;
18022 uint salt_len
= hash_pos
- salt_pos
- 1;
18024 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
18030 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18031 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18032 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18033 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18035 digest
[0] = byte_swap_32 (digest
[0]);
18036 digest
[1] = byte_swap_32 (digest
[1]);
18037 digest
[2] = byte_swap_32 (digest
[2]);
18038 digest
[3] = byte_swap_32 (digest
[3]);
18040 digest
[0] -= MD5M_A
;
18041 digest
[1] -= MD5M_B
;
18042 digest
[2] -= MD5M_C
;
18043 digest
[3] -= MD5M_D
;
18049 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18051 // first 4 bytes are the "challenge"
18053 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
18054 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
18055 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
18056 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
18058 // append the user name
18060 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
18062 salt
->salt_len
= 4 + user_len
;
18064 return (PARSER_OK
);
18067 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18069 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
18071 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18073 u32
*digest
= (u32
*) hash_buf
->digest
;
18075 salt_t
*salt
= hash_buf
->salt
;
18077 char *salt_pos
= input_buf
+ 9;
18079 char *hash_pos
= strchr (salt_pos
, '*');
18081 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18085 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18087 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
18089 uint salt_len
= hash_pos
- salt_pos
- 1;
18091 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
18097 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18098 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18099 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18100 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18101 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18107 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18109 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18111 salt
->salt_len
= salt_len
;
18113 return (PARSER_OK
);
18116 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18118 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
18120 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18122 u32
*digest
= (u32
*) hash_buf
->digest
;
18124 salt_t
*salt
= hash_buf
->salt
;
18126 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
18132 char *cry_master_len_pos
= input_buf
+ 9;
18134 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
18136 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18138 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
18140 cry_master_buf_pos
++;
18142 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
18144 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18146 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
18148 cry_salt_len_pos
++;
18150 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
18152 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18154 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
18156 cry_salt_buf_pos
++;
18158 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
18160 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18162 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
18166 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
18168 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18170 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
18174 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
18176 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18178 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
18182 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
18184 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18186 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
18188 public_key_len_pos
++;
18190 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
18192 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18194 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
18196 public_key_buf_pos
++;
18198 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;
18200 const uint cry_master_len
= atoi (cry_master_len_pos
);
18201 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
18202 const uint ckey_len
= atoi (ckey_len_pos
);
18203 const uint public_key_len
= atoi (public_key_len_pos
);
18205 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
18206 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
18207 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
18208 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
18210 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
18212 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
18214 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
18217 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
18219 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
18221 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
18224 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
18226 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
18228 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
18231 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
18232 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
18233 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
18236 * store digest (should be unique enought, hopefully)
18239 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
18240 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
18241 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
18242 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
18248 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
18250 const uint cry_rounds
= atoi (cry_rounds_pos
);
18252 salt
->salt_iter
= cry_rounds
- 1;
18254 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18256 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
18258 salt
->salt_len
= salt_len
;
18260 return (PARSER_OK
);
18263 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18265 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
18267 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18269 u32
*digest
= (u32
*) hash_buf
->digest
;
18271 salt_t
*salt
= hash_buf
->salt
;
18273 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
18275 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
18277 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
18279 memcpy (temp_input_buf
, input_buf
, input_len
);
18283 char *URI_server_pos
= temp_input_buf
+ 6;
18285 char *URI_client_pos
= strchr (URI_server_pos
, '*');
18287 if (URI_client_pos
== NULL
)
18289 myfree (temp_input_buf
);
18291 return (PARSER_SEPARATOR_UNMATCHED
);
18294 URI_client_pos
[0] = 0;
18297 uint URI_server_len
= strlen (URI_server_pos
);
18299 if (URI_server_len
> 512)
18301 myfree (temp_input_buf
);
18303 return (PARSER_SALT_LENGTH
);
18308 char *user_pos
= strchr (URI_client_pos
, '*');
18310 if (user_pos
== NULL
)
18312 myfree (temp_input_buf
);
18314 return (PARSER_SEPARATOR_UNMATCHED
);
18320 uint URI_client_len
= strlen (URI_client_pos
);
18322 if (URI_client_len
> 512)
18324 myfree (temp_input_buf
);
18326 return (PARSER_SALT_LENGTH
);
18331 char *realm_pos
= strchr (user_pos
, '*');
18333 if (realm_pos
== NULL
)
18335 myfree (temp_input_buf
);
18337 return (PARSER_SEPARATOR_UNMATCHED
);
18343 uint user_len
= strlen (user_pos
);
18345 if (user_len
> 116)
18347 myfree (temp_input_buf
);
18349 return (PARSER_SALT_LENGTH
);
18354 char *method_pos
= strchr (realm_pos
, '*');
18356 if (method_pos
== NULL
)
18358 myfree (temp_input_buf
);
18360 return (PARSER_SEPARATOR_UNMATCHED
);
18366 uint realm_len
= strlen (realm_pos
);
18368 if (realm_len
> 116)
18370 myfree (temp_input_buf
);
18372 return (PARSER_SALT_LENGTH
);
18377 char *URI_prefix_pos
= strchr (method_pos
, '*');
18379 if (URI_prefix_pos
== NULL
)
18381 myfree (temp_input_buf
);
18383 return (PARSER_SEPARATOR_UNMATCHED
);
18386 URI_prefix_pos
[0] = 0;
18389 uint method_len
= strlen (method_pos
);
18391 if (method_len
> 246)
18393 myfree (temp_input_buf
);
18395 return (PARSER_SALT_LENGTH
);
18400 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
18402 if (URI_resource_pos
== NULL
)
18404 myfree (temp_input_buf
);
18406 return (PARSER_SEPARATOR_UNMATCHED
);
18409 URI_resource_pos
[0] = 0;
18410 URI_resource_pos
++;
18412 uint URI_prefix_len
= strlen (URI_prefix_pos
);
18414 if (URI_prefix_len
> 245)
18416 myfree (temp_input_buf
);
18418 return (PARSER_SALT_LENGTH
);
18423 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
18425 if (URI_suffix_pos
== NULL
)
18427 myfree (temp_input_buf
);
18429 return (PARSER_SEPARATOR_UNMATCHED
);
18432 URI_suffix_pos
[0] = 0;
18435 uint URI_resource_len
= strlen (URI_resource_pos
);
18437 if (URI_resource_len
< 1 || URI_resource_len
> 246)
18439 myfree (temp_input_buf
);
18441 return (PARSER_SALT_LENGTH
);
18446 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
18448 if (nonce_pos
== NULL
)
18450 myfree (temp_input_buf
);
18452 return (PARSER_SEPARATOR_UNMATCHED
);
18458 uint URI_suffix_len
= strlen (URI_suffix_pos
);
18460 if (URI_suffix_len
> 245)
18462 myfree (temp_input_buf
);
18464 return (PARSER_SALT_LENGTH
);
18469 char *nonce_client_pos
= strchr (nonce_pos
, '*');
18471 if (nonce_client_pos
== NULL
)
18473 myfree (temp_input_buf
);
18475 return (PARSER_SEPARATOR_UNMATCHED
);
18478 nonce_client_pos
[0] = 0;
18479 nonce_client_pos
++;
18481 uint nonce_len
= strlen (nonce_pos
);
18483 if (nonce_len
< 1 || nonce_len
> 50)
18485 myfree (temp_input_buf
);
18487 return (PARSER_SALT_LENGTH
);
18492 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18494 if (nonce_count_pos
== NULL
)
18496 myfree (temp_input_buf
);
18498 return (PARSER_SEPARATOR_UNMATCHED
);
18501 nonce_count_pos
[0] = 0;
18504 uint nonce_client_len
= strlen (nonce_client_pos
);
18506 if (nonce_client_len
> 50)
18508 myfree (temp_input_buf
);
18510 return (PARSER_SALT_LENGTH
);
18515 char *qop_pos
= strchr (nonce_count_pos
, '*');
18517 if (qop_pos
== NULL
)
18519 myfree (temp_input_buf
);
18521 return (PARSER_SEPARATOR_UNMATCHED
);
18527 uint nonce_count_len
= strlen (nonce_count_pos
);
18529 if (nonce_count_len
> 50)
18531 myfree (temp_input_buf
);
18533 return (PARSER_SALT_LENGTH
);
18538 char *directive_pos
= strchr (qop_pos
, '*');
18540 if (directive_pos
== NULL
)
18542 myfree (temp_input_buf
);
18544 return (PARSER_SEPARATOR_UNMATCHED
);
18547 directive_pos
[0] = 0;
18550 uint qop_len
= strlen (qop_pos
);
18554 myfree (temp_input_buf
);
18556 return (PARSER_SALT_LENGTH
);
18561 char *digest_pos
= strchr (directive_pos
, '*');
18563 if (digest_pos
== NULL
)
18565 myfree (temp_input_buf
);
18567 return (PARSER_SEPARATOR_UNMATCHED
);
18573 uint directive_len
= strlen (directive_pos
);
18575 if (directive_len
!= 3)
18577 myfree (temp_input_buf
);
18579 return (PARSER_SALT_LENGTH
);
18582 if (memcmp (directive_pos
, "MD5", 3))
18584 log_info ("ERROR: only the MD5 directive is currently supported\n");
18586 myfree (temp_input_buf
);
18588 return (PARSER_SIP_AUTH_DIRECTIVE
);
18592 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18597 uint md5_max_len
= 4 * 64;
18599 uint md5_remaining_len
= md5_max_len
;
18601 uint tmp_md5_buf
[64] = { 0 };
18603 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18605 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18607 md5_len
+= method_len
+ 1;
18608 tmp_md5_ptr
+= method_len
+ 1;
18610 if (URI_prefix_len
> 0)
18612 md5_remaining_len
= md5_max_len
- md5_len
;
18614 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18616 md5_len
+= URI_prefix_len
+ 1;
18617 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18620 md5_remaining_len
= md5_max_len
- md5_len
;
18622 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18624 md5_len
+= URI_resource_len
;
18625 tmp_md5_ptr
+= URI_resource_len
;
18627 if (URI_suffix_len
> 0)
18629 md5_remaining_len
= md5_max_len
- md5_len
;
18631 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18633 md5_len
+= 1 + URI_suffix_len
;
18636 uint tmp_digest
[4] = { 0 };
18638 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18640 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18641 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18642 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18643 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18649 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18651 uint esalt_len
= 0;
18653 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18655 // there are 2 possibilities for the esalt:
18657 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18659 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18661 if (esalt_len
> max_esalt_len
)
18663 myfree (temp_input_buf
);
18665 return (PARSER_SALT_LENGTH
);
18668 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18680 esalt_len
= 1 + nonce_len
+ 1 + 32;
18682 if (esalt_len
> max_esalt_len
)
18684 myfree (temp_input_buf
);
18686 return (PARSER_SALT_LENGTH
);
18689 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18697 // add 0x80 to esalt
18699 esalt_buf_ptr
[esalt_len
] = 0x80;
18701 sip
->esalt_len
= esalt_len
;
18707 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18709 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18711 uint max_salt_len
= 119;
18713 if (salt_len
> max_salt_len
)
18715 myfree (temp_input_buf
);
18717 return (PARSER_SALT_LENGTH
);
18720 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18722 sip
->salt_len
= salt_len
;
18725 * fake salt (for sorting)
18728 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18732 uint fake_salt_len
= salt_len
;
18734 if (fake_salt_len
> max_salt_len
)
18736 fake_salt_len
= max_salt_len
;
18739 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18741 salt
->salt_len
= fake_salt_len
;
18747 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18748 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18749 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18750 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18752 digest
[0] = byte_swap_32 (digest
[0]);
18753 digest
[1] = byte_swap_32 (digest
[1]);
18754 digest
[2] = byte_swap_32 (digest
[2]);
18755 digest
[3] = byte_swap_32 (digest
[3]);
18757 myfree (temp_input_buf
);
18759 return (PARSER_OK
);
18762 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18764 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18766 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18768 u32
*digest
= (u32
*) hash_buf
->digest
;
18770 salt_t
*salt
= hash_buf
->salt
;
18774 char *digest_pos
= input_buf
;
18776 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18783 char *salt_buf
= input_buf
+ 8 + 1;
18787 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18789 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18791 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18793 salt
->salt_len
= salt_len
;
18795 return (PARSER_OK
);
18798 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18800 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18802 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18804 u32
*digest
= (u32
*) hash_buf
->digest
;
18806 salt_t
*salt
= hash_buf
->salt
;
18808 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18814 char *p_buf_pos
= input_buf
+ 4;
18816 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18818 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18820 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18822 NumCyclesPower_pos
++;
18824 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18826 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18828 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18832 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18834 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18836 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18840 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18842 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18844 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18848 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18850 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18852 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18856 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18858 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18860 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18864 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18866 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18868 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18872 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18874 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18876 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18880 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18882 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18884 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18888 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;
18890 const uint iter
= atoi (NumCyclesPower_pos
);
18891 const uint crc
= atoi (crc_buf_pos
);
18892 const uint p_buf
= atoi (p_buf_pos
);
18893 const uint salt_len
= atoi (salt_len_pos
);
18894 const uint iv_len
= atoi (iv_len_pos
);
18895 const uint unpack_size
= atoi (unpack_size_pos
);
18896 const uint data_len
= atoi (data_len_pos
);
18902 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18903 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18905 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18907 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18909 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18915 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18916 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18917 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18918 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18920 seven_zip
->iv_len
= iv_len
;
18922 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18924 seven_zip
->salt_len
= 0;
18926 seven_zip
->crc
= crc
;
18928 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18930 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18932 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18935 seven_zip
->data_len
= data_len
;
18937 seven_zip
->unpack_size
= unpack_size
;
18941 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18942 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18943 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18944 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18946 salt
->salt_len
= 16;
18948 salt
->salt_sign
[0] = iter
;
18950 salt
->salt_iter
= 1 << iter
;
18961 return (PARSER_OK
);
18964 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18966 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18968 u32
*digest
= (u32
*) hash_buf
->digest
;
18970 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18971 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18972 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18973 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18974 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18975 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18976 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18977 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18979 digest
[0] = byte_swap_32 (digest
[0]);
18980 digest
[1] = byte_swap_32 (digest
[1]);
18981 digest
[2] = byte_swap_32 (digest
[2]);
18982 digest
[3] = byte_swap_32 (digest
[3]);
18983 digest
[4] = byte_swap_32 (digest
[4]);
18984 digest
[5] = byte_swap_32 (digest
[5]);
18985 digest
[6] = byte_swap_32 (digest
[6]);
18986 digest
[7] = byte_swap_32 (digest
[7]);
18988 return (PARSER_OK
);
18991 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18993 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18995 u32
*digest
= (u32
*) hash_buf
->digest
;
18997 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18998 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18999 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
19000 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
19001 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
19002 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
19003 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
19004 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
19005 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
19006 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
19007 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
19008 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
19009 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
19010 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
19011 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
19012 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
19014 digest
[ 0] = byte_swap_32 (digest
[ 0]);
19015 digest
[ 1] = byte_swap_32 (digest
[ 1]);
19016 digest
[ 2] = byte_swap_32 (digest
[ 2]);
19017 digest
[ 3] = byte_swap_32 (digest
[ 3]);
19018 digest
[ 4] = byte_swap_32 (digest
[ 4]);
19019 digest
[ 5] = byte_swap_32 (digest
[ 5]);
19020 digest
[ 6] = byte_swap_32 (digest
[ 6]);
19021 digest
[ 7] = byte_swap_32 (digest
[ 7]);
19022 digest
[ 8] = byte_swap_32 (digest
[ 8]);
19023 digest
[ 9] = byte_swap_32 (digest
[ 9]);
19024 digest
[10] = byte_swap_32 (digest
[10]);
19025 digest
[11] = byte_swap_32 (digest
[11]);
19026 digest
[12] = byte_swap_32 (digest
[12]);
19027 digest
[13] = byte_swap_32 (digest
[13]);
19028 digest
[14] = byte_swap_32 (digest
[14]);
19029 digest
[15] = byte_swap_32 (digest
[15]);
19031 return (PARSER_OK
);
19034 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19036 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
19038 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
19040 u32
*digest
= (u32
*) hash_buf
->digest
;
19042 salt_t
*salt
= hash_buf
->salt
;
19044 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
19052 char *iter_pos
= input_buf
+ 4;
19054 u32 iter
= atoi (iter_pos
);
19056 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19057 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19059 // first is *raw* salt
19061 char *salt_pos
= strchr (iter_pos
, ':');
19063 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19067 char *hash_pos
= strchr (salt_pos
, ':');
19069 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19071 u32 salt_len
= hash_pos
- salt_pos
;
19073 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19077 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19079 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19083 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
19085 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19087 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19089 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19090 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19092 salt
->salt_len
= salt_len
;
19093 salt
->salt_iter
= iter
- 1;
19097 u8 tmp_buf
[100] = { 0 };
19099 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19101 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19103 memcpy (digest
, tmp_buf
, 16);
19105 // add some stuff to normal salt to make sorted happy
19107 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
19108 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
19109 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
19110 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
19111 salt
->salt_buf
[4] = salt
->salt_iter
;
19113 return (PARSER_OK
);
19116 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19118 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
19120 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
19122 u32
*digest
= (u32
*) hash_buf
->digest
;
19124 salt_t
*salt
= hash_buf
->salt
;
19126 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
19134 char *iter_pos
= input_buf
+ 5;
19136 u32 iter
= atoi (iter_pos
);
19138 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19139 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19141 // first is *raw* salt
19143 char *salt_pos
= strchr (iter_pos
, ':');
19145 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19149 char *hash_pos
= strchr (salt_pos
, ':');
19151 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19153 u32 salt_len
= hash_pos
- salt_pos
;
19155 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19159 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19161 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19165 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
19167 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19169 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19171 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19172 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19174 salt
->salt_len
= salt_len
;
19175 salt
->salt_iter
= iter
- 1;
19179 u8 tmp_buf
[100] = { 0 };
19181 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19183 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19185 memcpy (digest
, tmp_buf
, 16);
19187 digest
[0] = byte_swap_32 (digest
[0]);
19188 digest
[1] = byte_swap_32 (digest
[1]);
19189 digest
[2] = byte_swap_32 (digest
[2]);
19190 digest
[3] = byte_swap_32 (digest
[3]);
19192 // add some stuff to normal salt to make sorted happy
19194 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
19195 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
19196 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
19197 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
19198 salt
->salt_buf
[4] = salt
->salt_iter
;
19200 return (PARSER_OK
);
19203 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19205 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
19207 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
19209 u64
*digest
= (u64
*) hash_buf
->digest
;
19211 salt_t
*salt
= hash_buf
->salt
;
19213 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
19221 char *iter_pos
= input_buf
+ 7;
19223 u32 iter
= atoi (iter_pos
);
19225 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19226 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19228 // first is *raw* salt
19230 char *salt_pos
= strchr (iter_pos
, ':');
19232 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19236 char *hash_pos
= strchr (salt_pos
, ':');
19238 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19240 u32 salt_len
= hash_pos
- salt_pos
;
19242 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19246 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19248 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19252 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
19254 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19256 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19258 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19259 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19261 salt
->salt_len
= salt_len
;
19262 salt
->salt_iter
= iter
- 1;
19266 u8 tmp_buf
[100] = { 0 };
19268 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19270 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19272 memcpy (digest
, tmp_buf
, 64);
19274 digest
[0] = byte_swap_64 (digest
[0]);
19275 digest
[1] = byte_swap_64 (digest
[1]);
19276 digest
[2] = byte_swap_64 (digest
[2]);
19277 digest
[3] = byte_swap_64 (digest
[3]);
19278 digest
[4] = byte_swap_64 (digest
[4]);
19279 digest
[5] = byte_swap_64 (digest
[5]);
19280 digest
[6] = byte_swap_64 (digest
[6]);
19281 digest
[7] = byte_swap_64 (digest
[7]);
19283 // add some stuff to normal salt to make sorted happy
19285 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
19286 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
19287 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
19288 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
19289 salt
->salt_buf
[4] = salt
->salt_iter
;
19291 return (PARSER_OK
);
19294 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19296 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
19298 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
19300 uint
*digest
= (uint
*) hash_buf
->digest
;
19302 salt_t
*salt
= hash_buf
->salt
;
19308 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
19310 char *hash_pos
= strchr (salt_pos
, '$');
19312 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19314 u32 salt_len
= hash_pos
- salt_pos
;
19316 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19320 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
19322 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
19326 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
19327 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
19345 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19346 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19348 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
19349 salt
->salt_len
= 8;
19351 return (PARSER_OK
);
19354 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19356 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
19358 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19360 unsigned char c19
= itoa64_to_int (input_buf
[19]);
19362 if (c19
& 3) return (PARSER_HASH_VALUE
);
19364 salt_t
*salt
= hash_buf
->salt
;
19366 u32
*digest
= (u32
*) hash_buf
->digest
;
19370 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
19371 | itoa64_to_int (input_buf
[2]) << 6
19372 | itoa64_to_int (input_buf
[3]) << 12
19373 | itoa64_to_int (input_buf
[4]) << 18;
19377 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
19378 | itoa64_to_int (input_buf
[6]) << 6
19379 | itoa64_to_int (input_buf
[7]) << 12
19380 | itoa64_to_int (input_buf
[8]) << 18;
19382 salt
->salt_len
= 4;
19384 u8 tmp_buf
[100] = { 0 };
19386 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
19388 memcpy (digest
, tmp_buf
, 8);
19392 IP (digest
[0], digest
[1], tt
);
19394 digest
[0] = rotr32 (digest
[0], 31);
19395 digest
[1] = rotr32 (digest
[1], 31);
19399 return (PARSER_OK
);
19402 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19404 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
19406 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
19408 u32
*digest
= (u32
*) hash_buf
->digest
;
19410 salt_t
*salt
= hash_buf
->salt
;
19416 char *type_pos
= input_buf
+ 6 + 1;
19418 char *salt_pos
= strchr (type_pos
, '*');
19420 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19422 u32 type_len
= salt_pos
- type_pos
;
19424 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
19428 char *crypted_pos
= strchr (salt_pos
, '*');
19430 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19432 u32 salt_len
= crypted_pos
- salt_pos
;
19434 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19438 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
19440 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
19446 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19447 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19449 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19450 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19452 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
19453 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
19454 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
19455 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
19457 salt
->salt_len
= 24;
19458 salt
->salt_iter
= ROUNDS_RAR3
;
19460 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
19461 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
19463 digest
[0] = 0xc43d7b00;
19464 digest
[1] = 0x40070000;
19468 return (PARSER_OK
);
19471 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19473 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19475 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19477 u32
*digest
= (u32
*) hash_buf
->digest
;
19479 salt_t
*salt
= hash_buf
->salt
;
19481 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19487 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19489 char *param1_pos
= strchr (param0_pos
, '$');
19491 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19493 u32 param0_len
= param1_pos
- param0_pos
;
19497 char *param2_pos
= strchr (param1_pos
, '$');
19499 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19501 u32 param1_len
= param2_pos
- param1_pos
;
19505 char *param3_pos
= strchr (param2_pos
, '$');
19507 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19509 u32 param2_len
= param3_pos
- param2_pos
;
19513 char *param4_pos
= strchr (param3_pos
, '$');
19515 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19517 u32 param3_len
= param4_pos
- param3_pos
;
19521 char *param5_pos
= strchr (param4_pos
, '$');
19523 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19525 u32 param4_len
= param5_pos
- param4_pos
;
19529 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19531 char *salt_buf
= param1_pos
;
19532 char *iv
= param3_pos
;
19533 char *pswcheck
= param5_pos
;
19535 const uint salt_len
= atoi (param0_pos
);
19536 const uint iterations
= atoi (param2_pos
);
19537 const uint pswcheck_len
= atoi (param4_pos
);
19543 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19544 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19545 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19547 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19548 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19549 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19555 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19556 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19557 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19558 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19560 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19561 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19562 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19563 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19565 salt
->salt_len
= 16;
19567 salt
->salt_sign
[0] = iterations
;
19569 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19575 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19576 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19580 return (PARSER_OK
);
19583 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19585 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19587 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19589 u32
*digest
= (u32
*) hash_buf
->digest
;
19591 salt_t
*salt
= hash_buf
->salt
;
19593 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19600 char *account_pos
= input_buf
+ 11 + 1;
19606 if (account_pos
[0] == '*')
19610 data_pos
= strchr (account_pos
, '*');
19615 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19617 uint account_len
= data_pos
- account_pos
+ 1;
19619 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19624 data_len
= input_len
- 11 - 1 - account_len
- 2;
19626 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19630 /* assume $krb5tgs$23$checksum$edata2 */
19631 data_pos
= account_pos
;
19633 memcpy (krb5tgs
->account_info
, "**", 3);
19635 data_len
= input_len
- 11 - 1 - 1;
19638 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19640 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19642 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19644 const char p0
= data_pos
[i
+ 0];
19645 const char p1
= data_pos
[i
+ 1];
19647 *checksum_ptr
++ = hex_convert (p1
) << 0
19648 | hex_convert (p0
) << 4;
19651 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19653 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19656 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19658 const char p0
= data_pos
[i
+ 0];
19659 const char p1
= data_pos
[i
+ 1];
19660 *edata_ptr
++ = hex_convert (p1
) << 0
19661 | hex_convert (p0
) << 4;
19664 /* this is needed for hmac_md5 */
19665 *edata_ptr
++ = 0x80;
19667 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19668 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19669 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19670 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19672 salt
->salt_len
= 32;
19674 digest
[0] = krb5tgs
->checksum
[0];
19675 digest
[1] = krb5tgs
->checksum
[1];
19676 digest
[2] = krb5tgs
->checksum
[2];
19677 digest
[3] = krb5tgs
->checksum
[3];
19679 return (PARSER_OK
);
19682 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19684 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19686 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19688 u32
*digest
= (u32
*) hash_buf
->digest
;
19690 salt_t
*salt
= hash_buf
->salt
;
19697 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19701 char *wrapped_key_pos
;
19705 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19707 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19709 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19711 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19716 data_pos
= salt_pos
;
19718 wrapped_key_pos
= strchr (salt_pos
, '*');
19720 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19722 uint salt_len
= wrapped_key_pos
- salt_pos
;
19724 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19729 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19731 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19733 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19734 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19735 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19736 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19740 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19741 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19742 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19743 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19744 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19745 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19747 salt
->salt_len
= 40;
19749 digest
[0] = salt
->salt_buf
[0];
19750 digest
[1] = salt
->salt_buf
[1];
19751 digest
[2] = salt
->salt_buf
[2];
19752 digest
[3] = salt
->salt_buf
[3];
19754 return (PARSER_OK
);
19757 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19759 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19761 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19763 u32
*digest
= (u32
*) hash_buf
->digest
;
19765 salt_t
*salt
= hash_buf
->salt
;
19767 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19777 char *algorithm_pos
;
19779 char *final_random_seed_pos
;
19780 u32 final_random_seed_len
;
19782 char *transf_random_seed_pos
;
19783 u32 transf_random_seed_len
;
19788 /* default is no keyfile provided */
19789 char *keyfile_len_pos
;
19790 u32 keyfile_len
= 0;
19791 u32 is_keyfile_present
= 0;
19792 char *keyfile_inline_pos
;
19795 /* specific to version 1 */
19796 char *contents_len_pos
;
19798 char *contents_pos
;
19800 /* specific to version 2 */
19801 char *expected_bytes_pos
;
19802 u32 expected_bytes_len
;
19804 char *contents_hash_pos
;
19805 u32 contents_hash_len
;
19807 version_pos
= input_buf
+ 8 + 1 + 1;
19809 keepass
->version
= atoi (version_pos
);
19811 rounds_pos
= strchr (version_pos
, '*');
19813 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19817 salt
->salt_iter
= (atoi (rounds_pos
));
19819 algorithm_pos
= strchr (rounds_pos
, '*');
19821 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19825 keepass
->algorithm
= atoi (algorithm_pos
);
19827 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19829 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19831 final_random_seed_pos
++;
19833 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19834 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19835 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19836 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19838 if (keepass
->version
== 2)
19840 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19841 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19842 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19843 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19846 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19848 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19850 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19852 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19853 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19855 transf_random_seed_pos
++;
19857 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19858 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19859 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19860 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19861 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19862 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19863 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19864 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19866 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19868 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19870 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19872 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19876 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19877 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19878 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19879 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19881 if (keepass
->version
== 1)
19883 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19885 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19887 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19889 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19891 contents_hash_pos
++;
19893 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19894 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19895 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19896 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19897 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19898 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19899 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19900 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19902 /* get length of contents following */
19903 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19905 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19907 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19909 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19913 u32 inline_flag
= atoi (inline_flag_pos
);
19915 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19917 contents_len_pos
= strchr (inline_flag_pos
, '*');
19919 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19921 contents_len_pos
++;
19923 contents_len
= atoi (contents_len_pos
);
19925 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19927 contents_pos
= strchr (contents_len_pos
, '*');
19929 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19935 keepass
->contents_len
= contents_len
;
19937 contents_len
= contents_len
/ 4;
19939 keyfile_inline_pos
= strchr (contents_pos
, '*');
19941 u32 real_contents_len
;
19943 if (keyfile_inline_pos
== NULL
)
19944 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19947 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19948 keyfile_inline_pos
++;
19949 is_keyfile_present
= 1;
19952 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
19954 for (i
= 0; i
< contents_len
; i
++)
19955 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
19957 else if (keepass
->version
== 2)
19959 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
19961 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19963 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
19965 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19967 expected_bytes_pos
++;
19969 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
19970 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
19971 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
19972 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
19973 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
19974 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
19975 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
19976 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
19978 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
19980 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19982 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
19984 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
19986 contents_hash_pos
++;
19988 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19989 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19990 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19991 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19992 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19993 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19994 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19995 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19997 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
19999 if (keyfile_inline_pos
== NULL
)
20000 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
20003 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
20004 keyfile_inline_pos
++;
20005 is_keyfile_present
= 1;
20007 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
20010 if (is_keyfile_present
!= 0)
20012 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
20016 keyfile_len
= atoi (keyfile_len_pos
);
20018 keepass
->keyfile_len
= keyfile_len
;
20020 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20022 keyfile_pos
= strchr (keyfile_len_pos
, '*');
20024 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20028 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
20030 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20032 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
20033 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
20034 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
20035 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
20036 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
20037 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
20038 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
20039 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
20042 digest
[0] = keepass
->enc_iv
[0];
20043 digest
[1] = keepass
->enc_iv
[1];
20044 digest
[2] = keepass
->enc_iv
[2];
20045 digest
[3] = keepass
->enc_iv
[3];
20047 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
20048 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
20049 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
20050 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
20051 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
20052 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
20053 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
20054 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
20056 return (PARSER_OK
);
20059 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20061 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
20063 u32
*digest
= (u32
*) hash_buf
->digest
;
20065 salt_t
*salt
= hash_buf
->salt
;
20067 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20068 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20069 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20070 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20071 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20072 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20073 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20074 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20076 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20078 uint salt_len
= input_len
- 64 - 1;
20080 char *salt_buf
= input_buf
+ 64 + 1;
20082 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
20084 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
20086 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
20088 salt
->salt_len
= salt_len
;
20091 * we can precompute the first sha256 transform
20094 uint w
[16] = { 0 };
20096 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
20097 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
20098 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
20099 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
20100 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
20101 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
20102 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
20103 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
20104 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
20105 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
20106 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
20107 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
20108 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
20109 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
20110 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
20111 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
20113 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
20115 sha256_64 (w
, pc256
);
20117 salt
->salt_buf_pc
[0] = pc256
[0];
20118 salt
->salt_buf_pc
[1] = pc256
[1];
20119 salt
->salt_buf_pc
[2] = pc256
[2];
20120 salt
->salt_buf_pc
[3] = pc256
[3];
20121 salt
->salt_buf_pc
[4] = pc256
[4];
20122 salt
->salt_buf_pc
[5] = pc256
[5];
20123 salt
->salt_buf_pc
[6] = pc256
[6];
20124 salt
->salt_buf_pc
[7] = pc256
[7];
20126 digest
[0] -= pc256
[0];
20127 digest
[1] -= pc256
[1];
20128 digest
[2] -= pc256
[2];
20129 digest
[3] -= pc256
[3];
20130 digest
[4] -= pc256
[4];
20131 digest
[5] -= pc256
[5];
20132 digest
[6] -= pc256
[6];
20133 digest
[7] -= pc256
[7];
20135 return (PARSER_OK
);
20138 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20140 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
20142 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
20144 u32
*digest
= (u32
*) hash_buf
->digest
;
20146 salt_t
*salt
= hash_buf
->salt
;
20152 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
20154 char *data_buf_pos
= strchr (data_len_pos
, '$');
20156 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20158 u32 data_len_len
= data_buf_pos
- data_len_pos
;
20160 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
20161 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
20165 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
20167 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
20169 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
20171 u32 data_len
= atoi (data_len_pos
);
20173 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
20179 char *salt_pos
= data_buf_pos
;
20181 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20182 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20183 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
20184 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
20186 // this is actually the CT, which is also the hash later (if matched)
20188 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
20189 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
20190 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
20191 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
20193 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
20195 salt
->salt_iter
= 10 - 1;
20201 digest
[0] = salt
->salt_buf
[4];
20202 digest
[1] = salt
->salt_buf
[5];
20203 digest
[2] = salt
->salt_buf
[6];
20204 digest
[3] = salt
->salt_buf
[7];
20206 return (PARSER_OK
);
20209 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20211 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
20213 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
20215 u32
*digest
= (u32
*) hash_buf
->digest
;
20217 salt_t
*salt
= hash_buf
->salt
;
20223 char *salt_pos
= input_buf
+ 11 + 1;
20225 char *iter_pos
= strchr (salt_pos
, ',');
20227 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20229 u32 salt_len
= iter_pos
- salt_pos
;
20231 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
20235 char *hash_pos
= strchr (iter_pos
, ',');
20237 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20239 u32 iter_len
= hash_pos
- iter_pos
;
20241 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
20245 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
20247 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
20253 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20254 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20255 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
20256 salt
->salt_buf
[3] = 0x00018000;
20258 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
20259 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
20260 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
20261 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
20263 salt
->salt_len
= salt_len
/ 2;
20265 salt
->salt_iter
= atoi (iter_pos
) - 1;
20271 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20272 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20273 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20274 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20275 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20276 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20277 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20278 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20280 return (PARSER_OK
);
20283 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20285 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
20287 u32
*digest
= (u32
*) hash_buf
->digest
;
20289 salt_t
*salt
= hash_buf
->salt
;
20295 char *hash_pos
= input_buf
+ 64;
20296 char *salt1_pos
= input_buf
+ 128;
20297 char *salt2_pos
= input_buf
;
20303 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
20304 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
20305 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
20306 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
20308 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
20309 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
20310 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
20311 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
20313 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
20314 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
20315 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
20316 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
20318 salt
->salt_len
= 48;
20320 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
20326 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20327 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20328 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20329 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20330 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20331 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20332 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20333 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20335 return (PARSER_OK
);
20338 int zip2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20340 if ((input_len
< DISPLAY_LEN_MIN_13600
) || (input_len
> DISPLAY_LEN_MAX_13600
)) return (PARSER_GLOBAL_LENGTH
);
20342 if (memcmp (SIGNATURE_ZIP2_START
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
20343 if (memcmp (SIGNATURE_ZIP2_STOP
, input_buf
+ input_len
- 7, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
20345 u32
*digest
= (u32
*) hash_buf
->digest
;
20347 salt_t
*salt
= hash_buf
->salt
;
20349 zip2_t
*zip2
= (zip2_t
*) hash_buf
->esalt
;
20355 char *param0_pos
= input_buf
+ 6 + 1;
20357 char *param1_pos
= strchr (param0_pos
, '*');
20359 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20361 u32 param0_len
= param1_pos
- param0_pos
;
20365 char *param2_pos
= strchr (param1_pos
, '*');
20367 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20369 u32 param1_len
= param2_pos
- param1_pos
;
20373 char *param3_pos
= strchr (param2_pos
, '*');
20375 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20377 u32 param2_len
= param3_pos
- param2_pos
;
20381 char *param4_pos
= strchr (param3_pos
, '*');
20383 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20385 u32 param3_len
= param4_pos
- param3_pos
;
20389 char *param5_pos
= strchr (param4_pos
, '*');
20391 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20393 u32 param4_len
= param5_pos
- param4_pos
;
20397 char *param6_pos
= strchr (param5_pos
, '*');
20399 if (param6_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20401 u32 param5_len
= param6_pos
- param5_pos
;
20405 char *param7_pos
= strchr (param6_pos
, '*');
20407 if (param7_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20409 u32 param6_len
= param7_pos
- param6_pos
;
20413 char *param8_pos
= strchr (param7_pos
, '*');
20415 if (param8_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20417 u32 param7_len
= param8_pos
- param7_pos
;
20421 const uint type
= atoi (param0_pos
);
20422 const uint mode
= atoi (param1_pos
);
20423 const uint magic
= atoi (param2_pos
);
20425 char *salt_buf
= param3_pos
;
20427 uint verify_bytes
; sscanf (param4_pos
, "%4x*", &verify_bytes
);
20429 const uint compress_length
= atoi (param5_pos
);
20431 char *data_buf
= param6_pos
;
20432 char *auth
= param7_pos
;
20438 if (param0_len
!= 1) return (PARSER_SALT_VALUE
);
20440 if (param1_len
!= 1) return (PARSER_SALT_VALUE
);
20442 if (param2_len
!= 1) return (PARSER_SALT_VALUE
);
20444 if ((param3_len
!= 16) && (param3_len
!= 24) && (param3_len
!= 32)) return (PARSER_SALT_VALUE
);
20446 if (param4_len
>= 5) return (PARSER_SALT_VALUE
);
20448 if (param5_len
>= 5) return (PARSER_SALT_VALUE
);
20450 if (param6_len
>= 8192) return (PARSER_SALT_VALUE
);
20452 if (param6_len
& 1) return (PARSER_SALT_VALUE
);
20454 if (param7_len
!= 20) return (PARSER_SALT_VALUE
);
20456 if (type
!= 0) return (PARSER_SALT_VALUE
);
20458 if ((mode
!= 1) && (mode
!= 2) && (mode
!= 3)) return (PARSER_SALT_VALUE
);
20460 if (magic
!= 0) return (PARSER_SALT_VALUE
);
20462 if (verify_bytes
>= 0x10000) return (PARSER_SALT_VALUE
);
20470 zip2
->magic
= magic
;
20474 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20475 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20476 zip2
->salt_buf
[2] = 0;
20477 zip2
->salt_buf
[3] = 0;
20479 zip2
->salt_len
= 8;
20481 else if (mode
== 2)
20483 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20484 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20485 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20486 zip2
->salt_buf
[3] = 0;
20488 zip2
->salt_len
= 12;
20490 else if (mode
== 3)
20492 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20493 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20494 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20495 zip2
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
20497 zip2
->salt_len
= 16;
20500 zip2
->salt_buf
[0] = byte_swap_32 (zip2
->salt_buf
[0]);
20501 zip2
->salt_buf
[1] = byte_swap_32 (zip2
->salt_buf
[1]);
20502 zip2
->salt_buf
[2] = byte_swap_32 (zip2
->salt_buf
[2]);
20503 zip2
->salt_buf
[3] = byte_swap_32 (zip2
->salt_buf
[3]);
20505 zip2
->verify_bytes
= verify_bytes
;
20507 zip2
->compress_length
= compress_length
;
20509 char *data_buf_ptr
= (char *) zip2
->data_buf
;
20511 for (uint i
= 0; i
< param6_len
; i
+= 2)
20513 const char p0
= data_buf
[i
+ 0];
20514 const char p1
= data_buf
[i
+ 1];
20516 *data_buf_ptr
++ = hex_convert (p1
) << 0
20517 | hex_convert (p0
) << 4;
20522 *data_buf_ptr
= 0x80;
20524 char *auth_ptr
= (char *) zip2
->auth_buf
;
20526 for (uint i
= 0; i
< param7_len
; i
+= 2)
20528 const char p0
= auth
[i
+ 0];
20529 const char p1
= auth
[i
+ 1];
20531 *auth_ptr
++ = hex_convert (p1
) << 0
20532 | hex_convert (p0
) << 4;
20541 salt
->salt_buf
[0] = zip2
->salt_buf
[0];
20542 salt
->salt_buf
[1] = zip2
->salt_buf
[1];
20543 salt
->salt_buf
[2] = zip2
->salt_buf
[2];
20544 salt
->salt_buf
[3] = zip2
->salt_buf
[3];
20545 salt
->salt_buf
[4] = zip2
->data_buf
[0];
20546 salt
->salt_buf
[5] = zip2
->data_buf
[1];
20547 salt
->salt_buf
[6] = zip2
->data_buf
[2];
20548 salt
->salt_buf
[7] = zip2
->data_buf
[3];
20550 salt
->salt_len
= 32;
20552 salt
->salt_iter
= ROUNDS_ZIP2
- 1;
20555 * digest buf (fake)
20558 digest
[0] = zip2
->auth_buf
[0];
20559 digest
[1] = zip2
->auth_buf
[1];
20560 digest
[2] = zip2
->auth_buf
[2];
20561 digest
[3] = zip2
->auth_buf
[3];
20563 return (PARSER_OK
);
20566 int win8phone_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20568 if ((input_len
< DISPLAY_LEN_MIN_13800
) || (input_len
> DISPLAY_LEN_MAX_13800
)) return (PARSER_GLOBAL_LENGTH
);
20570 u32
*digest
= (u32
*) hash_buf
->digest
;
20572 salt_t
*salt
= hash_buf
->salt
;
20574 win8phone_t
*esalt
= hash_buf
->esalt
;
20576 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20577 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20578 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20579 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20580 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20581 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20582 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20583 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20585 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20587 char *salt_buf_ptr
= input_buf
+ 64 + 1;
20589 u32
*salt_buf
= esalt
->salt_buf
;
20591 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
20593 salt_buf
[i
] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[j
]);
20596 salt
->salt_buf
[0] = salt_buf
[0];
20597 salt
->salt_buf
[1] = salt_buf
[1];
20598 salt
->salt_buf
[2] = salt_buf
[2];
20599 salt
->salt_buf
[3] = salt_buf
[3];
20600 salt
->salt_buf
[4] = salt_buf
[4];
20601 salt
->salt_buf
[5] = salt_buf
[5];
20602 salt
->salt_buf
[6] = salt_buf
[6];
20603 salt
->salt_buf
[7] = salt_buf
[7];
20605 salt
->salt_len
= 64;
20607 return (PARSER_OK
);
20611 * parallel running threads
20616 BOOL WINAPI
sigHandler_default (DWORD sig
)
20620 case CTRL_CLOSE_EVENT
:
20623 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
20624 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
20625 * function otherwise it is too late (e.g. after returning from this function)
20630 SetConsoleCtrlHandler (NULL
, TRUE
);
20637 case CTRL_LOGOFF_EVENT
:
20638 case CTRL_SHUTDOWN_EVENT
:
20642 SetConsoleCtrlHandler (NULL
, TRUE
);
20650 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
20654 case CTRL_CLOSE_EVENT
:
20658 SetConsoleCtrlHandler (NULL
, TRUE
);
20665 case CTRL_LOGOFF_EVENT
:
20666 case CTRL_SHUTDOWN_EVENT
:
20670 SetConsoleCtrlHandler (NULL
, TRUE
);
20678 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
20680 if (callback
== NULL
)
20682 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
20686 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
20692 void sigHandler_default (int sig
)
20696 signal (sig
, NULL
);
20699 void sigHandler_benchmark (int sig
)
20703 signal (sig
, NULL
);
20706 void hc_signal (void (callback
) (int))
20708 if (callback
== NULL
) callback
= SIG_DFL
;
20710 signal (SIGINT
, callback
);
20711 signal (SIGTERM
, callback
);
20712 signal (SIGABRT
, callback
);
20717 void status_display ();
20719 void *thread_keypress (void *p
)
20721 int benchmark
= *((int *) p
);
20723 uint quiet
= data
.quiet
;
20727 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
20729 int ch
= tty_getchar();
20731 if (ch
== -1) break;
20733 if (ch
== 0) continue;
20735 //https://github.com/hashcat/hashcat/issues/302
20740 hc_thread_mutex_lock (mux_display
);
20756 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20757 if (quiet
== 0) fflush (stdout
);
20769 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20770 if (quiet
== 0) fflush (stdout
);
20782 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20783 if (quiet
== 0) fflush (stdout
);
20795 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20796 if (quiet
== 0) fflush (stdout
);
20804 if (benchmark
== 1) break;
20806 stop_at_checkpoint ();
20810 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20811 if (quiet
== 0) fflush (stdout
);
20819 if (benchmark
== 1)
20831 //https://github.com/hashcat/hashcat/issues/302
20836 hc_thread_mutex_unlock (mux_display
);
20848 bool class_num (const u8 c
)
20850 return ((c
>= '0') && (c
<= '9'));
20853 bool class_lower (const u8 c
)
20855 return ((c
>= 'a') && (c
<= 'z'));
20858 bool class_upper (const u8 c
)
20860 return ((c
>= 'A') && (c
<= 'Z'));
20863 bool class_alpha (const u8 c
)
20865 return (class_lower (c
) || class_upper (c
));
20868 int conv_ctoi (const u8 c
)
20874 else if (class_upper (c
))
20876 return c
- 'A' + 10;
20882 int conv_itoc (const u8 c
)
20890 return c
+ 'A' - 10;
20900 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20901 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20902 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20903 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20904 #define MAX_KERNEL_RULES 255
20905 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20906 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20907 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20909 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20910 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20911 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20912 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20914 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20919 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20921 switch (rule_buf
[rule_pos
])
20927 case RULE_OP_MANGLE_NOOP
:
20928 SET_NAME (rule
, rule_buf
[rule_pos
]);
20931 case RULE_OP_MANGLE_LREST
:
20932 SET_NAME (rule
, rule_buf
[rule_pos
]);
20935 case RULE_OP_MANGLE_UREST
:
20936 SET_NAME (rule
, rule_buf
[rule_pos
]);
20939 case RULE_OP_MANGLE_LREST_UFIRST
:
20940 SET_NAME (rule
, rule_buf
[rule_pos
]);
20943 case RULE_OP_MANGLE_UREST_LFIRST
:
20944 SET_NAME (rule
, rule_buf
[rule_pos
]);
20947 case RULE_OP_MANGLE_TREST
:
20948 SET_NAME (rule
, rule_buf
[rule_pos
]);
20951 case RULE_OP_MANGLE_TOGGLE_AT
:
20952 SET_NAME (rule
, rule_buf
[rule_pos
]);
20953 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20956 case RULE_OP_MANGLE_REVERSE
:
20957 SET_NAME (rule
, rule_buf
[rule_pos
]);
20960 case RULE_OP_MANGLE_DUPEWORD
:
20961 SET_NAME (rule
, rule_buf
[rule_pos
]);
20964 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20965 SET_NAME (rule
, rule_buf
[rule_pos
]);
20966 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20969 case RULE_OP_MANGLE_REFLECT
:
20970 SET_NAME (rule
, rule_buf
[rule_pos
]);
20973 case RULE_OP_MANGLE_ROTATE_LEFT
:
20974 SET_NAME (rule
, rule_buf
[rule_pos
]);
20977 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20978 SET_NAME (rule
, rule_buf
[rule_pos
]);
20981 case RULE_OP_MANGLE_APPEND
:
20982 SET_NAME (rule
, rule_buf
[rule_pos
]);
20983 SET_P0 (rule
, rule_buf
[rule_pos
]);
20986 case RULE_OP_MANGLE_PREPEND
:
20987 SET_NAME (rule
, rule_buf
[rule_pos
]);
20988 SET_P0 (rule
, rule_buf
[rule_pos
]);
20991 case RULE_OP_MANGLE_DELETE_FIRST
:
20992 SET_NAME (rule
, rule_buf
[rule_pos
]);
20995 case RULE_OP_MANGLE_DELETE_LAST
:
20996 SET_NAME (rule
, rule_buf
[rule_pos
]);
20999 case RULE_OP_MANGLE_DELETE_AT
:
21000 SET_NAME (rule
, rule_buf
[rule_pos
]);
21001 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21004 case RULE_OP_MANGLE_EXTRACT
:
21005 SET_NAME (rule
, rule_buf
[rule_pos
]);
21006 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21007 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21010 case RULE_OP_MANGLE_OMIT
:
21011 SET_NAME (rule
, rule_buf
[rule_pos
]);
21012 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21013 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21016 case RULE_OP_MANGLE_INSERT
:
21017 SET_NAME (rule
, rule_buf
[rule_pos
]);
21018 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21019 SET_P1 (rule
, rule_buf
[rule_pos
]);
21022 case RULE_OP_MANGLE_OVERSTRIKE
:
21023 SET_NAME (rule
, rule_buf
[rule_pos
]);
21024 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21025 SET_P1 (rule
, rule_buf
[rule_pos
]);
21028 case RULE_OP_MANGLE_TRUNCATE_AT
:
21029 SET_NAME (rule
, rule_buf
[rule_pos
]);
21030 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21033 case RULE_OP_MANGLE_REPLACE
:
21034 SET_NAME (rule
, rule_buf
[rule_pos
]);
21035 SET_P0 (rule
, rule_buf
[rule_pos
]);
21036 SET_P1 (rule
, rule_buf
[rule_pos
]);
21039 case RULE_OP_MANGLE_PURGECHAR
:
21043 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21047 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21048 SET_NAME (rule
, rule_buf
[rule_pos
]);
21049 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21052 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21053 SET_NAME (rule
, rule_buf
[rule_pos
]);
21054 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21057 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21058 SET_NAME (rule
, rule_buf
[rule_pos
]);
21061 case RULE_OP_MANGLE_SWITCH_FIRST
:
21062 SET_NAME (rule
, rule_buf
[rule_pos
]);
21065 case RULE_OP_MANGLE_SWITCH_LAST
:
21066 SET_NAME (rule
, rule_buf
[rule_pos
]);
21069 case RULE_OP_MANGLE_SWITCH_AT
:
21070 SET_NAME (rule
, rule_buf
[rule_pos
]);
21071 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21072 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21075 case RULE_OP_MANGLE_CHR_SHIFTL
:
21076 SET_NAME (rule
, rule_buf
[rule_pos
]);
21077 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21080 case RULE_OP_MANGLE_CHR_SHIFTR
:
21081 SET_NAME (rule
, rule_buf
[rule_pos
]);
21082 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21085 case RULE_OP_MANGLE_CHR_INCR
:
21086 SET_NAME (rule
, rule_buf
[rule_pos
]);
21087 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21090 case RULE_OP_MANGLE_CHR_DECR
:
21091 SET_NAME (rule
, rule_buf
[rule_pos
]);
21092 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21095 case RULE_OP_MANGLE_REPLACE_NP1
:
21096 SET_NAME (rule
, rule_buf
[rule_pos
]);
21097 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21100 case RULE_OP_MANGLE_REPLACE_NM1
:
21101 SET_NAME (rule
, rule_buf
[rule_pos
]);
21102 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21105 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21106 SET_NAME (rule
, rule_buf
[rule_pos
]);
21107 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21110 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21111 SET_NAME (rule
, rule_buf
[rule_pos
]);
21112 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21115 case RULE_OP_MANGLE_TITLE
:
21116 SET_NAME (rule
, rule_buf
[rule_pos
]);
21125 if (rule_pos
< rule_len
) return (-1);
21130 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
21134 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
21138 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
21142 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
21146 case RULE_OP_MANGLE_NOOP
:
21147 rule_buf
[rule_pos
] = rule_cmd
;
21150 case RULE_OP_MANGLE_LREST
:
21151 rule_buf
[rule_pos
] = rule_cmd
;
21154 case RULE_OP_MANGLE_UREST
:
21155 rule_buf
[rule_pos
] = rule_cmd
;
21158 case RULE_OP_MANGLE_LREST_UFIRST
:
21159 rule_buf
[rule_pos
] = rule_cmd
;
21162 case RULE_OP_MANGLE_UREST_LFIRST
:
21163 rule_buf
[rule_pos
] = rule_cmd
;
21166 case RULE_OP_MANGLE_TREST
:
21167 rule_buf
[rule_pos
] = rule_cmd
;
21170 case RULE_OP_MANGLE_TOGGLE_AT
:
21171 rule_buf
[rule_pos
] = rule_cmd
;
21172 GET_P0_CONV (rule
);
21175 case RULE_OP_MANGLE_REVERSE
:
21176 rule_buf
[rule_pos
] = rule_cmd
;
21179 case RULE_OP_MANGLE_DUPEWORD
:
21180 rule_buf
[rule_pos
] = rule_cmd
;
21183 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21184 rule_buf
[rule_pos
] = rule_cmd
;
21185 GET_P0_CONV (rule
);
21188 case RULE_OP_MANGLE_REFLECT
:
21189 rule_buf
[rule_pos
] = rule_cmd
;
21192 case RULE_OP_MANGLE_ROTATE_LEFT
:
21193 rule_buf
[rule_pos
] = rule_cmd
;
21196 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21197 rule_buf
[rule_pos
] = rule_cmd
;
21200 case RULE_OP_MANGLE_APPEND
:
21201 rule_buf
[rule_pos
] = rule_cmd
;
21205 case RULE_OP_MANGLE_PREPEND
:
21206 rule_buf
[rule_pos
] = rule_cmd
;
21210 case RULE_OP_MANGLE_DELETE_FIRST
:
21211 rule_buf
[rule_pos
] = rule_cmd
;
21214 case RULE_OP_MANGLE_DELETE_LAST
:
21215 rule_buf
[rule_pos
] = rule_cmd
;
21218 case RULE_OP_MANGLE_DELETE_AT
:
21219 rule_buf
[rule_pos
] = rule_cmd
;
21220 GET_P0_CONV (rule
);
21223 case RULE_OP_MANGLE_EXTRACT
:
21224 rule_buf
[rule_pos
] = rule_cmd
;
21225 GET_P0_CONV (rule
);
21226 GET_P1_CONV (rule
);
21229 case RULE_OP_MANGLE_OMIT
:
21230 rule_buf
[rule_pos
] = rule_cmd
;
21231 GET_P0_CONV (rule
);
21232 GET_P1_CONV (rule
);
21235 case RULE_OP_MANGLE_INSERT
:
21236 rule_buf
[rule_pos
] = rule_cmd
;
21237 GET_P0_CONV (rule
);
21241 case RULE_OP_MANGLE_OVERSTRIKE
:
21242 rule_buf
[rule_pos
] = rule_cmd
;
21243 GET_P0_CONV (rule
);
21247 case RULE_OP_MANGLE_TRUNCATE_AT
:
21248 rule_buf
[rule_pos
] = rule_cmd
;
21249 GET_P0_CONV (rule
);
21252 case RULE_OP_MANGLE_REPLACE
:
21253 rule_buf
[rule_pos
] = rule_cmd
;
21258 case RULE_OP_MANGLE_PURGECHAR
:
21262 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21266 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21267 rule_buf
[rule_pos
] = rule_cmd
;
21268 GET_P0_CONV (rule
);
21271 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21272 rule_buf
[rule_pos
] = rule_cmd
;
21273 GET_P0_CONV (rule
);
21276 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21277 rule_buf
[rule_pos
] = rule_cmd
;
21280 case RULE_OP_MANGLE_SWITCH_FIRST
:
21281 rule_buf
[rule_pos
] = rule_cmd
;
21284 case RULE_OP_MANGLE_SWITCH_LAST
:
21285 rule_buf
[rule_pos
] = rule_cmd
;
21288 case RULE_OP_MANGLE_SWITCH_AT
:
21289 rule_buf
[rule_pos
] = rule_cmd
;
21290 GET_P0_CONV (rule
);
21291 GET_P1_CONV (rule
);
21294 case RULE_OP_MANGLE_CHR_SHIFTL
:
21295 rule_buf
[rule_pos
] = rule_cmd
;
21296 GET_P0_CONV (rule
);
21299 case RULE_OP_MANGLE_CHR_SHIFTR
:
21300 rule_buf
[rule_pos
] = rule_cmd
;
21301 GET_P0_CONV (rule
);
21304 case RULE_OP_MANGLE_CHR_INCR
:
21305 rule_buf
[rule_pos
] = rule_cmd
;
21306 GET_P0_CONV (rule
);
21309 case RULE_OP_MANGLE_CHR_DECR
:
21310 rule_buf
[rule_pos
] = rule_cmd
;
21311 GET_P0_CONV (rule
);
21314 case RULE_OP_MANGLE_REPLACE_NP1
:
21315 rule_buf
[rule_pos
] = rule_cmd
;
21316 GET_P0_CONV (rule
);
21319 case RULE_OP_MANGLE_REPLACE_NM1
:
21320 rule_buf
[rule_pos
] = rule_cmd
;
21321 GET_P0_CONV (rule
);
21324 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21325 rule_buf
[rule_pos
] = rule_cmd
;
21326 GET_P0_CONV (rule
);
21329 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21330 rule_buf
[rule_pos
] = rule_cmd
;
21331 GET_P0_CONV (rule
);
21334 case RULE_OP_MANGLE_TITLE
:
21335 rule_buf
[rule_pos
] = rule_cmd
;
21339 return rule_pos
- 1;
21357 * CPU rules : this is from hashcat sources, cpu based rules
21360 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
21361 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
21363 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
21364 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
21365 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
21367 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
21368 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
21369 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
21371 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
21375 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
21380 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
21384 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
21389 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
21393 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
21398 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
21403 for (l
= 0; l
< arr_len
; l
++)
21405 r
= arr_len
- 1 - l
;
21409 MANGLE_SWITCH (arr
, l
, r
);
21415 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
21417 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21419 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
21421 return (arr_len
* 2);
21424 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
21426 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21428 int orig_len
= arr_len
;
21432 for (i
= 0; i
< times
; i
++)
21434 memcpy (&arr
[arr_len
], arr
, orig_len
);
21436 arr_len
+= orig_len
;
21442 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
21444 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21446 mangle_double (arr
, arr_len
);
21448 mangle_reverse (arr
+ arr_len
, arr_len
);
21450 return (arr_len
* 2);
21453 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
21458 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
21460 MANGLE_SWITCH (arr
, l
, r
);
21466 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
21471 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
21473 MANGLE_SWITCH (arr
, l
, r
);
21479 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21481 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21485 return (arr_len
+ 1);
21488 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21490 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21494 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21496 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21501 return (arr_len
+ 1);
21504 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21506 if (upos
>= arr_len
) return (arr_len
);
21510 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
21512 arr
[arr_pos
] = arr
[arr_pos
+ 1];
21515 return (arr_len
- 1);
21518 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21520 if (upos
>= arr_len
) return (arr_len
);
21522 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
21526 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
21528 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
21534 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21536 if (upos
>= arr_len
) return (arr_len
);
21538 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
21542 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
21544 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
21547 return (arr_len
- ulen
);
21550 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21552 if (upos
>= arr_len
) return (arr_len
);
21554 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21558 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
21560 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21565 return (arr_len
+ 1);
21568 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
)
21570 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21572 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
21574 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
21576 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
21578 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
21580 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
21582 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
21584 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
21586 return (arr_len
+ arr2_cpy
);
21589 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21591 if (upos
>= arr_len
) return (arr_len
);
21598 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21600 if (upos
>= arr_len
) return (arr_len
);
21602 memset (arr
+ upos
, 0, arr_len
- upos
);
21607 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
21611 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21613 if (arr
[arr_pos
] != oldc
) continue;
21615 arr
[arr_pos
] = newc
;
21621 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21627 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21629 if (arr
[arr_pos
] == c
) continue;
21631 arr
[ret_len
] = arr
[arr_pos
];
21639 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21641 if (ulen
> arr_len
) return (arr_len
);
21643 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21645 char cs
[100] = { 0 };
21647 memcpy (cs
, arr
, ulen
);
21651 for (i
= 0; i
< ulen
; i
++)
21655 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
21661 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21663 if (ulen
> arr_len
) return (arr_len
);
21665 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21667 int upos
= arr_len
- ulen
;
21671 for (i
= 0; i
< ulen
; i
++)
21673 char c
= arr
[upos
+ i
];
21675 arr_len
= mangle_append (arr
, arr_len
, c
);
21681 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21683 if ( arr_len
== 0) return (arr_len
);
21684 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21686 char c
= arr
[upos
];
21690 for (i
= 0; i
< ulen
; i
++)
21692 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
21698 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
21700 if ( arr_len
== 0) return (arr_len
);
21701 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21705 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21707 int new_pos
= arr_pos
* 2;
21709 arr
[new_pos
] = arr
[arr_pos
];
21711 arr
[new_pos
+ 1] = arr
[arr_pos
];
21714 return (arr_len
* 2);
21717 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21719 if (upos
>= arr_len
) return (arr_len
);
21720 if (upos2
>= arr_len
) return (arr_len
);
21722 MANGLE_SWITCH (arr
, upos
, upos2
);
21727 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21729 MANGLE_SWITCH (arr
, upos
, upos2
);
21734 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21736 if (upos
>= arr_len
) return (arr_len
);
21743 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21745 if (upos
>= arr_len
) return (arr_len
);
21752 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21754 if (upos
>= arr_len
) return (arr_len
);
21761 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21763 if (upos
>= arr_len
) return (arr_len
);
21770 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21772 int upper_next
= 1;
21776 for (pos
= 0; pos
< arr_len
; pos
++)
21778 if (arr
[pos
] == ' ')
21789 MANGLE_UPPER_AT (arr
, pos
);
21793 MANGLE_LOWER_AT (arr
, pos
);
21800 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21802 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21808 for (j
= 0; j
< rp_gen_num
; j
++)
21815 switch ((char) get_random_num (0, 9))
21818 r
= get_random_num (0, sizeof (grp_op_nop
));
21819 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21823 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21824 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21825 p1
= get_random_num (0, sizeof (grp_pos
));
21826 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21830 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21831 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21832 p1
= get_random_num (1, 6);
21833 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21837 r
= get_random_num (0, sizeof (grp_op_chr
));
21838 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21839 p1
= get_random_num (0x20, 0x7e);
21840 rule_buf
[rule_pos
++] = (char) p1
;
21844 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21845 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21846 p1
= get_random_num (0x20, 0x7e);
21847 rule_buf
[rule_pos
++] = (char) p1
;
21848 p2
= get_random_num (0x20, 0x7e);
21850 p2
= get_random_num (0x20, 0x7e);
21851 rule_buf
[rule_pos
++] = (char) p2
;
21855 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21856 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21857 p1
= get_random_num (0, sizeof (grp_pos
));
21858 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21859 p2
= get_random_num (0x20, 0x7e);
21860 rule_buf
[rule_pos
++] = (char) p2
;
21864 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21865 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21866 p1
= get_random_num (0, sizeof (grp_pos
));
21867 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21868 p2
= get_random_num (0, sizeof (grp_pos
));
21870 p2
= get_random_num (0, sizeof (grp_pos
));
21871 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21875 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21876 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[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
));
21881 p2
= get_random_num (1, sizeof (grp_pos
));
21882 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21886 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21887 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21888 p1
= get_random_num (0, sizeof (grp_pos
));
21889 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21890 p2
= get_random_num (1, sizeof (grp_pos
));
21891 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21892 p3
= get_random_num (0, sizeof (grp_pos
));
21893 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21901 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21903 char mem
[BLOCK_SIZE
] = { 0 };
21905 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21907 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21909 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21911 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21913 int out_len
= in_len
;
21914 int mem_len
= in_len
;
21916 memcpy (out
, in
, out_len
);
21920 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21925 switch (rule
[rule_pos
])
21930 case RULE_OP_MANGLE_NOOP
:
21933 case RULE_OP_MANGLE_LREST
:
21934 out_len
= mangle_lrest (out
, out_len
);
21937 case RULE_OP_MANGLE_UREST
:
21938 out_len
= mangle_urest (out
, out_len
);
21941 case RULE_OP_MANGLE_LREST_UFIRST
:
21942 out_len
= mangle_lrest (out
, out_len
);
21943 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21946 case RULE_OP_MANGLE_UREST_LFIRST
:
21947 out_len
= mangle_urest (out
, out_len
);
21948 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21951 case RULE_OP_MANGLE_TREST
:
21952 out_len
= mangle_trest (out
, out_len
);
21955 case RULE_OP_MANGLE_TOGGLE_AT
:
21956 NEXT_RULEPOS (rule_pos
);
21957 NEXT_RPTOI (rule
, rule_pos
, upos
);
21958 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21961 case RULE_OP_MANGLE_REVERSE
:
21962 out_len
= mangle_reverse (out
, out_len
);
21965 case RULE_OP_MANGLE_DUPEWORD
:
21966 out_len
= mangle_double (out
, out_len
);
21969 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21970 NEXT_RULEPOS (rule_pos
);
21971 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21972 out_len
= mangle_double_times (out
, out_len
, ulen
);
21975 case RULE_OP_MANGLE_REFLECT
:
21976 out_len
= mangle_reflect (out
, out_len
);
21979 case RULE_OP_MANGLE_ROTATE_LEFT
:
21980 mangle_rotate_left (out
, out_len
);
21983 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21984 mangle_rotate_right (out
, out_len
);
21987 case RULE_OP_MANGLE_APPEND
:
21988 NEXT_RULEPOS (rule_pos
);
21989 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
21992 case RULE_OP_MANGLE_PREPEND
:
21993 NEXT_RULEPOS (rule_pos
);
21994 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
21997 case RULE_OP_MANGLE_DELETE_FIRST
:
21998 out_len
= mangle_delete_at (out
, out_len
, 0);
22001 case RULE_OP_MANGLE_DELETE_LAST
:
22002 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
22005 case RULE_OP_MANGLE_DELETE_AT
:
22006 NEXT_RULEPOS (rule_pos
);
22007 NEXT_RPTOI (rule
, rule_pos
, upos
);
22008 out_len
= mangle_delete_at (out
, out_len
, upos
);
22011 case RULE_OP_MANGLE_EXTRACT
:
22012 NEXT_RULEPOS (rule_pos
);
22013 NEXT_RPTOI (rule
, rule_pos
, upos
);
22014 NEXT_RULEPOS (rule_pos
);
22015 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22016 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
22019 case RULE_OP_MANGLE_OMIT
:
22020 NEXT_RULEPOS (rule_pos
);
22021 NEXT_RPTOI (rule
, rule_pos
, upos
);
22022 NEXT_RULEPOS (rule_pos
);
22023 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22024 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
22027 case RULE_OP_MANGLE_INSERT
:
22028 NEXT_RULEPOS (rule_pos
);
22029 NEXT_RPTOI (rule
, rule_pos
, upos
);
22030 NEXT_RULEPOS (rule_pos
);
22031 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
22034 case RULE_OP_MANGLE_OVERSTRIKE
:
22035 NEXT_RULEPOS (rule_pos
);
22036 NEXT_RPTOI (rule
, rule_pos
, upos
);
22037 NEXT_RULEPOS (rule_pos
);
22038 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
22041 case RULE_OP_MANGLE_TRUNCATE_AT
:
22042 NEXT_RULEPOS (rule_pos
);
22043 NEXT_RPTOI (rule
, rule_pos
, upos
);
22044 out_len
= mangle_truncate_at (out
, out_len
, upos
);
22047 case RULE_OP_MANGLE_REPLACE
:
22048 NEXT_RULEPOS (rule_pos
);
22049 NEXT_RULEPOS (rule_pos
);
22050 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
22053 case RULE_OP_MANGLE_PURGECHAR
:
22054 NEXT_RULEPOS (rule_pos
);
22055 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
22058 case RULE_OP_MANGLE_TOGGLECASE_REC
:
22062 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
22063 NEXT_RULEPOS (rule_pos
);
22064 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22065 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
22068 case RULE_OP_MANGLE_DUPECHAR_LAST
:
22069 NEXT_RULEPOS (rule_pos
);
22070 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22071 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
22074 case RULE_OP_MANGLE_DUPECHAR_ALL
:
22075 out_len
= mangle_dupechar (out
, out_len
);
22078 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
22079 NEXT_RULEPOS (rule_pos
);
22080 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22081 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
22084 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
22085 NEXT_RULEPOS (rule_pos
);
22086 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22087 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
22090 case RULE_OP_MANGLE_SWITCH_FIRST
:
22091 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
22094 case RULE_OP_MANGLE_SWITCH_LAST
:
22095 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
22098 case RULE_OP_MANGLE_SWITCH_AT
:
22099 NEXT_RULEPOS (rule_pos
);
22100 NEXT_RPTOI (rule
, rule_pos
, upos
);
22101 NEXT_RULEPOS (rule_pos
);
22102 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22103 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
22106 case RULE_OP_MANGLE_CHR_SHIFTL
:
22107 NEXT_RULEPOS (rule_pos
);
22108 NEXT_RPTOI (rule
, rule_pos
, upos
);
22109 mangle_chr_shiftl (out
, out_len
, upos
);
22112 case RULE_OP_MANGLE_CHR_SHIFTR
:
22113 NEXT_RULEPOS (rule_pos
);
22114 NEXT_RPTOI (rule
, rule_pos
, upos
);
22115 mangle_chr_shiftr (out
, out_len
, upos
);
22118 case RULE_OP_MANGLE_CHR_INCR
:
22119 NEXT_RULEPOS (rule_pos
);
22120 NEXT_RPTOI (rule
, rule_pos
, upos
);
22121 mangle_chr_incr (out
, out_len
, upos
);
22124 case RULE_OP_MANGLE_CHR_DECR
:
22125 NEXT_RULEPOS (rule_pos
);
22126 NEXT_RPTOI (rule
, rule_pos
, upos
);
22127 mangle_chr_decr (out
, out_len
, upos
);
22130 case RULE_OP_MANGLE_REPLACE_NP1
:
22131 NEXT_RULEPOS (rule_pos
);
22132 NEXT_RPTOI (rule
, rule_pos
, upos
);
22133 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
22136 case RULE_OP_MANGLE_REPLACE_NM1
:
22137 NEXT_RULEPOS (rule_pos
);
22138 NEXT_RPTOI (rule
, rule_pos
, upos
);
22139 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
22142 case RULE_OP_MANGLE_TITLE
:
22143 out_len
= mangle_title (out
, out_len
);
22146 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
22147 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22148 NEXT_RULEPOS (rule_pos
);
22149 NEXT_RPTOI (rule
, rule_pos
, upos
);
22150 NEXT_RULEPOS (rule_pos
);
22151 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22152 NEXT_RULEPOS (rule_pos
);
22153 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22154 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
22157 case RULE_OP_MANGLE_APPEND_MEMORY
:
22158 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22159 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22160 memcpy (out
+ out_len
, mem
, mem_len
);
22161 out_len
+= mem_len
;
22164 case RULE_OP_MANGLE_PREPEND_MEMORY
:
22165 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22166 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22167 memcpy (mem
+ mem_len
, out
, out_len
);
22168 out_len
+= mem_len
;
22169 memcpy (out
, mem
, out_len
);
22172 case RULE_OP_MEMORIZE_WORD
:
22173 memcpy (mem
, out
, out_len
);
22177 case RULE_OP_REJECT_LESS
:
22178 NEXT_RULEPOS (rule_pos
);
22179 NEXT_RPTOI (rule
, rule_pos
, upos
);
22180 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
22183 case RULE_OP_REJECT_GREATER
:
22184 NEXT_RULEPOS (rule_pos
);
22185 NEXT_RPTOI (rule
, rule_pos
, upos
);
22186 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
22189 case RULE_OP_REJECT_CONTAIN
:
22190 NEXT_RULEPOS (rule_pos
);
22191 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
22194 case RULE_OP_REJECT_NOT_CONTAIN
:
22195 NEXT_RULEPOS (rule_pos
);
22196 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
22199 case RULE_OP_REJECT_EQUAL_FIRST
:
22200 NEXT_RULEPOS (rule_pos
);
22201 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22204 case RULE_OP_REJECT_EQUAL_LAST
:
22205 NEXT_RULEPOS (rule_pos
);
22206 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22209 case RULE_OP_REJECT_EQUAL_AT
:
22210 NEXT_RULEPOS (rule_pos
);
22211 NEXT_RPTOI (rule
, rule_pos
, upos
);
22212 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22213 NEXT_RULEPOS (rule_pos
);
22214 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22217 case RULE_OP_REJECT_CONTAINS
:
22218 NEXT_RULEPOS (rule_pos
);
22219 NEXT_RPTOI (rule
, rule_pos
, upos
);
22220 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22221 NEXT_RULEPOS (rule_pos
);
22222 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
22223 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
22226 case RULE_OP_REJECT_MEMORY
:
22227 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
22231 return (RULE_RC_SYNTAX_ERROR
);
22236 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);