2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
19 #define GET_ACCEL(x) KERNEL_ACCEL_ ## x
20 #define GET_LOOPS(x) KERNEL_LOOPS_ ## x
22 #define GET_LOOPS_OSX(x) KERNEL_LOOPS_OSX_ ## x
23 #define GET_ACCEL_OSX(x) KERNEL_ACCEL_OSX_ ## x
29 u32
rotl32 (const u32 a
, const u32 n
)
31 return ((a
<< n
) | (a
>> (32 - n
)));
34 u32
rotr32 (const u32 a
, const u32 n
)
36 return ((a
>> n
) | (a
<< (32 - n
)));
39 u64
rotl64 (const u64 a
, const u64 n
)
41 return ((a
<< n
) | (a
>> (64 - n
)));
44 u64
rotr64 (const u64 a
, const u64 n
)
46 return ((a
>> n
) | (a
<< (64 - n
)));
49 u32
byte_swap_32 (const u32 n
)
51 return (n
& 0xff000000) >> 24
52 | (n
& 0x00ff0000) >> 8
53 | (n
& 0x0000ff00) << 8
54 | (n
& 0x000000ff) << 24;
57 u64
byte_swap_64 (const u64 n
)
59 return (n
& 0xff00000000000000ULL
) >> 56
60 | (n
& 0x00ff000000000000ULL
) >> 40
61 | (n
& 0x0000ff0000000000ULL
) >> 24
62 | (n
& 0x000000ff00000000ULL
) >> 8
63 | (n
& 0x00000000ff000000ULL
) << 8
64 | (n
& 0x0000000000ff0000ULL
) << 24
65 | (n
& 0x000000000000ff00ULL
) << 40
66 | (n
& 0x00000000000000ffULL
) << 56;
70 * ciphers for use on cpu
77 * hashes for use on cpu
81 #include "cpu-sha256.c"
89 void log_final (FILE *fp
, const char *fmt
, va_list ap
)
95 for (int i
= 0; i
< last_len
; i
++)
103 char s
[4096] = { 0 };
105 int max_len
= (int) sizeof (s
);
107 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
109 if (len
> max_len
) len
= max_len
;
111 fwrite (s
, len
, 1, fp
);
118 void log_out_nn (FILE *fp
, const char *fmt
, ...)
120 if (SUPPRESS_OUTPUT
) return;
126 log_final (fp
, fmt
, ap
);
131 void log_info_nn (const char *fmt
, ...)
133 if (SUPPRESS_OUTPUT
) return;
139 log_final (stdout
, fmt
, ap
);
144 void log_error_nn (const char *fmt
, ...)
146 if (SUPPRESS_OUTPUT
) return;
152 log_final (stderr
, fmt
, ap
);
157 void log_out (FILE *fp
, const char *fmt
, ...)
159 if (SUPPRESS_OUTPUT
) return;
165 log_final (fp
, fmt
, ap
);
174 void log_info (const char *fmt
, ...)
176 if (SUPPRESS_OUTPUT
) return;
182 log_final (stdout
, fmt
, ap
);
186 fputc ('\n', stdout
);
191 void log_error (const char *fmt
, ...)
193 if (SUPPRESS_OUTPUT
) return;
195 fputc ('\n', stderr
);
196 fputc ('\n', stderr
);
202 log_final (stderr
, fmt
, ap
);
206 fputc ('\n', stderr
);
207 fputc ('\n', stderr
);
216 u8
int_to_base32 (const u8 c
)
218 static const u8 tbl
[0x20] =
220 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
221 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
227 u8
base32_to_int (const u8 c
)
229 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
230 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
235 u8
int_to_itoa32 (const u8 c
)
237 static const u8 tbl
[0x20] =
239 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
240 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
246 u8
itoa32_to_int (const u8 c
)
248 if ((c
>= '0') && (c
<= '9')) return c
- '0';
249 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
254 u8
int_to_itoa64 (const u8 c
)
256 static const u8 tbl
[0x40] =
258 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
259 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
260 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
261 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
267 u8
itoa64_to_int (const u8 c
)
269 static const u8 tbl
[0x100] =
271 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
272 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
273 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
274 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
275 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
276 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
277 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
278 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
279 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
280 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
281 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
282 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
283 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
284 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
285 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
286 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
292 u8
int_to_base64 (const u8 c
)
294 static const u8 tbl
[0x40] =
296 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
297 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
298 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
299 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
305 u8
base64_to_int (const u8 c
)
307 static const u8 tbl
[0x100] =
309 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
310 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
311 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
312 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
313 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
314 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
315 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
316 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 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,
322 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
323 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
324 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
330 u8
int_to_bf64 (const u8 c
)
332 static const u8 tbl
[0x40] =
334 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
335 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
336 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
337 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
343 u8
bf64_to_int (const u8 c
)
345 static const u8 tbl
[0x100] =
347 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
348 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
349 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
350 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
351 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
352 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
353 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
354 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 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,
360 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
361 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
362 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
368 u8
int_to_lotus64 (const u8 c
)
370 if (c
< 10) return '0' + c
;
371 else if (c
< 36) return 'A' + c
- 10;
372 else if (c
< 62) return 'a' + c
- 36;
373 else if (c
== 62) return '+';
374 else if (c
== 63) return '/';
379 u8
lotus64_to_int (const u8 c
)
381 if ((c
>= '0') && (c
<= '9')) return c
- '0';
382 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
383 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
384 else if (c
== '+') return 62;
385 else if (c
== '/') return 63;
391 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
393 const u8
*in_ptr
= in_buf
;
395 u8
*out_ptr
= out_buf
;
397 for (int i
= 0; i
< in_len
; i
+= 8)
399 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
400 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
401 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
402 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
403 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
404 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
405 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
406 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
408 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
409 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
410 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
411 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
412 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
418 for (int i
= 0; i
< in_len
; i
++)
420 if (in_buf
[i
] != '=') continue;
425 int out_len
= (in_len
* 5) / 8;
430 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
432 const u8
*in_ptr
= in_buf
;
434 u8
*out_ptr
= out_buf
;
436 for (int i
= 0; i
< in_len
; i
+= 5)
438 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
439 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
440 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
441 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
442 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
443 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
444 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
445 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
447 out_ptr
[0] = out_val0
& 0x7f;
448 out_ptr
[1] = out_val1
& 0x7f;
449 out_ptr
[2] = out_val2
& 0x7f;
450 out_ptr
[3] = out_val3
& 0x7f;
451 out_ptr
[4] = out_val4
& 0x7f;
452 out_ptr
[5] = out_val5
& 0x7f;
453 out_ptr
[6] = out_val6
& 0x7f;
454 out_ptr
[7] = out_val7
& 0x7f;
460 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
464 out_buf
[out_len
] = '=';
472 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
474 const u8
*in_ptr
= in_buf
;
476 u8
*out_ptr
= out_buf
;
478 for (int i
= 0; i
< in_len
; i
+= 4)
480 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
481 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
482 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
483 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
485 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
486 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
487 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
493 for (int i
= 0; i
< in_len
; i
++)
495 if (in_buf
[i
] != '=') continue;
500 int out_len
= (in_len
* 6) / 8;
505 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
507 const u8
*in_ptr
= in_buf
;
509 u8
*out_ptr
= out_buf
;
511 for (int i
= 0; i
< in_len
; i
+= 3)
513 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
514 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
515 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
516 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
518 out_ptr
[0] = out_val0
& 0x7f;
519 out_ptr
[1] = out_val1
& 0x7f;
520 out_ptr
[2] = out_val2
& 0x7f;
521 out_ptr
[3] = out_val3
& 0x7f;
527 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
531 out_buf
[out_len
] = '=';
539 int is_valid_hex_char (const u8 c
)
541 if ((c
>= '0') && (c
<= '9')) return 1;
542 if ((c
>= 'A') && (c
<= 'F')) return 1;
543 if ((c
>= 'a') && (c
<= 'f')) return 1;
548 u8
hex_convert (const u8 c
)
550 return (c
& 15) + (c
>> 6) * 9;
553 u8
hex_to_u8 (const u8 hex
[2])
557 v
|= (hex_convert (hex
[1]) << 0);
558 v
|= (hex_convert (hex
[0]) << 4);
563 u32
hex_to_u32 (const u8 hex
[8])
567 v
|= ((u32
) hex_convert (hex
[7])) << 0;
568 v
|= ((u32
) hex_convert (hex
[6])) << 4;
569 v
|= ((u32
) hex_convert (hex
[5])) << 8;
570 v
|= ((u32
) hex_convert (hex
[4])) << 12;
571 v
|= ((u32
) hex_convert (hex
[3])) << 16;
572 v
|= ((u32
) hex_convert (hex
[2])) << 20;
573 v
|= ((u32
) hex_convert (hex
[1])) << 24;
574 v
|= ((u32
) hex_convert (hex
[0])) << 28;
579 u64
hex_to_u64 (const u8 hex
[16])
583 v
|= ((u64
) hex_convert (hex
[15]) << 0);
584 v
|= ((u64
) hex_convert (hex
[14]) << 4);
585 v
|= ((u64
) hex_convert (hex
[13]) << 8);
586 v
|= ((u64
) hex_convert (hex
[12]) << 12);
587 v
|= ((u64
) hex_convert (hex
[11]) << 16);
588 v
|= ((u64
) hex_convert (hex
[10]) << 20);
589 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
590 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
591 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
592 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
593 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
594 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
595 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
596 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
597 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
598 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
603 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
605 hex
[0] = v
>> 28 & 15;
606 hex
[1] = v
>> 24 & 15;
607 hex
[2] = v
>> 20 & 15;
608 hex
[3] = v
>> 16 & 15;
609 hex
[4] = v
>> 12 & 15;
610 hex
[5] = v
>> 8 & 15;
611 hex
[6] = v
>> 4 & 15;
612 hex
[7] = v
>> 0 & 15;
616 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
617 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
618 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
619 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
620 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
621 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
622 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
623 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
630 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
634 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
643 for (int i
= 0; i
< 16; i
+= 4)
653 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
660 out
[i
+ 0] = _out
[0];
661 out
[i
+ 1] = _out
[1];
662 out
[i
+ 2] = _out
[2];
663 out
[i
+ 3] = _out
[3];
672 static void juniper_decrypt_hash (char *in
, char *out
)
676 u8 base64_buf
[100] = { 0 };
678 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
682 u32 juniper_iv
[4] = { 0 };
684 memcpy (juniper_iv
, base64_buf
, 12);
686 memcpy (out
, juniper_iv
, 12);
690 u32 juniper_key
[4] = { 0 };
692 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
693 juniper_key
[1] = byte_swap_32 (0x8df91059);
694 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
695 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
699 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
700 u32
*out_ptr
= (u32
*) (out
+ 12);
702 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
705 void phpass_decode (u8 digest
[16], u8 buf
[22])
709 l
= itoa64_to_int (buf
[ 0]) << 0;
710 l
|= itoa64_to_int (buf
[ 1]) << 6;
711 l
|= itoa64_to_int (buf
[ 2]) << 12;
712 l
|= itoa64_to_int (buf
[ 3]) << 18;
714 digest
[ 0] = (l
>> 0) & 0xff;
715 digest
[ 1] = (l
>> 8) & 0xff;
716 digest
[ 2] = (l
>> 16) & 0xff;
718 l
= itoa64_to_int (buf
[ 4]) << 0;
719 l
|= itoa64_to_int (buf
[ 5]) << 6;
720 l
|= itoa64_to_int (buf
[ 6]) << 12;
721 l
|= itoa64_to_int (buf
[ 7]) << 18;
723 digest
[ 3] = (l
>> 0) & 0xff;
724 digest
[ 4] = (l
>> 8) & 0xff;
725 digest
[ 5] = (l
>> 16) & 0xff;
727 l
= itoa64_to_int (buf
[ 8]) << 0;
728 l
|= itoa64_to_int (buf
[ 9]) << 6;
729 l
|= itoa64_to_int (buf
[10]) << 12;
730 l
|= itoa64_to_int (buf
[11]) << 18;
732 digest
[ 6] = (l
>> 0) & 0xff;
733 digest
[ 7] = (l
>> 8) & 0xff;
734 digest
[ 8] = (l
>> 16) & 0xff;
736 l
= itoa64_to_int (buf
[12]) << 0;
737 l
|= itoa64_to_int (buf
[13]) << 6;
738 l
|= itoa64_to_int (buf
[14]) << 12;
739 l
|= itoa64_to_int (buf
[15]) << 18;
741 digest
[ 9] = (l
>> 0) & 0xff;
742 digest
[10] = (l
>> 8) & 0xff;
743 digest
[11] = (l
>> 16) & 0xff;
745 l
= itoa64_to_int (buf
[16]) << 0;
746 l
|= itoa64_to_int (buf
[17]) << 6;
747 l
|= itoa64_to_int (buf
[18]) << 12;
748 l
|= itoa64_to_int (buf
[19]) << 18;
750 digest
[12] = (l
>> 0) & 0xff;
751 digest
[13] = (l
>> 8) & 0xff;
752 digest
[14] = (l
>> 16) & 0xff;
754 l
= itoa64_to_int (buf
[20]) << 0;
755 l
|= itoa64_to_int (buf
[21]) << 6;
757 digest
[15] = (l
>> 0) & 0xff;
760 void phpass_encode (u8 digest
[16], u8 buf
[22])
764 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
766 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
767 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
768 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
769 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
771 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
773 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
774 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
775 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
776 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
778 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
780 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
781 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
782 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
783 buf
[11] = int_to_itoa64 (l
& 0x3f);
785 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
787 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
788 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
789 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
790 buf
[15] = int_to_itoa64 (l
& 0x3f);
792 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
794 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
795 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
796 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
797 buf
[19] = int_to_itoa64 (l
& 0x3f);
799 l
= (digest
[15] << 0);
801 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
802 buf
[21] = int_to_itoa64 (l
& 0x3f);
805 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
809 l
= itoa64_to_int (buf
[ 0]) << 0;
810 l
|= itoa64_to_int (buf
[ 1]) << 6;
811 l
|= itoa64_to_int (buf
[ 2]) << 12;
812 l
|= itoa64_to_int (buf
[ 3]) << 18;
814 digest
[ 0] = (l
>> 16) & 0xff;
815 digest
[ 6] = (l
>> 8) & 0xff;
816 digest
[12] = (l
>> 0) & 0xff;
818 l
= itoa64_to_int (buf
[ 4]) << 0;
819 l
|= itoa64_to_int (buf
[ 5]) << 6;
820 l
|= itoa64_to_int (buf
[ 6]) << 12;
821 l
|= itoa64_to_int (buf
[ 7]) << 18;
823 digest
[ 1] = (l
>> 16) & 0xff;
824 digest
[ 7] = (l
>> 8) & 0xff;
825 digest
[13] = (l
>> 0) & 0xff;
827 l
= itoa64_to_int (buf
[ 8]) << 0;
828 l
|= itoa64_to_int (buf
[ 9]) << 6;
829 l
|= itoa64_to_int (buf
[10]) << 12;
830 l
|= itoa64_to_int (buf
[11]) << 18;
832 digest
[ 2] = (l
>> 16) & 0xff;
833 digest
[ 8] = (l
>> 8) & 0xff;
834 digest
[14] = (l
>> 0) & 0xff;
836 l
= itoa64_to_int (buf
[12]) << 0;
837 l
|= itoa64_to_int (buf
[13]) << 6;
838 l
|= itoa64_to_int (buf
[14]) << 12;
839 l
|= itoa64_to_int (buf
[15]) << 18;
841 digest
[ 3] = (l
>> 16) & 0xff;
842 digest
[ 9] = (l
>> 8) & 0xff;
843 digest
[15] = (l
>> 0) & 0xff;
845 l
= itoa64_to_int (buf
[16]) << 0;
846 l
|= itoa64_to_int (buf
[17]) << 6;
847 l
|= itoa64_to_int (buf
[18]) << 12;
848 l
|= itoa64_to_int (buf
[19]) << 18;
850 digest
[ 4] = (l
>> 16) & 0xff;
851 digest
[10] = (l
>> 8) & 0xff;
852 digest
[ 5] = (l
>> 0) & 0xff;
854 l
= itoa64_to_int (buf
[20]) << 0;
855 l
|= itoa64_to_int (buf
[21]) << 6;
857 digest
[11] = (l
>> 0) & 0xff;
860 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
864 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
866 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
867 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
868 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
869 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
871 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
873 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
874 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
875 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
876 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
880 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
881 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
882 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
883 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
887 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
888 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
889 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
890 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
894 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
895 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
896 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
897 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
899 l
= (digest
[11] << 0);
901 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
902 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
905 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
909 l
= itoa64_to_int (buf
[ 0]) << 0;
910 l
|= itoa64_to_int (buf
[ 1]) << 6;
911 l
|= itoa64_to_int (buf
[ 2]) << 12;
912 l
|= itoa64_to_int (buf
[ 3]) << 18;
914 digest
[ 0] = (l
>> 16) & 0xff;
915 digest
[21] = (l
>> 8) & 0xff;
916 digest
[42] = (l
>> 0) & 0xff;
918 l
= itoa64_to_int (buf
[ 4]) << 0;
919 l
|= itoa64_to_int (buf
[ 5]) << 6;
920 l
|= itoa64_to_int (buf
[ 6]) << 12;
921 l
|= itoa64_to_int (buf
[ 7]) << 18;
923 digest
[22] = (l
>> 16) & 0xff;
924 digest
[43] = (l
>> 8) & 0xff;
925 digest
[ 1] = (l
>> 0) & 0xff;
927 l
= itoa64_to_int (buf
[ 8]) << 0;
928 l
|= itoa64_to_int (buf
[ 9]) << 6;
929 l
|= itoa64_to_int (buf
[10]) << 12;
930 l
|= itoa64_to_int (buf
[11]) << 18;
932 digest
[44] = (l
>> 16) & 0xff;
933 digest
[ 2] = (l
>> 8) & 0xff;
934 digest
[23] = (l
>> 0) & 0xff;
936 l
= itoa64_to_int (buf
[12]) << 0;
937 l
|= itoa64_to_int (buf
[13]) << 6;
938 l
|= itoa64_to_int (buf
[14]) << 12;
939 l
|= itoa64_to_int (buf
[15]) << 18;
941 digest
[ 3] = (l
>> 16) & 0xff;
942 digest
[24] = (l
>> 8) & 0xff;
943 digest
[45] = (l
>> 0) & 0xff;
945 l
= itoa64_to_int (buf
[16]) << 0;
946 l
|= itoa64_to_int (buf
[17]) << 6;
947 l
|= itoa64_to_int (buf
[18]) << 12;
948 l
|= itoa64_to_int (buf
[19]) << 18;
950 digest
[25] = (l
>> 16) & 0xff;
951 digest
[46] = (l
>> 8) & 0xff;
952 digest
[ 4] = (l
>> 0) & 0xff;
954 l
= itoa64_to_int (buf
[20]) << 0;
955 l
|= itoa64_to_int (buf
[21]) << 6;
956 l
|= itoa64_to_int (buf
[22]) << 12;
957 l
|= itoa64_to_int (buf
[23]) << 18;
959 digest
[47] = (l
>> 16) & 0xff;
960 digest
[ 5] = (l
>> 8) & 0xff;
961 digest
[26] = (l
>> 0) & 0xff;
963 l
= itoa64_to_int (buf
[24]) << 0;
964 l
|= itoa64_to_int (buf
[25]) << 6;
965 l
|= itoa64_to_int (buf
[26]) << 12;
966 l
|= itoa64_to_int (buf
[27]) << 18;
968 digest
[ 6] = (l
>> 16) & 0xff;
969 digest
[27] = (l
>> 8) & 0xff;
970 digest
[48] = (l
>> 0) & 0xff;
972 l
= itoa64_to_int (buf
[28]) << 0;
973 l
|= itoa64_to_int (buf
[29]) << 6;
974 l
|= itoa64_to_int (buf
[30]) << 12;
975 l
|= itoa64_to_int (buf
[31]) << 18;
977 digest
[28] = (l
>> 16) & 0xff;
978 digest
[49] = (l
>> 8) & 0xff;
979 digest
[ 7] = (l
>> 0) & 0xff;
981 l
= itoa64_to_int (buf
[32]) << 0;
982 l
|= itoa64_to_int (buf
[33]) << 6;
983 l
|= itoa64_to_int (buf
[34]) << 12;
984 l
|= itoa64_to_int (buf
[35]) << 18;
986 digest
[50] = (l
>> 16) & 0xff;
987 digest
[ 8] = (l
>> 8) & 0xff;
988 digest
[29] = (l
>> 0) & 0xff;
990 l
= itoa64_to_int (buf
[36]) << 0;
991 l
|= itoa64_to_int (buf
[37]) << 6;
992 l
|= itoa64_to_int (buf
[38]) << 12;
993 l
|= itoa64_to_int (buf
[39]) << 18;
995 digest
[ 9] = (l
>> 16) & 0xff;
996 digest
[30] = (l
>> 8) & 0xff;
997 digest
[51] = (l
>> 0) & 0xff;
999 l
= itoa64_to_int (buf
[40]) << 0;
1000 l
|= itoa64_to_int (buf
[41]) << 6;
1001 l
|= itoa64_to_int (buf
[42]) << 12;
1002 l
|= itoa64_to_int (buf
[43]) << 18;
1004 digest
[31] = (l
>> 16) & 0xff;
1005 digest
[52] = (l
>> 8) & 0xff;
1006 digest
[10] = (l
>> 0) & 0xff;
1008 l
= itoa64_to_int (buf
[44]) << 0;
1009 l
|= itoa64_to_int (buf
[45]) << 6;
1010 l
|= itoa64_to_int (buf
[46]) << 12;
1011 l
|= itoa64_to_int (buf
[47]) << 18;
1013 digest
[53] = (l
>> 16) & 0xff;
1014 digest
[11] = (l
>> 8) & 0xff;
1015 digest
[32] = (l
>> 0) & 0xff;
1017 l
= itoa64_to_int (buf
[48]) << 0;
1018 l
|= itoa64_to_int (buf
[49]) << 6;
1019 l
|= itoa64_to_int (buf
[50]) << 12;
1020 l
|= itoa64_to_int (buf
[51]) << 18;
1022 digest
[12] = (l
>> 16) & 0xff;
1023 digest
[33] = (l
>> 8) & 0xff;
1024 digest
[54] = (l
>> 0) & 0xff;
1026 l
= itoa64_to_int (buf
[52]) << 0;
1027 l
|= itoa64_to_int (buf
[53]) << 6;
1028 l
|= itoa64_to_int (buf
[54]) << 12;
1029 l
|= itoa64_to_int (buf
[55]) << 18;
1031 digest
[34] = (l
>> 16) & 0xff;
1032 digest
[55] = (l
>> 8) & 0xff;
1033 digest
[13] = (l
>> 0) & 0xff;
1035 l
= itoa64_to_int (buf
[56]) << 0;
1036 l
|= itoa64_to_int (buf
[57]) << 6;
1037 l
|= itoa64_to_int (buf
[58]) << 12;
1038 l
|= itoa64_to_int (buf
[59]) << 18;
1040 digest
[56] = (l
>> 16) & 0xff;
1041 digest
[14] = (l
>> 8) & 0xff;
1042 digest
[35] = (l
>> 0) & 0xff;
1044 l
= itoa64_to_int (buf
[60]) << 0;
1045 l
|= itoa64_to_int (buf
[61]) << 6;
1046 l
|= itoa64_to_int (buf
[62]) << 12;
1047 l
|= itoa64_to_int (buf
[63]) << 18;
1049 digest
[15] = (l
>> 16) & 0xff;
1050 digest
[36] = (l
>> 8) & 0xff;
1051 digest
[57] = (l
>> 0) & 0xff;
1053 l
= itoa64_to_int (buf
[64]) << 0;
1054 l
|= itoa64_to_int (buf
[65]) << 6;
1055 l
|= itoa64_to_int (buf
[66]) << 12;
1056 l
|= itoa64_to_int (buf
[67]) << 18;
1058 digest
[37] = (l
>> 16) & 0xff;
1059 digest
[58] = (l
>> 8) & 0xff;
1060 digest
[16] = (l
>> 0) & 0xff;
1062 l
= itoa64_to_int (buf
[68]) << 0;
1063 l
|= itoa64_to_int (buf
[69]) << 6;
1064 l
|= itoa64_to_int (buf
[70]) << 12;
1065 l
|= itoa64_to_int (buf
[71]) << 18;
1067 digest
[59] = (l
>> 16) & 0xff;
1068 digest
[17] = (l
>> 8) & 0xff;
1069 digest
[38] = (l
>> 0) & 0xff;
1071 l
= itoa64_to_int (buf
[72]) << 0;
1072 l
|= itoa64_to_int (buf
[73]) << 6;
1073 l
|= itoa64_to_int (buf
[74]) << 12;
1074 l
|= itoa64_to_int (buf
[75]) << 18;
1076 digest
[18] = (l
>> 16) & 0xff;
1077 digest
[39] = (l
>> 8) & 0xff;
1078 digest
[60] = (l
>> 0) & 0xff;
1080 l
= itoa64_to_int (buf
[76]) << 0;
1081 l
|= itoa64_to_int (buf
[77]) << 6;
1082 l
|= itoa64_to_int (buf
[78]) << 12;
1083 l
|= itoa64_to_int (buf
[79]) << 18;
1085 digest
[40] = (l
>> 16) & 0xff;
1086 digest
[61] = (l
>> 8) & 0xff;
1087 digest
[19] = (l
>> 0) & 0xff;
1089 l
= itoa64_to_int (buf
[80]) << 0;
1090 l
|= itoa64_to_int (buf
[81]) << 6;
1091 l
|= itoa64_to_int (buf
[82]) << 12;
1092 l
|= itoa64_to_int (buf
[83]) << 18;
1094 digest
[62] = (l
>> 16) & 0xff;
1095 digest
[20] = (l
>> 8) & 0xff;
1096 digest
[41] = (l
>> 0) & 0xff;
1098 l
= itoa64_to_int (buf
[84]) << 0;
1099 l
|= itoa64_to_int (buf
[85]) << 6;
1101 digest
[63] = (l
>> 0) & 0xff;
1104 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1108 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1110 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1111 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1112 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1113 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1115 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1117 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1118 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1119 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1120 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1124 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1125 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1126 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1127 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1131 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1132 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1133 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1134 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1138 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1139 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1140 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1141 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1145 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1146 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1147 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1148 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1152 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1153 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1154 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1155 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1159 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1160 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1161 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1162 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1166 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1167 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1168 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1169 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1173 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1174 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1175 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1176 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1180 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1181 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1182 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1183 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1187 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1188 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1189 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1190 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1194 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1195 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1196 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1197 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1201 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1202 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1203 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1204 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1208 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1209 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1210 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1211 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1215 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1216 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1217 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1218 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1222 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1223 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1224 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1225 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1229 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1230 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1231 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1232 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1236 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1237 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1238 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1239 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1243 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1244 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1245 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1246 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1250 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1251 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1252 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1253 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1255 l
= 0 | 0 | (digest
[63] << 0);
1257 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1258 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1261 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1265 l
= itoa64_to_int (buf
[ 0]) << 0;
1266 l
|= itoa64_to_int (buf
[ 1]) << 6;
1267 l
|= itoa64_to_int (buf
[ 2]) << 12;
1268 l
|= itoa64_to_int (buf
[ 3]) << 18;
1270 digest
[ 2] = (l
>> 0) & 0xff;
1271 digest
[ 1] = (l
>> 8) & 0xff;
1272 digest
[ 0] = (l
>> 16) & 0xff;
1274 l
= itoa64_to_int (buf
[ 4]) << 0;
1275 l
|= itoa64_to_int (buf
[ 5]) << 6;
1276 l
|= itoa64_to_int (buf
[ 6]) << 12;
1277 l
|= itoa64_to_int (buf
[ 7]) << 18;
1279 digest
[ 5] = (l
>> 0) & 0xff;
1280 digest
[ 4] = (l
>> 8) & 0xff;
1281 digest
[ 3] = (l
>> 16) & 0xff;
1283 l
= itoa64_to_int (buf
[ 8]) << 0;
1284 l
|= itoa64_to_int (buf
[ 9]) << 6;
1285 l
|= itoa64_to_int (buf
[10]) << 12;
1286 l
|= itoa64_to_int (buf
[11]) << 18;
1288 digest
[ 8] = (l
>> 0) & 0xff;
1289 digest
[ 7] = (l
>> 8) & 0xff;
1290 digest
[ 6] = (l
>> 16) & 0xff;
1292 l
= itoa64_to_int (buf
[12]) << 0;
1293 l
|= itoa64_to_int (buf
[13]) << 6;
1294 l
|= itoa64_to_int (buf
[14]) << 12;
1295 l
|= itoa64_to_int (buf
[15]) << 18;
1297 digest
[11] = (l
>> 0) & 0xff;
1298 digest
[10] = (l
>> 8) & 0xff;
1299 digest
[ 9] = (l
>> 16) & 0xff;
1301 l
= itoa64_to_int (buf
[16]) << 0;
1302 l
|= itoa64_to_int (buf
[17]) << 6;
1303 l
|= itoa64_to_int (buf
[18]) << 12;
1304 l
|= itoa64_to_int (buf
[19]) << 18;
1306 digest
[14] = (l
>> 0) & 0xff;
1307 digest
[13] = (l
>> 8) & 0xff;
1308 digest
[12] = (l
>> 16) & 0xff;
1310 l
= itoa64_to_int (buf
[20]) << 0;
1311 l
|= itoa64_to_int (buf
[21]) << 6;
1312 l
|= itoa64_to_int (buf
[22]) << 12;
1313 l
|= itoa64_to_int (buf
[23]) << 18;
1315 digest
[17] = (l
>> 0) & 0xff;
1316 digest
[16] = (l
>> 8) & 0xff;
1317 digest
[15] = (l
>> 16) & 0xff;
1319 l
= itoa64_to_int (buf
[24]) << 0;
1320 l
|= itoa64_to_int (buf
[25]) << 6;
1321 l
|= itoa64_to_int (buf
[26]) << 12;
1323 digest
[19] = (l
>> 8) & 0xff;
1324 digest
[18] = (l
>> 16) & 0xff;
1327 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1331 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1333 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1334 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1335 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1336 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1338 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1340 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1341 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1342 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1343 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1345 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1347 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1348 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1349 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1350 buf
[11] = int_to_itoa64 (l
& 0x3f);
1352 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1354 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1355 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1356 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1357 buf
[15] = int_to_itoa64 (l
& 0x3f);
1359 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1361 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1362 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1363 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1364 buf
[19] = int_to_itoa64 (l
& 0x3f);
1366 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1368 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1369 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1370 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1371 buf
[23] = int_to_itoa64 (l
& 0x3f);
1373 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1375 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1376 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1377 buf
[26] = int_to_itoa64 (l
& 0x3f);
1380 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1384 l
= itoa64_to_int (buf
[ 0]) << 0;
1385 l
|= itoa64_to_int (buf
[ 1]) << 6;
1386 l
|= itoa64_to_int (buf
[ 2]) << 12;
1387 l
|= itoa64_to_int (buf
[ 3]) << 18;
1389 digest
[ 2] = (l
>> 0) & 0xff;
1390 digest
[ 1] = (l
>> 8) & 0xff;
1391 digest
[ 0] = (l
>> 16) & 0xff;
1393 l
= itoa64_to_int (buf
[ 4]) << 0;
1394 l
|= itoa64_to_int (buf
[ 5]) << 6;
1395 l
|= itoa64_to_int (buf
[ 6]) << 12;
1396 l
|= itoa64_to_int (buf
[ 7]) << 18;
1398 digest
[ 5] = (l
>> 0) & 0xff;
1399 digest
[ 4] = (l
>> 8) & 0xff;
1400 digest
[ 3] = (l
>> 16) & 0xff;
1402 l
= itoa64_to_int (buf
[ 8]) << 0;
1403 l
|= itoa64_to_int (buf
[ 9]) << 6;
1404 l
|= itoa64_to_int (buf
[10]) << 12;
1405 l
|= itoa64_to_int (buf
[11]) << 18;
1407 digest
[ 8] = (l
>> 0) & 0xff;
1408 digest
[ 7] = (l
>> 8) & 0xff;
1409 digest
[ 6] = (l
>> 16) & 0xff;
1411 l
= itoa64_to_int (buf
[12]) << 0;
1412 l
|= itoa64_to_int (buf
[13]) << 6;
1413 l
|= itoa64_to_int (buf
[14]) << 12;
1414 l
|= itoa64_to_int (buf
[15]) << 18;
1416 digest
[11] = (l
>> 0) & 0xff;
1417 digest
[10] = (l
>> 8) & 0xff;
1418 digest
[ 9] = (l
>> 16) & 0xff;
1420 l
= itoa64_to_int (buf
[16]) << 0;
1421 l
|= itoa64_to_int (buf
[17]) << 6;
1422 l
|= itoa64_to_int (buf
[18]) << 12;
1423 l
|= itoa64_to_int (buf
[19]) << 18;
1425 digest
[14] = (l
>> 0) & 0xff;
1426 digest
[13] = (l
>> 8) & 0xff;
1427 digest
[12] = (l
>> 16) & 0xff;
1429 l
= itoa64_to_int (buf
[20]) << 0;
1430 l
|= itoa64_to_int (buf
[21]) << 6;
1431 l
|= itoa64_to_int (buf
[22]) << 12;
1432 l
|= itoa64_to_int (buf
[23]) << 18;
1434 digest
[17] = (l
>> 0) & 0xff;
1435 digest
[16] = (l
>> 8) & 0xff;
1436 digest
[15] = (l
>> 16) & 0xff;
1438 l
= itoa64_to_int (buf
[24]) << 0;
1439 l
|= itoa64_to_int (buf
[25]) << 6;
1440 l
|= itoa64_to_int (buf
[26]) << 12;
1441 l
|= itoa64_to_int (buf
[27]) << 18;
1443 digest
[20] = (l
>> 0) & 0xff;
1444 digest
[19] = (l
>> 8) & 0xff;
1445 digest
[18] = (l
>> 16) & 0xff;
1447 l
= itoa64_to_int (buf
[28]) << 0;
1448 l
|= itoa64_to_int (buf
[29]) << 6;
1449 l
|= itoa64_to_int (buf
[30]) << 12;
1450 l
|= itoa64_to_int (buf
[31]) << 18;
1452 digest
[23] = (l
>> 0) & 0xff;
1453 digest
[22] = (l
>> 8) & 0xff;
1454 digest
[21] = (l
>> 16) & 0xff;
1456 l
= itoa64_to_int (buf
[32]) << 0;
1457 l
|= itoa64_to_int (buf
[33]) << 6;
1458 l
|= itoa64_to_int (buf
[34]) << 12;
1459 l
|= itoa64_to_int (buf
[35]) << 18;
1461 digest
[26] = (l
>> 0) & 0xff;
1462 digest
[25] = (l
>> 8) & 0xff;
1463 digest
[24] = (l
>> 16) & 0xff;
1465 l
= itoa64_to_int (buf
[36]) << 0;
1466 l
|= itoa64_to_int (buf
[37]) << 6;
1467 l
|= itoa64_to_int (buf
[38]) << 12;
1468 l
|= itoa64_to_int (buf
[39]) << 18;
1470 digest
[29] = (l
>> 0) & 0xff;
1471 digest
[28] = (l
>> 8) & 0xff;
1472 digest
[27] = (l
>> 16) & 0xff;
1474 l
= itoa64_to_int (buf
[40]) << 0;
1475 l
|= itoa64_to_int (buf
[41]) << 6;
1476 l
|= itoa64_to_int (buf
[42]) << 12;
1478 //digest[32] = (l >> 0) & 0xff;
1479 digest
[31] = (l
>> 8) & 0xff;
1480 digest
[30] = (l
>> 16) & 0xff;
1483 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1487 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1489 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1490 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1491 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1492 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1494 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1496 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1497 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1498 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1499 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1501 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1503 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1504 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1505 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1506 buf
[11] = int_to_itoa64 (l
& 0x3f);
1508 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1510 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1511 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1512 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1513 buf
[15] = int_to_itoa64 (l
& 0x3f);
1515 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1517 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1518 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1519 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1520 buf
[19] = int_to_itoa64 (l
& 0x3f);
1522 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1524 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1525 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1526 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1527 buf
[23] = int_to_itoa64 (l
& 0x3f);
1529 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1531 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1532 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1533 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1534 buf
[27] = int_to_itoa64 (l
& 0x3f);
1536 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1538 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1539 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1540 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1541 buf
[31] = int_to_itoa64 (l
& 0x3f);
1543 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1545 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1546 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1547 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1548 buf
[35] = int_to_itoa64 (l
& 0x3f);
1550 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1552 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1553 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1554 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1555 buf
[39] = int_to_itoa64 (l
& 0x3f);
1557 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1559 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1560 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1561 buf
[42] = int_to_itoa64 (l
& 0x3f);
1564 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1568 l
= itoa64_to_int (buf
[ 0]) << 0;
1569 l
|= itoa64_to_int (buf
[ 1]) << 6;
1570 l
|= itoa64_to_int (buf
[ 2]) << 12;
1571 l
|= itoa64_to_int (buf
[ 3]) << 18;
1573 digest
[ 2] = (l
>> 0) & 0xff;
1574 digest
[ 1] = (l
>> 8) & 0xff;
1575 digest
[ 0] = (l
>> 16) & 0xff;
1577 l
= itoa64_to_int (buf
[ 4]) << 0;
1578 l
|= itoa64_to_int (buf
[ 5]) << 6;
1579 l
|= itoa64_to_int (buf
[ 6]) << 12;
1580 l
|= itoa64_to_int (buf
[ 7]) << 18;
1582 digest
[ 5] = (l
>> 0) & 0xff;
1583 digest
[ 4] = (l
>> 8) & 0xff;
1584 digest
[ 3] = (l
>> 16) & 0xff;
1586 l
= itoa64_to_int (buf
[ 8]) << 0;
1587 l
|= itoa64_to_int (buf
[ 9]) << 6;
1588 l
|= itoa64_to_int (buf
[10]) << 12;
1589 l
|= itoa64_to_int (buf
[11]) << 18;
1591 digest
[ 8] = (l
>> 0) & 0xff;
1592 digest
[ 7] = (l
>> 8) & 0xff;
1593 digest
[ 6] = (l
>> 16) & 0xff;
1595 l
= itoa64_to_int (buf
[12]) << 0;
1596 l
|= itoa64_to_int (buf
[13]) << 6;
1597 l
|= itoa64_to_int (buf
[14]) << 12;
1598 l
|= itoa64_to_int (buf
[15]) << 18;
1600 digest
[11] = (l
>> 0) & 0xff;
1601 digest
[10] = (l
>> 8) & 0xff;
1602 digest
[ 9] = (l
>> 16) & 0xff;
1604 l
= itoa64_to_int (buf
[16]) << 0;
1605 l
|= itoa64_to_int (buf
[17]) << 6;
1606 l
|= itoa64_to_int (buf
[18]) << 12;
1607 l
|= itoa64_to_int (buf
[19]) << 18;
1609 digest
[14] = (l
>> 0) & 0xff;
1610 digest
[13] = (l
>> 8) & 0xff;
1611 digest
[12] = (l
>> 16) & 0xff;
1613 l
= itoa64_to_int (buf
[20]) << 0;
1614 l
|= itoa64_to_int (buf
[21]) << 6;
1615 l
|= itoa64_to_int (buf
[22]) << 12;
1616 l
|= itoa64_to_int (buf
[23]) << 18;
1618 digest
[17] = (l
>> 0) & 0xff;
1619 digest
[16] = (l
>> 8) & 0xff;
1620 digest
[15] = (l
>> 16) & 0xff;
1622 l
= itoa64_to_int (buf
[24]) << 0;
1623 l
|= itoa64_to_int (buf
[25]) << 6;
1624 l
|= itoa64_to_int (buf
[26]) << 12;
1625 l
|= itoa64_to_int (buf
[27]) << 18;
1627 digest
[20] = (l
>> 0) & 0xff;
1628 digest
[19] = (l
>> 8) & 0xff;
1629 digest
[18] = (l
>> 16) & 0xff;
1631 l
= itoa64_to_int (buf
[28]) << 0;
1632 l
|= itoa64_to_int (buf
[29]) << 6;
1633 l
|= itoa64_to_int (buf
[30]) << 12;
1634 l
|= itoa64_to_int (buf
[31]) << 18;
1636 digest
[23] = (l
>> 0) & 0xff;
1637 digest
[22] = (l
>> 8) & 0xff;
1638 digest
[21] = (l
>> 16) & 0xff;
1640 l
= itoa64_to_int (buf
[32]) << 0;
1641 l
|= itoa64_to_int (buf
[33]) << 6;
1642 l
|= itoa64_to_int (buf
[34]) << 12;
1643 l
|= itoa64_to_int (buf
[35]) << 18;
1645 digest
[26] = (l
>> 0) & 0xff;
1646 digest
[25] = (l
>> 8) & 0xff;
1647 digest
[24] = (l
>> 16) & 0xff;
1649 l
= itoa64_to_int (buf
[36]) << 0;
1650 l
|= itoa64_to_int (buf
[37]) << 6;
1651 l
|= itoa64_to_int (buf
[38]) << 12;
1652 l
|= itoa64_to_int (buf
[39]) << 18;
1654 digest
[29] = (l
>> 0) & 0xff;
1655 digest
[28] = (l
>> 8) & 0xff;
1656 digest
[27] = (l
>> 16) & 0xff;
1658 l
= itoa64_to_int (buf
[40]) << 0;
1659 l
|= itoa64_to_int (buf
[41]) << 6;
1660 l
|= itoa64_to_int (buf
[42]) << 12;
1661 l
|= itoa64_to_int (buf
[43]) << 18;
1663 digest
[32] = (l
>> 0) & 0xff;
1664 digest
[31] = (l
>> 8) & 0xff;
1665 digest
[30] = (l
>> 16) & 0xff;
1667 l
= itoa64_to_int (buf
[44]) << 0;
1668 l
|= itoa64_to_int (buf
[45]) << 6;
1669 l
|= itoa64_to_int (buf
[46]) << 12;
1670 l
|= itoa64_to_int (buf
[47]) << 18;
1672 digest
[35] = (l
>> 0) & 0xff;
1673 digest
[34] = (l
>> 8) & 0xff;
1674 digest
[33] = (l
>> 16) & 0xff;
1676 l
= itoa64_to_int (buf
[48]) << 0;
1677 l
|= itoa64_to_int (buf
[49]) << 6;
1678 l
|= itoa64_to_int (buf
[50]) << 12;
1679 l
|= itoa64_to_int (buf
[51]) << 18;
1681 digest
[38] = (l
>> 0) & 0xff;
1682 digest
[37] = (l
>> 8) & 0xff;
1683 digest
[36] = (l
>> 16) & 0xff;
1685 l
= itoa64_to_int (buf
[52]) << 0;
1686 l
|= itoa64_to_int (buf
[53]) << 6;
1687 l
|= itoa64_to_int (buf
[54]) << 12;
1688 l
|= itoa64_to_int (buf
[55]) << 18;
1690 digest
[41] = (l
>> 0) & 0xff;
1691 digest
[40] = (l
>> 8) & 0xff;
1692 digest
[39] = (l
>> 16) & 0xff;
1694 l
= itoa64_to_int (buf
[56]) << 0;
1695 l
|= itoa64_to_int (buf
[57]) << 6;
1696 l
|= itoa64_to_int (buf
[58]) << 12;
1697 l
|= itoa64_to_int (buf
[59]) << 18;
1699 digest
[44] = (l
>> 0) & 0xff;
1700 digest
[43] = (l
>> 8) & 0xff;
1701 digest
[42] = (l
>> 16) & 0xff;
1703 l
= itoa64_to_int (buf
[60]) << 0;
1704 l
|= itoa64_to_int (buf
[61]) << 6;
1705 l
|= itoa64_to_int (buf
[62]) << 12;
1706 l
|= itoa64_to_int (buf
[63]) << 18;
1708 digest
[47] = (l
>> 0) & 0xff;
1709 digest
[46] = (l
>> 8) & 0xff;
1710 digest
[45] = (l
>> 16) & 0xff;
1712 l
= itoa64_to_int (buf
[64]) << 0;
1713 l
|= itoa64_to_int (buf
[65]) << 6;
1714 l
|= itoa64_to_int (buf
[66]) << 12;
1715 l
|= itoa64_to_int (buf
[67]) << 18;
1717 digest
[50] = (l
>> 0) & 0xff;
1718 digest
[49] = (l
>> 8) & 0xff;
1719 digest
[48] = (l
>> 16) & 0xff;
1721 l
= itoa64_to_int (buf
[68]) << 0;
1722 l
|= itoa64_to_int (buf
[69]) << 6;
1723 l
|= itoa64_to_int (buf
[70]) << 12;
1724 l
|= itoa64_to_int (buf
[71]) << 18;
1726 digest
[53] = (l
>> 0) & 0xff;
1727 digest
[52] = (l
>> 8) & 0xff;
1728 digest
[51] = (l
>> 16) & 0xff;
1730 l
= itoa64_to_int (buf
[72]) << 0;
1731 l
|= itoa64_to_int (buf
[73]) << 6;
1732 l
|= itoa64_to_int (buf
[74]) << 12;
1733 l
|= itoa64_to_int (buf
[75]) << 18;
1735 digest
[56] = (l
>> 0) & 0xff;
1736 digest
[55] = (l
>> 8) & 0xff;
1737 digest
[54] = (l
>> 16) & 0xff;
1739 l
= itoa64_to_int (buf
[76]) << 0;
1740 l
|= itoa64_to_int (buf
[77]) << 6;
1741 l
|= itoa64_to_int (buf
[78]) << 12;
1742 l
|= itoa64_to_int (buf
[79]) << 18;
1744 digest
[59] = (l
>> 0) & 0xff;
1745 digest
[58] = (l
>> 8) & 0xff;
1746 digest
[57] = (l
>> 16) & 0xff;
1748 l
= itoa64_to_int (buf
[80]) << 0;
1749 l
|= itoa64_to_int (buf
[81]) << 6;
1750 l
|= itoa64_to_int (buf
[82]) << 12;
1751 l
|= itoa64_to_int (buf
[83]) << 18;
1753 digest
[62] = (l
>> 0) & 0xff;
1754 digest
[61] = (l
>> 8) & 0xff;
1755 digest
[60] = (l
>> 16) & 0xff;
1757 l
= itoa64_to_int (buf
[84]) << 0;
1758 l
|= itoa64_to_int (buf
[85]) << 6;
1760 digest
[63] = (l
>> 16) & 0xff;
1763 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1767 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1769 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1770 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1771 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1772 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1774 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1776 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1777 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1778 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1779 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1781 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1783 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1784 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1785 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1786 buf
[11] = int_to_itoa64 (l
& 0x3f);
1788 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1790 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1791 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1792 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1793 buf
[15] = int_to_itoa64 (l
& 0x3f);
1795 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1797 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1798 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1799 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1800 buf
[19] = int_to_itoa64 (l
& 0x3f);
1802 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1804 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1805 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1806 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1807 buf
[23] = int_to_itoa64 (l
& 0x3f);
1809 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1811 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1812 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1813 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1814 buf
[27] = int_to_itoa64 (l
& 0x3f);
1816 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1818 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1819 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1820 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1821 buf
[31] = int_to_itoa64 (l
& 0x3f);
1823 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1825 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1826 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1827 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1828 buf
[35] = int_to_itoa64 (l
& 0x3f);
1830 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1832 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1833 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1834 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1835 buf
[39] = int_to_itoa64 (l
& 0x3f);
1837 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1839 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1840 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1841 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1842 buf
[43] = int_to_itoa64 (l
& 0x3f);
1844 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1846 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1847 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1848 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1849 buf
[47] = int_to_itoa64 (l
& 0x3f);
1851 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1853 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1854 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1855 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1856 buf
[51] = int_to_itoa64 (l
& 0x3f);
1858 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1860 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1861 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1862 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1863 buf
[55] = int_to_itoa64 (l
& 0x3f);
1865 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1867 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1868 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1869 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1870 buf
[59] = int_to_itoa64 (l
& 0x3f);
1872 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1874 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1875 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1876 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1877 buf
[63] = int_to_itoa64 (l
& 0x3f);
1879 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1881 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1882 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1883 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1884 buf
[67] = int_to_itoa64 (l
& 0x3f);
1886 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1888 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1889 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1890 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1891 buf
[71] = int_to_itoa64 (l
& 0x3f);
1893 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1895 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1896 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1897 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1898 buf
[75] = int_to_itoa64 (l
& 0x3f);
1900 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1902 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1903 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1904 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1905 buf
[79] = int_to_itoa64 (l
& 0x3f);
1907 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1909 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1910 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1911 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1912 buf
[83] = int_to_itoa64 (l
& 0x3f);
1914 l
= 0 | 0 | (digest
[63] << 16);
1916 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1917 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1920 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1924 l
= itoa64_to_int (buf
[ 0]) << 0;
1925 l
|= itoa64_to_int (buf
[ 1]) << 6;
1926 l
|= itoa64_to_int (buf
[ 2]) << 12;
1927 l
|= itoa64_to_int (buf
[ 3]) << 18;
1929 digest
[ 0] = (l
>> 16) & 0xff;
1930 digest
[10] = (l
>> 8) & 0xff;
1931 digest
[20] = (l
>> 0) & 0xff;
1933 l
= itoa64_to_int (buf
[ 4]) << 0;
1934 l
|= itoa64_to_int (buf
[ 5]) << 6;
1935 l
|= itoa64_to_int (buf
[ 6]) << 12;
1936 l
|= itoa64_to_int (buf
[ 7]) << 18;
1938 digest
[21] = (l
>> 16) & 0xff;
1939 digest
[ 1] = (l
>> 8) & 0xff;
1940 digest
[11] = (l
>> 0) & 0xff;
1942 l
= itoa64_to_int (buf
[ 8]) << 0;
1943 l
|= itoa64_to_int (buf
[ 9]) << 6;
1944 l
|= itoa64_to_int (buf
[10]) << 12;
1945 l
|= itoa64_to_int (buf
[11]) << 18;
1947 digest
[12] = (l
>> 16) & 0xff;
1948 digest
[22] = (l
>> 8) & 0xff;
1949 digest
[ 2] = (l
>> 0) & 0xff;
1951 l
= itoa64_to_int (buf
[12]) << 0;
1952 l
|= itoa64_to_int (buf
[13]) << 6;
1953 l
|= itoa64_to_int (buf
[14]) << 12;
1954 l
|= itoa64_to_int (buf
[15]) << 18;
1956 digest
[ 3] = (l
>> 16) & 0xff;
1957 digest
[13] = (l
>> 8) & 0xff;
1958 digest
[23] = (l
>> 0) & 0xff;
1960 l
= itoa64_to_int (buf
[16]) << 0;
1961 l
|= itoa64_to_int (buf
[17]) << 6;
1962 l
|= itoa64_to_int (buf
[18]) << 12;
1963 l
|= itoa64_to_int (buf
[19]) << 18;
1965 digest
[24] = (l
>> 16) & 0xff;
1966 digest
[ 4] = (l
>> 8) & 0xff;
1967 digest
[14] = (l
>> 0) & 0xff;
1969 l
= itoa64_to_int (buf
[20]) << 0;
1970 l
|= itoa64_to_int (buf
[21]) << 6;
1971 l
|= itoa64_to_int (buf
[22]) << 12;
1972 l
|= itoa64_to_int (buf
[23]) << 18;
1974 digest
[15] = (l
>> 16) & 0xff;
1975 digest
[25] = (l
>> 8) & 0xff;
1976 digest
[ 5] = (l
>> 0) & 0xff;
1978 l
= itoa64_to_int (buf
[24]) << 0;
1979 l
|= itoa64_to_int (buf
[25]) << 6;
1980 l
|= itoa64_to_int (buf
[26]) << 12;
1981 l
|= itoa64_to_int (buf
[27]) << 18;
1983 digest
[ 6] = (l
>> 16) & 0xff;
1984 digest
[16] = (l
>> 8) & 0xff;
1985 digest
[26] = (l
>> 0) & 0xff;
1987 l
= itoa64_to_int (buf
[28]) << 0;
1988 l
|= itoa64_to_int (buf
[29]) << 6;
1989 l
|= itoa64_to_int (buf
[30]) << 12;
1990 l
|= itoa64_to_int (buf
[31]) << 18;
1992 digest
[27] = (l
>> 16) & 0xff;
1993 digest
[ 7] = (l
>> 8) & 0xff;
1994 digest
[17] = (l
>> 0) & 0xff;
1996 l
= itoa64_to_int (buf
[32]) << 0;
1997 l
|= itoa64_to_int (buf
[33]) << 6;
1998 l
|= itoa64_to_int (buf
[34]) << 12;
1999 l
|= itoa64_to_int (buf
[35]) << 18;
2001 digest
[18] = (l
>> 16) & 0xff;
2002 digest
[28] = (l
>> 8) & 0xff;
2003 digest
[ 8] = (l
>> 0) & 0xff;
2005 l
= itoa64_to_int (buf
[36]) << 0;
2006 l
|= itoa64_to_int (buf
[37]) << 6;
2007 l
|= itoa64_to_int (buf
[38]) << 12;
2008 l
|= itoa64_to_int (buf
[39]) << 18;
2010 digest
[ 9] = (l
>> 16) & 0xff;
2011 digest
[19] = (l
>> 8) & 0xff;
2012 digest
[29] = (l
>> 0) & 0xff;
2014 l
= itoa64_to_int (buf
[40]) << 0;
2015 l
|= itoa64_to_int (buf
[41]) << 6;
2016 l
|= itoa64_to_int (buf
[42]) << 12;
2018 digest
[31] = (l
>> 8) & 0xff;
2019 digest
[30] = (l
>> 0) & 0xff;
2022 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2026 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2028 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2029 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2030 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2031 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2033 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2035 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2036 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2037 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2038 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2042 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2043 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2044 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2045 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2049 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2050 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2051 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2052 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2056 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2057 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2058 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2059 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2063 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2064 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2065 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2066 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2070 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2071 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2072 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2073 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2077 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2078 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2079 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2080 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2084 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2085 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2086 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2087 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2091 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2092 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2093 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2094 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2096 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2098 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2099 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2100 buf
[42] = int_to_itoa64 (l
& 0x3f);
2103 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2107 l
= itoa64_to_int (buf
[ 0]) << 0;
2108 l
|= itoa64_to_int (buf
[ 1]) << 6;
2109 l
|= itoa64_to_int (buf
[ 2]) << 12;
2110 l
|= itoa64_to_int (buf
[ 3]) << 18;
2112 digest
[ 0] = (l
>> 0) & 0xff;
2113 digest
[ 1] = (l
>> 8) & 0xff;
2114 digest
[ 2] = (l
>> 16) & 0xff;
2116 l
= itoa64_to_int (buf
[ 4]) << 0;
2117 l
|= itoa64_to_int (buf
[ 5]) << 6;
2118 l
|= itoa64_to_int (buf
[ 6]) << 12;
2119 l
|= itoa64_to_int (buf
[ 7]) << 18;
2121 digest
[ 3] = (l
>> 0) & 0xff;
2122 digest
[ 4] = (l
>> 8) & 0xff;
2123 digest
[ 5] = (l
>> 16) & 0xff;
2125 l
= itoa64_to_int (buf
[ 8]) << 0;
2126 l
|= itoa64_to_int (buf
[ 9]) << 6;
2127 l
|= itoa64_to_int (buf
[10]) << 12;
2128 l
|= itoa64_to_int (buf
[11]) << 18;
2130 digest
[ 6] = (l
>> 0) & 0xff;
2131 digest
[ 7] = (l
>> 8) & 0xff;
2132 digest
[ 8] = (l
>> 16) & 0xff;
2134 l
= itoa64_to_int (buf
[12]) << 0;
2135 l
|= itoa64_to_int (buf
[13]) << 6;
2136 l
|= itoa64_to_int (buf
[14]) << 12;
2137 l
|= itoa64_to_int (buf
[15]) << 18;
2139 digest
[ 9] = (l
>> 0) & 0xff;
2140 digest
[10] = (l
>> 8) & 0xff;
2141 digest
[11] = (l
>> 16) & 0xff;
2143 l
= itoa64_to_int (buf
[16]) << 0;
2144 l
|= itoa64_to_int (buf
[17]) << 6;
2145 l
|= itoa64_to_int (buf
[18]) << 12;
2146 l
|= itoa64_to_int (buf
[19]) << 18;
2148 digest
[12] = (l
>> 0) & 0xff;
2149 digest
[13] = (l
>> 8) & 0xff;
2150 digest
[14] = (l
>> 16) & 0xff;
2152 l
= itoa64_to_int (buf
[20]) << 0;
2153 l
|= itoa64_to_int (buf
[21]) << 6;
2154 l
|= itoa64_to_int (buf
[22]) << 12;
2155 l
|= itoa64_to_int (buf
[23]) << 18;
2157 digest
[15] = (l
>> 0) & 0xff;
2158 digest
[16] = (l
>> 8) & 0xff;
2159 digest
[17] = (l
>> 16) & 0xff;
2161 l
= itoa64_to_int (buf
[24]) << 0;
2162 l
|= itoa64_to_int (buf
[25]) << 6;
2163 l
|= itoa64_to_int (buf
[26]) << 12;
2164 l
|= itoa64_to_int (buf
[27]) << 18;
2166 digest
[18] = (l
>> 0) & 0xff;
2167 digest
[19] = (l
>> 8) & 0xff;
2168 digest
[20] = (l
>> 16) & 0xff;
2170 l
= itoa64_to_int (buf
[28]) << 0;
2171 l
|= itoa64_to_int (buf
[29]) << 6;
2172 l
|= itoa64_to_int (buf
[30]) << 12;
2173 l
|= itoa64_to_int (buf
[31]) << 18;
2175 digest
[21] = (l
>> 0) & 0xff;
2176 digest
[22] = (l
>> 8) & 0xff;
2177 digest
[23] = (l
>> 16) & 0xff;
2179 l
= itoa64_to_int (buf
[32]) << 0;
2180 l
|= itoa64_to_int (buf
[33]) << 6;
2181 l
|= itoa64_to_int (buf
[34]) << 12;
2182 l
|= itoa64_to_int (buf
[35]) << 18;
2184 digest
[24] = (l
>> 0) & 0xff;
2185 digest
[25] = (l
>> 8) & 0xff;
2186 digest
[26] = (l
>> 16) & 0xff;
2188 l
= itoa64_to_int (buf
[36]) << 0;
2189 l
|= itoa64_to_int (buf
[37]) << 6;
2190 l
|= itoa64_to_int (buf
[38]) << 12;
2191 l
|= itoa64_to_int (buf
[39]) << 18;
2193 digest
[27] = (l
>> 0) & 0xff;
2194 digest
[28] = (l
>> 8) & 0xff;
2195 digest
[29] = (l
>> 16) & 0xff;
2197 l
= itoa64_to_int (buf
[40]) << 0;
2198 l
|= itoa64_to_int (buf
[41]) << 6;
2199 l
|= itoa64_to_int (buf
[42]) << 12;
2200 l
|= itoa64_to_int (buf
[43]) << 18;
2202 digest
[30] = (l
>> 0) & 0xff;
2203 digest
[31] = (l
>> 8) & 0xff;
2204 digest
[32] = (l
>> 16) & 0xff;
2239 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2243 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2245 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2246 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2247 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2248 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2250 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2252 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2253 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2254 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2255 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2257 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2259 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2260 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2261 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2262 buf
[11] = int_to_itoa64 (l
& 0x3f);
2264 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2266 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2267 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2268 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2269 buf
[15] = int_to_itoa64 (l
& 0x3f);
2271 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2273 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2274 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2275 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2276 buf
[19] = int_to_itoa64 (l
& 0x3f);
2278 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2280 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2281 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2282 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2283 buf
[23] = int_to_itoa64 (l
& 0x3f);
2285 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2287 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2288 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2289 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2290 buf
[27] = int_to_itoa64 (l
& 0x3f);
2292 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2294 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2295 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2296 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2297 buf
[31] = int_to_itoa64 (l
& 0x3f);
2299 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2301 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2302 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2303 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2304 buf
[35] = int_to_itoa64 (l
& 0x3f);
2306 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2308 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2309 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2310 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2311 buf
[39] = int_to_itoa64 (l
& 0x3f);
2313 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2315 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2316 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2317 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2318 //buf[43] = int_to_itoa64 (l & 0x3f);
2326 static struct termio savemodes
;
2327 static int havemodes
= 0;
2331 struct termio modmodes
;
2333 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2337 modmodes
= savemodes
;
2338 modmodes
.c_lflag
&= ~ICANON
;
2339 modmodes
.c_cc
[VMIN
] = 1;
2340 modmodes
.c_cc
[VTIME
] = 0;
2342 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2351 FD_SET (fileno (stdin
), &rfds
);
2358 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2360 if (retval
== 0) return 0;
2361 if (retval
== -1) return -1;
2368 if (!havemodes
) return 0;
2370 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2375 static struct termios savemodes
;
2376 static int havemodes
= 0;
2380 struct termios modmodes
;
2382 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2386 modmodes
= savemodes
;
2387 modmodes
.c_lflag
&= ~ICANON
;
2388 modmodes
.c_cc
[VMIN
] = 1;
2389 modmodes
.c_cc
[VTIME
] = 0;
2391 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2400 FD_SET (fileno (stdin
), &rfds
);
2407 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2409 if (retval
== 0) return 0;
2410 if (retval
== -1) return -1;
2417 if (!havemodes
) return 0;
2419 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2424 static DWORD saveMode
= 0;
2428 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2430 GetConsoleMode (stdinHandle
, &saveMode
);
2431 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2438 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2440 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2442 if (rc
== WAIT_TIMEOUT
) return 0;
2443 if (rc
== WAIT_ABANDONED
) return -1;
2444 if (rc
== WAIT_FAILED
) return -1;
2446 // The whole ReadConsoleInput () part is a workaround.
2447 // For some unknown reason, maybe a mingw bug, a random signal
2448 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2449 // Then it wants to read with getche () a keyboard input
2450 // which has never been made.
2452 INPUT_RECORD buf
[100];
2456 memset (buf
, 0, sizeof (buf
));
2458 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2460 FlushConsoleInputBuffer (stdinHandle
);
2462 for (uint i
= 0; i
< num
; i
++)
2464 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2466 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2468 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2470 return KeyEvent
.uChar
.AsciiChar
;
2478 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2480 SetConsoleMode (stdinHandle
, saveMode
);
2490 #define MSG_ENOMEM "Insufficient memory available"
2492 void *mycalloc (size_t nmemb
, size_t size
)
2494 void *p
= calloc (nmemb
, size
);
2498 log_error ("ERROR: %s", MSG_ENOMEM
);
2506 void *mymalloc (size_t size
)
2508 void *p
= malloc (size
);
2512 log_error ("ERROR: %s", MSG_ENOMEM
);
2517 memset (p
, 0, size
);
2522 void myfree (void *ptr
)
2524 if (ptr
== NULL
) return;
2529 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2531 void *p
= realloc (ptr
, oldsz
+ add
);
2535 log_error ("ERROR: %s", MSG_ENOMEM
);
2540 memset ((char *) p
+ oldsz
, 0, add
);
2545 char *mystrdup (const char *s
)
2547 const size_t len
= strlen (s
);
2549 char *b
= (char *) mymalloc (len
+ 1);
2556 FILE *logfile_open (char *logfile
)
2558 FILE *fp
= fopen (logfile
, "ab");
2568 void logfile_close (FILE *fp
)
2570 if (fp
== stdout
) return;
2575 void logfile_append (const char *fmt
, ...)
2577 if (data
.logfile_disable
== 1) return;
2579 FILE *fp
= logfile_open (data
.logfile
);
2585 vfprintf (fp
, fmt
, ap
);
2596 int logfile_generate_id ()
2598 const int n
= rand ();
2607 char *logfile_generate_topid ()
2609 const int id
= logfile_generate_id ();
2611 char *topid
= (char *) mymalloc (1 + 16 + 1);
2613 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2618 char *logfile_generate_subid ()
2620 const int id
= logfile_generate_id ();
2622 char *subid
= (char *) mymalloc (1 + 16 + 1);
2624 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2634 void lock_file (FILE *fp
)
2638 memset (&lock
, 0, sizeof (struct flock
));
2640 lock
.l_type
= F_WRLCK
;
2641 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2645 log_error ("ERROR: failed acquiring write lock: %s", strerror (errno
));
2652 void unlock_file (FILE *fp
)
2656 memset (&lock
, 0, sizeof (struct flock
));
2658 lock
.l_type
= F_UNLCK
;
2659 fcntl(fileno(fp
), F_SETLK
, &lock
);
2666 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2668 FlushFileBuffers (h
);
2677 #if defined(_WIN) && defined(HAVE_NVAPI)
2678 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2682 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nv
, nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2686 log_info ("WARN: No NvAPI adapters found");
2693 #endif // _WIN && HAVE_NVAPI
2695 #if defined(LINUX) && defined(HAVE_NVML)
2696 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2700 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2702 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nv
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2704 // can be used to determine if the device by index matches the cuda device by index
2705 // char name[100]; memset (name, 0, sizeof (name));
2706 // hm_NVML_nvmlDeviceGetName (data.hm_nv, nvGPUHandle[i], name, sizeof (name) - 1);
2713 log_info ("WARN: No NVML adapters found");
2720 #endif // LINUX && HAVE_NVML
2723 int get_adapters_num_amd (void *adl
, int *iNumberAdapters
)
2725 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2727 if (iNumberAdapters
== 0)
2729 log_info ("WARN: No ADL adapters found.");
2738 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2740 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2741 ADLODParameters lpOdParameters;
2743 lpOdParameters.iSize = sizeof (ADLODParameters);
2744 size_t plevels_size = 0;
2746 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2748 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2749 __func__, iAdapterIndex,
2750 lpOdParameters.iNumberOfPerformanceLevels,
2751 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2752 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2754 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2756 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2758 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2760 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2762 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2763 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2764 __func__, iAdapterIndex, j,
2765 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2767 myfree (lpOdPerformanceLevels);
2773 LPAdapterInfo
hm_get_adapter_info_amd (void *adl
, int iNumberAdapters
)
2775 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2777 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2779 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2781 return lpAdapterInfo
;
2786 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2789 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2793 for (uint i = 0; i < num_adl_adapters; i++)
2795 int opencl_bus_num = hm_device[i].busid;
2796 int opencl_dev_num = hm_device[i].devid;
2798 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2806 if (idx >= DEVICES_MAX) return -1;
2811 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2813 for (uint i = 0; i < opencl_num_devices; i++)
2815 cl_device_topology_amd device_topology;
2817 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2819 hm_device[i].busid = device_topology.pcie.bus;
2820 hm_device[i].devid = device_topology.pcie.device;
2825 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2827 // basically bubble sort
2829 for (int i
= 0; i
< num_adl_adapters
; i
++)
2831 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2833 // get info of adapter [x]
2835 u32 adapter_index_x
= valid_adl_device_list
[j
];
2836 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2838 u32 bus_num_x
= info_x
.iBusNumber
;
2839 u32 dev_num_x
= info_x
.iDeviceNumber
;
2841 // get info of adapter [y]
2843 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2844 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2846 u32 bus_num_y
= info_y
.iBusNumber
;
2847 u32 dev_num_y
= info_y
.iDeviceNumber
;
2851 if (bus_num_y
< bus_num_x
)
2855 else if (bus_num_y
== bus_num_x
)
2857 if (dev_num_y
< dev_num_x
)
2865 u32 temp
= valid_adl_device_list
[j
+ 1];
2867 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2868 valid_adl_device_list
[j
+ 0] = temp
;
2874 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2876 *num_adl_adapters
= 0;
2878 u32
*adl_adapters
= NULL
;
2880 int *bus_numbers
= NULL
;
2881 int *device_numbers
= NULL
;
2883 for (int i
= 0; i
< iNumberAdapters
; i
++)
2885 AdapterInfo info
= lpAdapterInfo
[i
];
2887 if (strlen (info
.strUDID
) < 1) continue;
2890 if (info
.iVendorID
!= 1002) continue;
2892 if (info
.iVendorID
!= 0x1002) continue;
2895 if (info
.iBusNumber
< 0) continue;
2896 if (info
.iDeviceNumber
< 0) continue;
2900 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2902 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2909 if (found
) continue;
2911 // add it to the list
2913 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2915 adl_adapters
[*num_adl_adapters
] = i
;
2917 // rest is just bookkeeping
2919 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2920 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2922 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2923 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2925 (*num_adl_adapters
)++;
2928 myfree (bus_numbers
);
2929 myfree (device_numbers
);
2931 // sort the list by increasing bus id, device id number
2933 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2935 return adl_adapters
;
2938 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2940 // loop through all valid devices
2942 for (int i
= 0; i
< num_adl_adapters
; i
++)
2944 u32 adapter_index
= valid_adl_device_list
[i
];
2948 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2950 // unfortunately this doesn't work since bus id and dev id are not unique
2951 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2952 // if (opencl_device_index == -1) continue;
2954 int opencl_device_index
= i
;
2956 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2958 // get fanspeed info
2960 if (hm_device
[opencl_device_index
].od_version
== 5)
2962 ADLFanSpeedInfo FanSpeedInfo
;
2964 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2966 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2968 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2970 // check read and write capability in fanspeedinfo
2972 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2973 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2975 hm_device
[opencl_device_index
].fan_supported
= 1;
2979 hm_device
[opencl_device_index
].fan_supported
= 0;
2982 else // od_version == 6
2984 ADLOD6FanSpeedInfo faninfo
;
2986 memset (&faninfo
, 0, sizeof (faninfo
));
2988 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2990 // check read capability in fanspeedinfo
2992 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2994 hm_device
[opencl_device_index
].fan_supported
= 1;
2998 hm_device
[opencl_device_index
].fan_supported
= 0;
3006 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3008 for (int i
= 0; i
< num_adl_adapters
; i
++)
3010 u32 adapter_index
= valid_adl_device_list
[i
];
3014 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3016 // get overdrive version
3018 int od_supported
= 0;
3022 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3024 // store the overdrive version in hm_device
3026 // unfortunately this doesn't work since bus id and dev id are not unique
3027 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3028 // if (opencl_device_index == -1) continue;
3030 int opencl_device_index
= i
;
3032 hm_device
[opencl_device_index
].od_version
= od_version
;
3038 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3040 for (int i
= 0; i
< num_adl_adapters
; i
++)
3042 u32 adapter_index
= valid_adl_device_list
[i
];
3046 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3048 // store the iAdapterIndex in hm_device
3050 // unfortunately this doesn't work since bus id and dev id are not unique
3051 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3052 // if (opencl_device_index == -1) continue;
3054 int opencl_device_index
= i
;
3056 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3059 return num_adl_adapters
;
3063 int hm_get_temperature_with_device_id (const uint device_id
)
3065 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3068 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3072 if (data
.hm_device
[device_id
].od_version
== 5)
3074 ADLTemperature Temperature
;
3076 Temperature
.iSize
= sizeof (ADLTemperature
);
3078 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3080 return Temperature
.iTemperature
/ 1000;
3082 else if (data
.hm_device
[device_id
].od_version
== 6)
3084 int Temperature
= 0;
3086 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3088 return Temperature
/ 1000;
3094 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3095 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3097 #if defined(LINUX) && defined(HAVE_NVML)
3098 int temperature
= 0;
3100 hm_NVML_nvmlDeviceGetTemperature (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (unsigned int *) &temperature
);
3105 #if defined(WIN) && defined(HAVE_NVAPI)
3106 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3108 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3109 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3110 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3111 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3113 if (hm_NvAPI_GPU_GetThermalSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3115 return pThermalSettings
.sensor
[0].currentTemp
;
3116 #endif // WIN && HAVE_NVAPI
3118 #endif // HAVE_NVML || HAVE_NVAPI
3123 int hm_get_fanspeed_with_device_id (const uint device_id
)
3125 // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
3126 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3128 if (data
.hm_device
[device_id
].fan_supported
== 1)
3131 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3135 if (data
.hm_device
[device_id
].od_version
== 5)
3137 ADLFanSpeedValue lpFanSpeedValue
;
3139 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3141 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3142 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3143 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3145 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3147 return lpFanSpeedValue
.iFanSpeed
;
3149 else // od_version == 6
3151 ADLOD6FanSpeedInfo faninfo
;
3153 memset (&faninfo
, 0, sizeof (faninfo
));
3155 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3157 return faninfo
.iFanSpeedPercent
;
3163 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3164 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3166 #if defined(LINUX) && defined(HAVE_NVML)
3169 hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (unsigned int *) &speed
);
3174 #if defined(WIN) && defined(HAVE_NVAPI)
3176 NV_GPU_COOLER_SETTINGS pCoolerSettings
;
3178 pCoolerSettings
.Version
= GPU_COOLER_SETTINGS_VER
| sizeof (NV_GPU_COOLER_SETTINGS
);
3180 hm_NvAPI_GPU_GetCoolerSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pCoolerSettings
);
3182 return pCoolerSettings
.Cooler
[0].CurrentLevel
;
3185 #endif // HAVE_NVML || HAVE_NVAPI
3191 int hm_get_utilization_with_device_id (const uint device_id
)
3193 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3196 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3200 ADLPMActivity PMActivity
;
3202 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3204 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3206 return PMActivity
.iActivityPercent
;
3211 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3212 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3214 #if defined(LINUX) && defined(HAVE_NVML)
3215 nvmlUtilization_t utilization
;
3217 hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3219 return utilization
.gpu
;
3222 #if defined(WIN) && defined(HAVE_NVAPI)
3223 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3225 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3227 if (hm_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3229 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3232 #endif // HAVE_NVML || HAVE_NVAPI
3238 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3240 if (data
.hm_device
[device_id
].fan_supported
== 1)
3244 if (data
.hm_device
[device_id
].od_version
== 5)
3246 ADLFanSpeedValue lpFanSpeedValue
;
3248 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3250 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3251 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3252 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3253 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3255 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3259 else // od_version == 6
3261 ADLOD6FanSpeedValue fan_speed_value
;
3263 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3265 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3266 fan_speed_value
.iFanSpeed
= fanspeed
;
3268 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3279 // helper function for status display
3281 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3283 #define VALUE_NOT_AVAILABLE "N/A"
3287 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3291 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3294 #endif // HAVE_HWMON
3300 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3302 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3304 if (css_cnt
> SP_PW_MAX
)
3306 log_error ("ERROR: mask length is too long");
3311 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3313 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3315 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3316 uint cs_len
= css
[css_pos
].cs_len
;
3318 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3320 uint c
= cs_buf
[cs_pos
] & 0xff;
3327 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3329 cs_t
*cs
= &css
[css_cnt
];
3331 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3333 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3337 for (i
= 0; i
< cs
->cs_len
; i
++)
3339 const uint u
= cs
->cs_buf
[i
];
3344 for (i
= 0; i
< in_len
; i
++)
3346 uint u
= in_buf
[i
] & 0xff;
3348 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3350 if (css_uniq
[u
] == 1) continue;
3354 cs
->cs_buf
[cs
->cs_len
] = u
;
3362 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3366 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3368 uint p0
= in_buf
[in_pos
] & 0xff;
3370 if (interpret
== 1 && p0
== '?')
3374 if (in_pos
== in_len
) break;
3376 uint p1
= in_buf
[in_pos
] & 0xff;
3380 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3382 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3384 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3386 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3388 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3390 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3392 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3393 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3395 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3396 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3398 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3399 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3401 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3402 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3404 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3406 default: log_error ("Syntax error: %s", in_buf
);
3412 if (data
.hex_charset
)
3416 if (in_pos
== in_len
)
3418 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3423 uint p1
= in_buf
[in_pos
] & 0xff;
3425 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3427 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3434 chr
= hex_convert (p1
) << 0;
3435 chr
|= hex_convert (p0
) << 4;
3437 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3443 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3449 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3453 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3455 sum
*= css
[css_pos
].cs_len
;
3461 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3463 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3468 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3470 char p0
= mask_buf
[mask_pos
];
3476 if (mask_pos
== mask_len
) break;
3478 char p1
= mask_buf
[mask_pos
];
3484 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3486 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3488 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3490 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3492 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3494 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3496 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3497 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3499 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3500 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3502 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3503 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3505 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3506 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3508 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3510 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3516 if (data
.hex_charset
)
3520 // if there is no 2nd hex character, show an error:
3522 if (mask_pos
== mask_len
)
3524 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3529 char p1
= mask_buf
[mask_pos
];
3531 // if they are not valid hex character, show an error:
3533 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3535 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3542 chr
|= hex_convert (p1
) << 0;
3543 chr
|= hex_convert (p0
) << 4;
3545 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3551 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3558 log_error ("ERROR: invalid mask length (0)");
3568 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3570 for (int i
= 0; i
< css_cnt
; i
++)
3572 uint len
= css
[i
].cs_len
;
3573 u64 next
= val
/ len
;
3574 uint pos
= val
% len
;
3575 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3580 void mp_cut_at (char *mask
, uint max
)
3584 uint mask_len
= strlen (mask
);
3586 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3588 if (mask
[i
] == '?') i
++;
3594 void mp_setup_sys (cs_t
*mp_sys
)
3598 uint donec
[CHARSIZ
] = { 0 };
3600 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3601 mp_sys
[0].cs_buf
[pos
++] = chr
;
3602 mp_sys
[0].cs_len
= pos
; }
3604 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3605 mp_sys
[1].cs_buf
[pos
++] = chr
;
3606 mp_sys
[1].cs_len
= pos
; }
3608 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3609 mp_sys
[2].cs_buf
[pos
++] = chr
;
3610 mp_sys
[2].cs_len
= pos
; }
3612 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3613 mp_sys
[3].cs_buf
[pos
++] = chr
;
3614 mp_sys
[3].cs_len
= pos
; }
3616 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3617 mp_sys
[4].cs_len
= pos
; }
3619 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3620 mp_sys
[5].cs_len
= pos
; }
3623 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3625 FILE *fp
= fopen (buf
, "rb");
3627 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3629 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3633 char mp_file
[1024] = { 0 };
3635 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3639 len
= in_superchop (mp_file
);
3643 log_info ("WARNING: charset file corrupted");
3645 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3649 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3654 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3656 mp_usr
[index
].cs_len
= 0;
3658 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3661 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3663 char *new_mask_buf
= (char *) mymalloc (256);
3669 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3671 if (css_pos
== len
) break;
3673 char p0
= mask_buf
[mask_pos
];
3675 new_mask_buf
[mask_pos
] = p0
;
3681 if (mask_pos
== mask_len
) break;
3683 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3687 if (data
.hex_charset
)
3691 if (mask_pos
== mask_len
)
3693 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3698 char p1
= mask_buf
[mask_pos
];
3700 // if they are not valid hex character, show an error:
3702 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3704 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3709 new_mask_buf
[mask_pos
] = p1
;
3714 if (css_pos
== len
) return (new_mask_buf
);
3716 myfree (new_mask_buf
);
3725 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3731 for (i
= start
; i
< stop
; i
++)
3733 sum
*= root_css_buf
[i
].cs_len
;
3739 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3743 cs_t
*cs
= &root_css_buf
[start
];
3747 for (i
= start
; i
< stop
; i
++)
3749 const u64 m
= v
% cs
->cs_len
;
3750 const u64 d
= v
/ cs
->cs_len
;
3754 const uint k
= cs
->cs_buf
[m
];
3756 pw_buf
[i
- start
] = (char) k
;
3758 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3762 int sp_comp_val (const void *p1
, const void *p2
)
3764 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3765 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3767 return b2
->val
- b1
->val
;
3770 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
)
3777 * Initialize hcstats
3780 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3782 u64
*root_stats_ptr
= root_stats_buf
;
3784 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3786 for (i
= 0; i
< SP_PW_MAX
; i
++)
3788 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3790 root_stats_ptr
+= CHARSIZ
;
3793 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3795 u64
*markov_stats_ptr
= markov_stats_buf
;
3797 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3799 for (i
= 0; i
< SP_PW_MAX
; i
++)
3801 for (j
= 0; j
< CHARSIZ
; j
++)
3803 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3805 markov_stats_ptr
+= CHARSIZ
;
3815 char hcstat_tmp
[256] = { 0 };
3817 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3819 hcstat
= hcstat_tmp
;
3822 FILE *fd
= fopen (hcstat
, "rb");
3826 log_error ("%s: %s", hcstat
, strerror (errno
));
3831 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3833 log_error ("%s: Could not load data", hcstat
);
3840 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3842 log_error ("%s: Could not load data", hcstat
);
3852 * Markov modifier of hcstat_table on user request
3857 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
3858 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
3863 /* Add all stats to first position */
3865 for (i
= 1; i
< SP_PW_MAX
; i
++)
3867 u64
*out
= root_stats_buf_by_pos
[0];
3868 u64
*in
= root_stats_buf_by_pos
[i
];
3870 for (j
= 0; j
< CHARSIZ
; j
++)
3876 for (i
= 1; i
< SP_PW_MAX
; i
++)
3878 u64
*out
= markov_stats_buf_by_key
[0][0];
3879 u64
*in
= markov_stats_buf_by_key
[i
][0];
3881 for (j
= 0; j
< CHARSIZ
; j
++)
3883 for (k
= 0; k
< CHARSIZ
; k
++)
3890 /* copy them to all pw_positions */
3892 for (i
= 1; i
< SP_PW_MAX
; i
++)
3894 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
3897 for (i
= 1; i
< SP_PW_MAX
; i
++)
3899 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
3907 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3909 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3911 for (i
= 0; i
< SP_PW_MAX
; i
++)
3913 root_table_buf_by_pos
[i
] = root_table_ptr
;
3915 root_table_ptr
+= CHARSIZ
;
3918 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3920 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3922 for (i
= 0; i
< SP_PW_MAX
; i
++)
3924 for (j
= 0; j
< CHARSIZ
; j
++)
3926 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3928 markov_table_ptr
+= CHARSIZ
;
3933 * Convert hcstat to tables
3936 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3938 uint key
= i
% CHARSIZ
;
3940 root_table_buf
[i
].key
= key
;
3941 root_table_buf
[i
].val
= root_stats_buf
[i
];
3944 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3946 uint key
= i
% CHARSIZ
;
3948 markov_table_buf
[i
].key
= key
;
3949 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3952 myfree (root_stats_buf
);
3953 myfree (markov_stats_buf
);
3959 for (i
= 0; i
< SP_PW_MAX
; i
++)
3961 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3964 for (i
= 0; i
< SP_PW_MAX
; i
++)
3966 for (j
= 0; j
< CHARSIZ
; j
++)
3968 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3973 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
])
3976 * Convert tables to css
3979 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
3981 uint pw_pos
= i
/ CHARSIZ
;
3983 cs_t
*cs
= &root_css_buf
[pw_pos
];
3985 if (cs
->cs_len
== threshold
) continue;
3987 uint key
= root_table_buf
[i
].key
;
3989 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
3991 cs
->cs_buf
[cs
->cs_len
] = key
;
3997 * Convert table to css
4000 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4002 uint c
= i
/ CHARSIZ
;
4004 cs_t
*cs
= &markov_css_buf
[c
];
4006 if (cs
->cs_len
== threshold
) continue;
4008 uint pw_pos
= c
/ CHARSIZ
;
4010 uint key
= markov_table_buf
[i
].key
;
4012 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4014 cs
->cs_buf
[cs
->cs_len
] = key
;
4020 for (uint i = 0; i < 8; i++)
4022 for (uint j = 0x20; j < 0x80; j++)
4024 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4026 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4028 for (uint k = 0; k < 10; k++)
4030 printf (" %u\n", ptr->cs_buf[k]);
4037 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4039 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4041 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4051 for (uint j
= 1; j
< CHARSIZ
; j
++)
4061 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4063 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4065 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4067 out
+= CHARSIZ
* CHARSIZ
;
4068 in
+= CHARSIZ
* CHARSIZ
;
4070 for (uint j
= 0; j
< CHARSIZ
; j
++)
4077 for (uint k
= 1; k
< CHARSIZ
; k
++)
4089 * mixed shared functions
4092 void dump_hex (const u8
*s
, const int sz
)
4094 for (int i
= 0; i
< sz
; i
++)
4096 log_info_nn ("%02x ", s
[i
]);
4102 void usage_mini_print (const char *progname
)
4104 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4107 void usage_big_print (const char *progname
)
4109 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4112 char *get_exec_path ()
4114 int exec_path_len
= 1024;
4116 char *exec_path
= (char *) mymalloc (exec_path_len
);
4120 char tmp
[32] = { 0 };
4122 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4124 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4128 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4132 uint size
= exec_path_len
;
4134 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4136 log_error("! executable path buffer too small\n");
4141 const int len
= strlen (exec_path
);
4144 #error Your Operating System is not supported or detected
4152 char *get_install_dir (const char *progname
)
4154 char *install_dir
= mystrdup (progname
);
4155 char *last_slash
= NULL
;
4157 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4161 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4167 install_dir
[0] = '.';
4171 return (install_dir
);
4174 char *get_profile_dir (const char *homedir
)
4176 #define DOT_HASHCAT ".hashcat"
4178 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4180 char *profile_dir
= (char *) mymalloc (len
+ 1);
4182 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4187 char *get_session_dir (const char *profile_dir
)
4189 #define SESSIONS_FOLDER "sessions"
4191 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4193 char *session_dir
= (char *) mymalloc (len
+ 1);
4195 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4200 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4204 FILE *fd
= fopen (filename
, "rb");
4208 log_error ("%s: %s", filename
, strerror (errno
));
4213 #define MAX_KEY_SIZE (1024 * 1024)
4215 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4217 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4223 for (int fpos
= 0; fpos
< nread
; fpos
++)
4225 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4227 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4228 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4229 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4230 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4232 if (kpos
>= 64) kpos
= 0;
4239 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4243 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4244 if (CPU_ISSET(core
, cpu_set
)) break;
4246 thread_affinity_policy_data_t policy
= { core
};
4248 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4250 if (data
.quiet
== 0)
4252 if (rc
!= KERN_SUCCESS
)
4254 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4262 void set_cpu_affinity (char *cpu_affinity
)
4265 DWORD_PTR aff_mask
= 0;
4273 char *devices
= strdup (cpu_affinity
);
4275 char *next
= strtok (devices
, ",");
4279 uint cpu_id
= atoi (next
);
4294 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4300 aff_mask
|= 1 << (cpu_id
- 1);
4302 CPU_SET ((cpu_id
- 1), &cpuset
);
4305 } while ((next
= strtok (NULL
, ",")) != NULL
);
4311 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4312 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4314 pthread_t thread
= pthread_self ();
4315 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4319 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4321 char *element
, *end
;
4323 end
= (char *) base
+ nmemb
* size
;
4325 for (element
= (char *) base
; element
< end
; element
+= size
)
4326 if (!compar (element
, key
))
4332 int sort_by_salt (const void *v1
, const void *v2
)
4334 const salt_t
*s1
= (const salt_t
*) v1
;
4335 const salt_t
*s2
= (const salt_t
*) v2
;
4337 const int res1
= s1
->salt_len
- s2
->salt_len
;
4339 if (res1
!= 0) return (res1
);
4341 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4343 if (res2
!= 0) return (res2
);
4351 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4352 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4359 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4360 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4366 int sort_by_salt_buf (const void *v1
, const void *v2
)
4368 const pot_t
*p1
= (const pot_t
*) v1
;
4369 const pot_t
*p2
= (const pot_t
*) v2
;
4371 const hash_t
*h1
= &p1
->hash
;
4372 const hash_t
*h2
= &p2
->hash
;
4374 const salt_t
*s1
= h1
->salt
;
4375 const salt_t
*s2
= h2
->salt
;
4381 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4382 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4388 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4390 const hash_t
*h1
= (const hash_t
*) v1
;
4391 const hash_t
*h2
= (const hash_t
*) v2
;
4393 const salt_t
*s1
= h1
->salt
;
4394 const salt_t
*s2
= h2
->salt
;
4396 // testphase: this should work
4401 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4402 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4405 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4406 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4407 if (s1->salt_len > s2->salt_len) return ( 1);
4408 if (s1->salt_len < s2->salt_len) return (-1);
4410 uint n = s1->salt_len;
4414 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4415 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4422 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4424 const hash_t
*h1
= (const hash_t
*) v1
;
4425 const hash_t
*h2
= (const hash_t
*) v2
;
4427 const salt_t
*s1
= h1
->salt
;
4428 const salt_t
*s2
= h2
->salt
;
4430 // 16 - 2 (since last 2 uints contain the digest)
4435 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4436 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4442 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4444 const hash_t
*h1
= (const hash_t
*) v1
;
4445 const hash_t
*h2
= (const hash_t
*) v2
;
4447 const void *d1
= h1
->digest
;
4448 const void *d2
= h2
->digest
;
4450 return data
.sort_by_digest (d1
, d2
);
4453 int sort_by_hash (const void *v1
, const void *v2
)
4455 const hash_t
*h1
= (const hash_t
*) v1
;
4456 const hash_t
*h2
= (const hash_t
*) v2
;
4460 const salt_t
*s1
= h1
->salt
;
4461 const salt_t
*s2
= h2
->salt
;
4463 int res
= sort_by_salt (s1
, s2
);
4465 if (res
!= 0) return (res
);
4468 const void *d1
= h1
->digest
;
4469 const void *d2
= h2
->digest
;
4471 return data
.sort_by_digest (d1
, d2
);
4474 int sort_by_pot (const void *v1
, const void *v2
)
4476 const pot_t
*p1
= (const pot_t
*) v1
;
4477 const pot_t
*p2
= (const pot_t
*) v2
;
4479 const hash_t
*h1
= &p1
->hash
;
4480 const hash_t
*h2
= &p2
->hash
;
4482 return sort_by_hash (h1
, h2
);
4485 int sort_by_mtime (const void *p1
, const void *p2
)
4487 const char **f1
= (const char **) p1
;
4488 const char **f2
= (const char **) p2
;
4490 struct stat s1
; stat (*f1
, &s1
);
4491 struct stat s2
; stat (*f2
, &s2
);
4493 return s2
.st_mtime
- s1
.st_mtime
;
4496 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4498 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4499 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4501 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4504 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4506 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4507 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4509 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4512 int sort_by_stringptr (const void *p1
, const void *p2
)
4514 const char **s1
= (const char **) p1
;
4515 const char **s2
= (const char **) p2
;
4517 return strcmp (*s1
, *s2
);
4520 int sort_by_dictstat (const void *s1
, const void *s2
)
4522 dictstat_t
*d1
= (dictstat_t
*) s1
;
4523 dictstat_t
*d2
= (dictstat_t
*) s2
;
4526 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4528 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4531 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4534 int sort_by_bitmap (const void *p1
, const void *p2
)
4536 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4537 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4539 return b1
->collisions
- b2
->collisions
;
4542 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4544 const u32
*d1
= (const u32
*) v1
;
4545 const u32
*d2
= (const u32
*) v2
;
4551 if (d1
[n
] > d2
[n
]) return ( 1);
4552 if (d1
[n
] < d2
[n
]) return (-1);
4558 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4560 const u32
*d1
= (const u32
*) v1
;
4561 const u32
*d2
= (const u32
*) v2
;
4567 if (d1
[n
] > d2
[n
]) return ( 1);
4568 if (d1
[n
] < d2
[n
]) return (-1);
4574 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4576 const u32
*d1
= (const u32
*) v1
;
4577 const u32
*d2
= (const u32
*) v2
;
4583 if (d1
[n
] > d2
[n
]) return ( 1);
4584 if (d1
[n
] < d2
[n
]) return (-1);
4590 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4592 const u32
*d1
= (const u32
*) v1
;
4593 const u32
*d2
= (const u32
*) v2
;
4599 if (d1
[n
] > d2
[n
]) return ( 1);
4600 if (d1
[n
] < d2
[n
]) return (-1);
4606 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4608 const u32
*d1
= (const u32
*) v1
;
4609 const u32
*d2
= (const u32
*) v2
;
4615 if (d1
[n
] > d2
[n
]) return ( 1);
4616 if (d1
[n
] < d2
[n
]) return (-1);
4622 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4624 const u32
*d1
= (const u32
*) v1
;
4625 const u32
*d2
= (const u32
*) v2
;
4631 if (d1
[n
] > d2
[n
]) return ( 1);
4632 if (d1
[n
] < d2
[n
]) return (-1);
4638 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4640 const u32
*d1
= (const u32
*) v1
;
4641 const u32
*d2
= (const u32
*) v2
;
4647 if (d1
[n
] > d2
[n
]) return ( 1);
4648 if (d1
[n
] < d2
[n
]) return (-1);
4654 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4656 const u32
*d1
= (const u32
*) v1
;
4657 const u32
*d2
= (const u32
*) v2
;
4663 if (d1
[n
] > d2
[n
]) return ( 1);
4664 if (d1
[n
] < d2
[n
]) return (-1);
4670 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4672 const u64
*d1
= (const u64
*) v1
;
4673 const u64
*d2
= (const u64
*) v2
;
4679 if (d1
[n
] > d2
[n
]) return ( 1);
4680 if (d1
[n
] < d2
[n
]) return (-1);
4686 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4688 const u64
*d1
= (const u64
*) v1
;
4689 const u64
*d2
= (const u64
*) v2
;
4695 if (d1
[n
] > d2
[n
]) return ( 1);
4696 if (d1
[n
] < d2
[n
]) return (-1);
4702 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4704 const u64
*d1
= (const u64
*) v1
;
4705 const u64
*d2
= (const u64
*) v2
;
4711 if (d1
[n
] > d2
[n
]) return ( 1);
4712 if (d1
[n
] < d2
[n
]) return (-1);
4718 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4720 const u32
*d1
= (const u32
*) v1
;
4721 const u32
*d2
= (const u32
*) v2
;
4723 const uint dgst_pos0
= data
.dgst_pos0
;
4724 const uint dgst_pos1
= data
.dgst_pos1
;
4725 const uint dgst_pos2
= data
.dgst_pos2
;
4726 const uint dgst_pos3
= data
.dgst_pos3
;
4728 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4729 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4730 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4731 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4732 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4733 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4734 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4735 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4740 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
)
4742 uint outfile_autohex
= data
.outfile_autohex
;
4744 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4746 FILE *debug_fp
= NULL
;
4748 if (debug_file
!= NULL
)
4750 debug_fp
= fopen (debug_file
, "ab");
4752 lock_file (debug_fp
);
4759 if (debug_fp
== NULL
)
4761 log_info ("WARNING: Could not open debug-file for writing");
4765 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4767 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4769 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4772 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4774 if (debug_mode
== 4)
4776 fputc (':', debug_fp
);
4778 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4781 fputc ('\n', debug_fp
);
4783 if (debug_file
!= NULL
) fclose (debug_fp
);
4787 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4789 int needs_hexify
= 0;
4791 if (outfile_autohex
== 1)
4793 for (uint i
= 0; i
< plain_len
; i
++)
4795 if (plain_ptr
[i
] < 0x20)
4802 if (plain_ptr
[i
] > 0x7f)
4811 if (needs_hexify
== 1)
4813 fprintf (fp
, "$HEX[");
4815 for (uint i
= 0; i
< plain_len
; i
++)
4817 fprintf (fp
, "%02x", plain_ptr
[i
]);
4824 fwrite (plain_ptr
, plain_len
, 1, fp
);
4828 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
)
4830 uint outfile_format
= data
.outfile_format
;
4832 char separator
= data
.separator
;
4834 if (outfile_format
& OUTFILE_FMT_HASH
)
4836 fprintf (out_fp
, "%s", out_buf
);
4838 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4840 fputc (separator
, out_fp
);
4843 else if (data
.username
)
4845 if (username
!= NULL
)
4847 for (uint i
= 0; i
< user_len
; i
++)
4849 fprintf (out_fp
, "%c", username
[i
]);
4852 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4854 fputc (separator
, out_fp
);
4859 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4861 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4863 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4865 fputc (separator
, out_fp
);
4869 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4871 for (uint i
= 0; i
< plain_len
; i
++)
4873 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4876 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4878 fputc (separator
, out_fp
);
4882 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4885 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4890 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
4892 fprintf (out_fp
, "%llu", crackpos
);
4897 fputc ('\n', out_fp
);
4900 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
)
4904 pot_key
.hash
.salt
= hashes_buf
->salt
;
4905 pot_key
.hash
.digest
= hashes_buf
->digest
;
4907 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4913 input_buf
[input_len
] = 0;
4916 unsigned char *username
= NULL
;
4921 user_t
*user
= hashes_buf
->hash_info
->user
;
4925 username
= (unsigned char *) (user
->user_name
);
4927 user_len
= user
->user_len
;
4931 // do output the line
4932 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
4936 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
4937 #define LM_MASKED_PLAIN "[notfound]"
4939 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
)
4945 pot_left_key
.hash
.salt
= hash_left
->salt
;
4946 pot_left_key
.hash
.digest
= hash_left
->digest
;
4948 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4952 uint weak_hash_found
= 0;
4954 pot_t pot_right_key
;
4956 pot_right_key
.hash
.salt
= hash_right
->salt
;
4957 pot_right_key
.hash
.digest
= hash_right
->digest
;
4959 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4961 if (pot_right_ptr
== NULL
)
4963 // special case, if "weak hash"
4965 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
4967 weak_hash_found
= 1;
4969 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4971 // in theory this is not needed, but we are paranoia:
4973 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4974 pot_right_ptr
->plain_len
= 0;
4978 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
4980 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
4985 // at least one half was found:
4989 input_buf
[input_len
] = 0;
4993 unsigned char *username
= NULL
;
4998 user_t
*user
= hash_left
->hash_info
->user
;
5002 username
= (unsigned char *) (user
->user_name
);
5004 user_len
= user
->user_len
;
5008 // mask the part which was not found
5010 uint left_part_masked
= 0;
5011 uint right_part_masked
= 0;
5013 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5015 if (pot_left_ptr
== NULL
)
5017 left_part_masked
= 1;
5019 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5021 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5023 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5024 pot_left_ptr
->plain_len
= mask_plain_len
;
5027 if (pot_right_ptr
== NULL
)
5029 right_part_masked
= 1;
5031 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5033 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5035 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5036 pot_right_ptr
->plain_len
= mask_plain_len
;
5039 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5043 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5045 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5047 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5049 // do output the line
5051 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5053 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5055 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5056 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5059 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
)
5063 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5065 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5067 if (pot_ptr
== NULL
)
5071 input_buf
[input_len
] = 0;
5073 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5077 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
)
5083 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5085 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5089 pot_t pot_right_key
;
5091 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5093 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5095 uint weak_hash_found
= 0;
5097 if (pot_right_ptr
== NULL
)
5099 // special case, if "weak hash"
5101 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5103 weak_hash_found
= 1;
5105 // we just need that pot_right_ptr is not a NULL pointer
5107 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5111 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5113 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5118 // ... at least one part was not cracked
5122 input_buf
[input_len
] = 0;
5124 // only show the hash part which is still not cracked
5126 uint user_len
= input_len
- 32;
5128 char *hash_output
= (char *) mymalloc (33);
5130 memcpy (hash_output
, input_buf
, input_len
);
5132 if (pot_left_ptr
!= NULL
)
5134 // only show right part (because left part was already found)
5136 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5138 hash_output
[user_len
+ 16] = 0;
5141 if (pot_right_ptr
!= NULL
)
5143 // only show left part (because right part was already found)
5145 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5147 hash_output
[user_len
+ 16] = 0;
5150 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5152 myfree (hash_output
);
5154 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5157 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5159 uint opencl_platforms_filter
= 0;
5161 if (opencl_platforms
)
5163 char *platforms
= strdup (opencl_platforms
);
5165 char *next
= strtok (platforms
, ",");
5169 int platform
= atoi (next
);
5171 if (platform
< 1 || platform
> 32)
5173 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5178 opencl_platforms_filter
|= 1 << (platform
- 1);
5180 } while ((next
= strtok (NULL
, ",")) != NULL
);
5186 opencl_platforms_filter
= -1;
5189 return opencl_platforms_filter
;
5192 u32
setup_devices_filter (char *opencl_devices
)
5194 u32 devices_filter
= 0;
5198 char *devices
= strdup (opencl_devices
);
5200 char *next
= strtok (devices
, ",");
5204 int device_id
= atoi (next
);
5206 if (device_id
< 1 || device_id
> 32)
5208 log_error ("ERROR: invalid device_id %u specified", device_id
);
5213 devices_filter
|= 1 << (device_id
- 1);
5215 } while ((next
= strtok (NULL
, ",")) != NULL
);
5221 devices_filter
= -1;
5224 return devices_filter
;
5227 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5229 cl_device_type device_types_filter
= 0;
5231 if (opencl_device_types
)
5233 char *device_types
= strdup (opencl_device_types
);
5235 char *next
= strtok (device_types
, ",");
5239 int device_type
= atoi (next
);
5241 if (device_type
< 1 || device_type
> 3)
5243 log_error ("ERROR: invalid device_type %u specified", device_type
);
5248 device_types_filter
|= 1 << device_type
;
5250 } while ((next
= strtok (NULL
, ",")) != NULL
);
5252 free (device_types
);
5256 // Do not use CPU by default, this often reduces GPU performance because
5257 // the CPU is too busy to handle GPU synchronization
5259 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5262 return device_types_filter
;
5265 u32
get_random_num (const u32 min
, const u32 max
)
5267 if (min
== max
) return (min
);
5269 return ((rand () % (max
- min
)) + min
);
5272 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5274 u32 quotient
= dividend
/ divisor
;
5276 if (dividend
% divisor
) quotient
++;
5281 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5283 u64 quotient
= dividend
/ divisor
;
5285 if (dividend
% divisor
) quotient
++;
5290 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5292 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5293 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5295 if (tm
->tm_year
- 70)
5297 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5298 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5300 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5302 else if (tm
->tm_yday
)
5304 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5305 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5307 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5309 else if (tm
->tm_hour
)
5311 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5312 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5314 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5316 else if (tm
->tm_min
)
5318 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5319 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5321 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5325 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5327 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5331 void format_speed_display (float val
, char *buf
, size_t len
)
5342 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5353 /* generate output */
5357 snprintf (buf
, len
- 1, "%.0f ", val
);
5361 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5365 void lowercase (u8
*buf
, int len
)
5367 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5370 void uppercase (u8
*buf
, int len
)
5372 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5375 int fgetl (FILE *fp
, char *line_buf
)
5381 const int c
= fgetc (fp
);
5383 if (c
== EOF
) break;
5385 line_buf
[line_len
] = (char) c
;
5389 if (line_len
== BUFSIZ
) line_len
--;
5391 if (c
== '\n') break;
5394 if (line_len
== 0) return 0;
5396 if (line_buf
[line_len
- 1] == '\n')
5400 line_buf
[line_len
] = 0;
5403 if (line_len
== 0) return 0;
5405 if (line_buf
[line_len
- 1] == '\r')
5409 line_buf
[line_len
] = 0;
5415 int in_superchop (char *buf
)
5417 int len
= strlen (buf
);
5421 if (buf
[len
- 1] == '\n')
5428 if (buf
[len
- 1] == '\r')
5443 char **scan_directory (const char *path
)
5445 char *tmp_path
= mystrdup (path
);
5447 size_t tmp_path_len
= strlen (tmp_path
);
5449 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5451 tmp_path
[tmp_path_len
- 1] = 0;
5453 tmp_path_len
= strlen (tmp_path
);
5456 char **files
= NULL
;
5462 if ((d
= opendir (tmp_path
)) != NULL
)
5468 memset (&e
, 0, sizeof (e
));
5469 struct dirent
*de
= NULL
;
5471 if (readdir_r (d
, &e
, &de
) != 0)
5473 log_error ("ERROR: readdir_r() failed");
5478 if (de
== NULL
) break;
5482 while ((de
= readdir (d
)) != NULL
)
5485 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5487 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5489 char *path_file
= (char *) mymalloc (path_size
+ 1);
5491 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5493 path_file
[path_size
] = 0;
5497 if ((d_test
= opendir (path_file
)) != NULL
)
5505 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5509 files
[num_files
- 1] = path_file
;
5515 else if (errno
== ENOTDIR
)
5517 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5521 files
[num_files
- 1] = mystrdup (path
);
5524 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5528 files
[num_files
- 1] = NULL
;
5535 int count_dictionaries (char **dictionary_files
)
5537 if (dictionary_files
== NULL
) return 0;
5541 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5549 char *stroptitype (const uint opti_type
)
5553 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5554 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5555 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5556 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5557 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5558 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5559 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5560 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5561 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5562 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5563 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5564 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5565 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5566 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5567 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5568 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5569 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5570 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5576 char *strparser (const uint parser_status
)
5578 switch (parser_status
)
5580 case PARSER_OK
: return ((char *) PA_000
); break;
5581 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5582 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5583 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5584 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5585 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5586 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5587 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5588 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5589 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5590 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5591 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5592 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5593 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5594 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5595 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5596 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5599 return ((char *) PA_255
);
5602 char *strhashtype (const uint hash_mode
)
5606 case 0: return ((char *) HT_00000
); break;
5607 case 10: return ((char *) HT_00010
); break;
5608 case 11: return ((char *) HT_00011
); break;
5609 case 12: return ((char *) HT_00012
); break;
5610 case 20: return ((char *) HT_00020
); break;
5611 case 21: return ((char *) HT_00021
); break;
5612 case 22: return ((char *) HT_00022
); break;
5613 case 23: return ((char *) HT_00023
); break;
5614 case 30: return ((char *) HT_00030
); break;
5615 case 40: return ((char *) HT_00040
); break;
5616 case 50: return ((char *) HT_00050
); break;
5617 case 60: return ((char *) HT_00060
); break;
5618 case 100: return ((char *) HT_00100
); break;
5619 case 101: return ((char *) HT_00101
); break;
5620 case 110: return ((char *) HT_00110
); break;
5621 case 111: return ((char *) HT_00111
); break;
5622 case 112: return ((char *) HT_00112
); break;
5623 case 120: return ((char *) HT_00120
); break;
5624 case 121: return ((char *) HT_00121
); break;
5625 case 122: return ((char *) HT_00122
); break;
5626 case 124: return ((char *) HT_00124
); break;
5627 case 130: return ((char *) HT_00130
); break;
5628 case 131: return ((char *) HT_00131
); break;
5629 case 132: return ((char *) HT_00132
); break;
5630 case 133: return ((char *) HT_00133
); break;
5631 case 140: return ((char *) HT_00140
); break;
5632 case 141: return ((char *) HT_00141
); break;
5633 case 150: return ((char *) HT_00150
); break;
5634 case 160: return ((char *) HT_00160
); break;
5635 case 190: return ((char *) HT_00190
); break;
5636 case 200: return ((char *) HT_00200
); break;
5637 case 300: return ((char *) HT_00300
); break;
5638 case 400: return ((char *) HT_00400
); break;
5639 case 500: return ((char *) HT_00500
); break;
5640 case 501: return ((char *) HT_00501
); break;
5641 case 900: return ((char *) HT_00900
); break;
5642 case 910: return ((char *) HT_00910
); break;
5643 case 1000: return ((char *) HT_01000
); break;
5644 case 1100: return ((char *) HT_01100
); break;
5645 case 1400: return ((char *) HT_01400
); break;
5646 case 1410: return ((char *) HT_01410
); break;
5647 case 1420: return ((char *) HT_01420
); break;
5648 case 1421: return ((char *) HT_01421
); break;
5649 case 1430: return ((char *) HT_01430
); break;
5650 case 1440: return ((char *) HT_01440
); break;
5651 case 1441: return ((char *) HT_01441
); break;
5652 case 1450: return ((char *) HT_01450
); break;
5653 case 1460: return ((char *) HT_01460
); break;
5654 case 1500: return ((char *) HT_01500
); break;
5655 case 1600: return ((char *) HT_01600
); break;
5656 case 1700: return ((char *) HT_01700
); break;
5657 case 1710: return ((char *) HT_01710
); break;
5658 case 1711: return ((char *) HT_01711
); break;
5659 case 1720: return ((char *) HT_01720
); break;
5660 case 1722: return ((char *) HT_01722
); break;
5661 case 1730: return ((char *) HT_01730
); break;
5662 case 1731: return ((char *) HT_01731
); break;
5663 case 1740: return ((char *) HT_01740
); break;
5664 case 1750: return ((char *) HT_01750
); break;
5665 case 1760: return ((char *) HT_01760
); break;
5666 case 1800: return ((char *) HT_01800
); break;
5667 case 2100: return ((char *) HT_02100
); break;
5668 case 2400: return ((char *) HT_02400
); break;
5669 case 2410: return ((char *) HT_02410
); break;
5670 case 2500: return ((char *) HT_02500
); break;
5671 case 2600: return ((char *) HT_02600
); break;
5672 case 2611: return ((char *) HT_02611
); break;
5673 case 2612: return ((char *) HT_02612
); break;
5674 case 2711: return ((char *) HT_02711
); break;
5675 case 2811: return ((char *) HT_02811
); break;
5676 case 3000: return ((char *) HT_03000
); break;
5677 case 3100: return ((char *) HT_03100
); break;
5678 case 3200: return ((char *) HT_03200
); break;
5679 case 3710: return ((char *) HT_03710
); break;
5680 case 3711: return ((char *) HT_03711
); break;
5681 case 3800: return ((char *) HT_03800
); break;
5682 case 4300: return ((char *) HT_04300
); break;
5683 case 4400: return ((char *) HT_04400
); break;
5684 case 4500: return ((char *) HT_04500
); break;
5685 case 4700: return ((char *) HT_04700
); break;
5686 case 4800: return ((char *) HT_04800
); break;
5687 case 4900: return ((char *) HT_04900
); break;
5688 case 5000: return ((char *) HT_05000
); break;
5689 case 5100: return ((char *) HT_05100
); break;
5690 case 5200: return ((char *) HT_05200
); break;
5691 case 5300: return ((char *) HT_05300
); break;
5692 case 5400: return ((char *) HT_05400
); break;
5693 case 5500: return ((char *) HT_05500
); break;
5694 case 5600: return ((char *) HT_05600
); break;
5695 case 5700: return ((char *) HT_05700
); break;
5696 case 5800: return ((char *) HT_05800
); break;
5697 case 6000: return ((char *) HT_06000
); break;
5698 case 6100: return ((char *) HT_06100
); break;
5699 case 6211: return ((char *) HT_06211
); break;
5700 case 6212: return ((char *) HT_06212
); break;
5701 case 6213: return ((char *) HT_06213
); break;
5702 case 6221: return ((char *) HT_06221
); break;
5703 case 6222: return ((char *) HT_06222
); break;
5704 case 6223: return ((char *) HT_06223
); break;
5705 case 6231: return ((char *) HT_06231
); break;
5706 case 6232: return ((char *) HT_06232
); break;
5707 case 6233: return ((char *) HT_06233
); break;
5708 case 6241: return ((char *) HT_06241
); break;
5709 case 6242: return ((char *) HT_06242
); break;
5710 case 6243: return ((char *) HT_06243
); break;
5711 case 6300: return ((char *) HT_06300
); break;
5712 case 6400: return ((char *) HT_06400
); break;
5713 case 6500: return ((char *) HT_06500
); break;
5714 case 6600: return ((char *) HT_06600
); break;
5715 case 6700: return ((char *) HT_06700
); break;
5716 case 6800: return ((char *) HT_06800
); break;
5717 case 6900: return ((char *) HT_06900
); break;
5718 case 7100: return ((char *) HT_07100
); break;
5719 case 7200: return ((char *) HT_07200
); break;
5720 case 7300: return ((char *) HT_07300
); break;
5721 case 7400: return ((char *) HT_07400
); break;
5722 case 7500: return ((char *) HT_07500
); break;
5723 case 7600: return ((char *) HT_07600
); break;
5724 case 7700: return ((char *) HT_07700
); break;
5725 case 7800: return ((char *) HT_07800
); break;
5726 case 7900: return ((char *) HT_07900
); break;
5727 case 8000: return ((char *) HT_08000
); break;
5728 case 8100: return ((char *) HT_08100
); break;
5729 case 8200: return ((char *) HT_08200
); break;
5730 case 8300: return ((char *) HT_08300
); break;
5731 case 8400: return ((char *) HT_08400
); break;
5732 case 8500: return ((char *) HT_08500
); break;
5733 case 8600: return ((char *) HT_08600
); break;
5734 case 8700: return ((char *) HT_08700
); break;
5735 case 8800: return ((char *) HT_08800
); break;
5736 case 8900: return ((char *) HT_08900
); break;
5737 case 9000: return ((char *) HT_09000
); break;
5738 case 9100: return ((char *) HT_09100
); break;
5739 case 9200: return ((char *) HT_09200
); break;
5740 case 9300: return ((char *) HT_09300
); break;
5741 case 9400: return ((char *) HT_09400
); break;
5742 case 9500: return ((char *) HT_09500
); break;
5743 case 9600: return ((char *) HT_09600
); break;
5744 case 9700: return ((char *) HT_09700
); break;
5745 case 9710: return ((char *) HT_09710
); break;
5746 case 9720: return ((char *) HT_09720
); break;
5747 case 9800: return ((char *) HT_09800
); break;
5748 case 9810: return ((char *) HT_09810
); break;
5749 case 9820: return ((char *) HT_09820
); break;
5750 case 9900: return ((char *) HT_09900
); break;
5751 case 10000: return ((char *) HT_10000
); break;
5752 case 10100: return ((char *) HT_10100
); break;
5753 case 10200: return ((char *) HT_10200
); break;
5754 case 10300: return ((char *) HT_10300
); break;
5755 case 10400: return ((char *) HT_10400
); break;
5756 case 10410: return ((char *) HT_10410
); break;
5757 case 10420: return ((char *) HT_10420
); break;
5758 case 10500: return ((char *) HT_10500
); break;
5759 case 10600: return ((char *) HT_10600
); break;
5760 case 10700: return ((char *) HT_10700
); break;
5761 case 10800: return ((char *) HT_10800
); break;
5762 case 10900: return ((char *) HT_10900
); break;
5763 case 11000: return ((char *) HT_11000
); break;
5764 case 11100: return ((char *) HT_11100
); break;
5765 case 11200: return ((char *) HT_11200
); break;
5766 case 11300: return ((char *) HT_11300
); break;
5767 case 11400: return ((char *) HT_11400
); break;
5768 case 11500: return ((char *) HT_11500
); break;
5769 case 11600: return ((char *) HT_11600
); break;
5770 case 11700: return ((char *) HT_11700
); break;
5771 case 11800: return ((char *) HT_11800
); break;
5772 case 11900: return ((char *) HT_11900
); break;
5773 case 12000: return ((char *) HT_12000
); break;
5774 case 12100: return ((char *) HT_12100
); break;
5775 case 12200: return ((char *) HT_12200
); break;
5776 case 12300: return ((char *) HT_12300
); break;
5777 case 12400: return ((char *) HT_12400
); break;
5778 case 12500: return ((char *) HT_12500
); break;
5779 case 12600: return ((char *) HT_12600
); break;
5780 case 12700: return ((char *) HT_12700
); break;
5781 case 12800: return ((char *) HT_12800
); break;
5782 case 12900: return ((char *) HT_12900
); break;
5783 case 13000: return ((char *) HT_13000
); break;
5786 return ((char *) "Unknown");
5789 char *strstatus (const uint devices_status
)
5791 switch (devices_status
)
5793 case STATUS_INIT
: return ((char *) ST_0000
); break;
5794 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5795 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5796 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5797 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5798 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5799 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5800 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5801 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5802 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5805 return ((char *) "Unknown");
5808 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5810 uint hash_type
= data
.hash_type
;
5811 uint hash_mode
= data
.hash_mode
;
5812 uint salt_type
= data
.salt_type
;
5813 uint opts_type
= data
.opts_type
;
5814 uint opti_type
= data
.opti_type
;
5815 uint dgst_size
= data
.dgst_size
;
5817 char *hashfile
= data
.hashfile
;
5821 uint digest_buf
[64] = { 0 };
5823 u64
*digest_buf64
= (u64
*) digest_buf
;
5825 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5827 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5829 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5835 case HASH_TYPE_DESCRYPT
:
5836 FP (digest_buf
[1], digest_buf
[0], tt
);
5839 case HASH_TYPE_DESRACF
:
5840 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5841 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5843 FP (digest_buf
[1], digest_buf
[0], tt
);
5847 FP (digest_buf
[1], digest_buf
[0], tt
);
5850 case HASH_TYPE_NETNTLM
:
5851 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5852 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5853 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5854 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5856 FP (digest_buf
[1], digest_buf
[0], tt
);
5857 FP (digest_buf
[3], digest_buf
[2], tt
);
5860 case HASH_TYPE_BSDICRYPT
:
5861 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5862 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5864 FP (digest_buf
[1], digest_buf
[0], tt
);
5869 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5874 digest_buf
[0] += MD4M_A
;
5875 digest_buf
[1] += MD4M_B
;
5876 digest_buf
[2] += MD4M_C
;
5877 digest_buf
[3] += MD4M_D
;
5881 digest_buf
[0] += MD5M_A
;
5882 digest_buf
[1] += MD5M_B
;
5883 digest_buf
[2] += MD5M_C
;
5884 digest_buf
[3] += MD5M_D
;
5887 case HASH_TYPE_SHA1
:
5888 digest_buf
[0] += SHA1M_A
;
5889 digest_buf
[1] += SHA1M_B
;
5890 digest_buf
[2] += SHA1M_C
;
5891 digest_buf
[3] += SHA1M_D
;
5892 digest_buf
[4] += SHA1M_E
;
5895 case HASH_TYPE_SHA256
:
5896 digest_buf
[0] += SHA256M_A
;
5897 digest_buf
[1] += SHA256M_B
;
5898 digest_buf
[2] += SHA256M_C
;
5899 digest_buf
[3] += SHA256M_D
;
5900 digest_buf
[4] += SHA256M_E
;
5901 digest_buf
[5] += SHA256M_F
;
5902 digest_buf
[6] += SHA256M_G
;
5903 digest_buf
[7] += SHA256M_H
;
5906 case HASH_TYPE_SHA384
:
5907 digest_buf64
[0] += SHA384M_A
;
5908 digest_buf64
[1] += SHA384M_B
;
5909 digest_buf64
[2] += SHA384M_C
;
5910 digest_buf64
[3] += SHA384M_D
;
5911 digest_buf64
[4] += SHA384M_E
;
5912 digest_buf64
[5] += SHA384M_F
;
5913 digest_buf64
[6] += 0;
5914 digest_buf64
[7] += 0;
5917 case HASH_TYPE_SHA512
:
5918 digest_buf64
[0] += SHA512M_A
;
5919 digest_buf64
[1] += SHA512M_B
;
5920 digest_buf64
[2] += SHA512M_C
;
5921 digest_buf64
[3] += SHA512M_D
;
5922 digest_buf64
[4] += SHA512M_E
;
5923 digest_buf64
[5] += SHA512M_F
;
5924 digest_buf64
[6] += SHA512M_G
;
5925 digest_buf64
[7] += SHA512M_H
;
5930 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
5932 if (dgst_size
== DGST_SIZE_4_2
)
5934 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5936 else if (dgst_size
== DGST_SIZE_4_4
)
5938 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5940 else if (dgst_size
== DGST_SIZE_4_5
)
5942 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5944 else if (dgst_size
== DGST_SIZE_4_6
)
5946 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5948 else if (dgst_size
== DGST_SIZE_4_8
)
5950 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5952 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
5954 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
5956 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5958 else if (hash_type
== HASH_TYPE_SHA384
)
5960 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5962 else if (hash_type
== HASH_TYPE_SHA512
)
5964 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5966 else if (hash_type
== HASH_TYPE_GOST
)
5968 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5971 else if (dgst_size
== DGST_SIZE_4_64
)
5973 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5975 else if (dgst_size
== DGST_SIZE_8_25
)
5977 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5981 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
5982 | (data
.salt_type
== SALT_TYPE_EXTERN
)
5983 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
5989 memset (&salt
, 0, sizeof (salt_t
));
5991 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
5993 char *ptr
= (char *) salt
.salt_buf
;
5995 uint len
= salt
.salt_len
;
5997 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6003 case HASH_TYPE_NETNTLM
:
6005 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6006 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6008 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6014 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6016 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6024 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6026 uint max
= salt
.salt_len
/ 4;
6030 for (uint i
= 0; i
< max
; i
++)
6032 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6036 if (opts_type
& OPTS_TYPE_ST_HEX
)
6038 char tmp
[64] = { 0 };
6040 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6042 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6047 memcpy (ptr
, tmp
, len
);
6050 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6052 memset (ptr
+ len
, 0, memset_size
);
6054 salt
.salt_len
= len
;
6058 // some modes require special encoding
6061 uint out_buf_plain
[256] = { 0 };
6062 uint out_buf_salt
[256] = { 0 };
6064 char tmp_buf
[1024] = { 0 };
6066 char *ptr_plain
= (char *) out_buf_plain
;
6067 char *ptr_salt
= (char *) out_buf_salt
;
6069 if (hash_mode
== 22)
6071 char username
[30] = { 0 };
6073 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6075 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6077 u16
*ptr
= (u16
*) digest_buf
;
6079 tmp_buf
[ 0] = sig
[0];
6080 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6081 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6082 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6083 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6084 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6085 tmp_buf
[ 6] = sig
[1];
6086 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6087 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6088 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6089 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6090 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6091 tmp_buf
[12] = sig
[2];
6092 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6093 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6094 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6095 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6096 tmp_buf
[17] = sig
[3];
6097 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6098 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6099 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6100 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6101 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6102 tmp_buf
[23] = sig
[4];
6103 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6104 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6105 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6106 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6107 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6108 tmp_buf
[29] = sig
[5];
6110 snprintf (out_buf
, len
-1, "%s:%s",
6114 else if (hash_mode
== 23)
6116 // do not show the \nskyper\n part in output
6118 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6120 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6122 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6129 else if (hash_mode
== 101)
6131 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6133 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6134 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6135 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6136 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6137 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6139 memcpy (tmp_buf
, digest_buf
, 20);
6141 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6143 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6145 else if (hash_mode
== 111)
6147 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6149 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6150 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6151 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6152 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6153 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6155 memcpy (tmp_buf
, digest_buf
, 20);
6156 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6158 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6160 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6162 else if (hash_mode
== 122)
6164 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6165 (char *) salt
.salt_buf
,
6172 else if (hash_mode
== 124)
6174 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6175 (char *) salt
.salt_buf
,
6182 else if (hash_mode
== 131)
6184 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6185 (char *) salt
.salt_buf
,
6193 else if (hash_mode
== 132)
6195 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6196 (char *) salt
.salt_buf
,
6203 else if (hash_mode
== 133)
6205 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6207 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6208 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6209 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6210 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6211 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6213 memcpy (tmp_buf
, digest_buf
, 20);
6215 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6217 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6219 else if (hash_mode
== 141)
6221 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6223 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6225 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6227 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6229 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6230 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6231 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6232 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6233 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6235 memcpy (tmp_buf
, digest_buf
, 20);
6237 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6241 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6243 else if (hash_mode
== 400)
6245 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6247 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6248 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6249 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6250 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6252 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6254 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6256 else if (hash_mode
== 500)
6258 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6260 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6261 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6262 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6263 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6265 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6267 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6269 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6273 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6276 else if (hash_mode
== 501)
6278 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6280 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6281 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6283 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6285 else if (hash_mode
== 1421)
6287 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6289 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6305 else if (hash_mode
== 1441)
6307 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6309 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6311 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6313 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6315 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6316 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6317 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6318 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6319 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6320 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6321 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6322 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6324 memcpy (tmp_buf
, digest_buf
, 32);
6326 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6330 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6332 else if (hash_mode
== 1500)
6334 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6335 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6336 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6337 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6338 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6340 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6342 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6344 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6345 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6347 memcpy (tmp_buf
, digest_buf
, 8);
6349 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6351 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6355 else if (hash_mode
== 1600)
6357 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6359 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6360 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6361 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6362 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6364 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6366 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6368 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6372 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6375 else if (hash_mode
== 1711)
6377 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6379 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6380 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6381 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6382 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6383 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6384 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6385 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6386 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6388 memcpy (tmp_buf
, digest_buf
, 64);
6389 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6391 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6393 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6395 else if (hash_mode
== 1722)
6397 uint
*ptr
= digest_buf
;
6399 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6400 (unsigned char *) salt
.salt_buf
,
6410 else if (hash_mode
== 1731)
6412 uint
*ptr
= digest_buf
;
6414 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6415 (unsigned char *) salt
.salt_buf
,
6425 else if (hash_mode
== 1800)
6429 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6430 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6431 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6432 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6433 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6434 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6435 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6436 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6438 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6440 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6442 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6446 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6449 else if (hash_mode
== 2100)
6453 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6455 salt
.salt_iter
+ 1);
6457 uint signature_len
= strlen (out_buf
);
6459 pos
+= signature_len
;
6460 len
-= signature_len
;
6462 char *salt_ptr
= (char *) salt
.salt_buf
;
6464 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6466 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6467 byte_swap_32 (digest_buf
[0]),
6468 byte_swap_32 (digest_buf
[1]),
6469 byte_swap_32 (digest_buf
[2]),
6470 byte_swap_32 (digest_buf
[3]));
6472 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6474 memcpy (tmp_buf
, digest_buf
, 16);
6476 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6478 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6479 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6480 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6481 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6483 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6484 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6485 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6486 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6488 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6489 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6490 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6491 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6493 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6494 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6495 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6496 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6498 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6499 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6500 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6501 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6505 else if (hash_mode
== 2500)
6507 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6509 wpa_t
*wpa
= &wpas
[salt_pos
];
6511 uint pke
[25] = { 0 };
6513 char *pke_ptr
= (char *) pke
;
6515 for (uint i
= 0; i
< 25; i
++)
6517 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6520 unsigned char mac1
[6] = { 0 };
6521 unsigned char mac2
[6] = { 0 };
6523 memcpy (mac1
, pke_ptr
+ 23, 6);
6524 memcpy (mac2
, pke_ptr
+ 29, 6);
6526 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6527 (char *) salt
.salt_buf
,
6541 else if (hash_mode
== 4400)
6543 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6544 byte_swap_32 (digest_buf
[0]),
6545 byte_swap_32 (digest_buf
[1]),
6546 byte_swap_32 (digest_buf
[2]),
6547 byte_swap_32 (digest_buf
[3]));
6549 else if (hash_mode
== 4700)
6551 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6552 byte_swap_32 (digest_buf
[0]),
6553 byte_swap_32 (digest_buf
[1]),
6554 byte_swap_32 (digest_buf
[2]),
6555 byte_swap_32 (digest_buf
[3]),
6556 byte_swap_32 (digest_buf
[4]));
6558 else if (hash_mode
== 4800)
6560 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6562 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6567 byte_swap_32 (salt
.salt_buf
[0]),
6568 byte_swap_32 (salt
.salt_buf
[1]),
6569 byte_swap_32 (salt
.salt_buf
[2]),
6570 byte_swap_32 (salt
.salt_buf
[3]),
6573 else if (hash_mode
== 4900)
6575 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6576 byte_swap_32 (digest_buf
[0]),
6577 byte_swap_32 (digest_buf
[1]),
6578 byte_swap_32 (digest_buf
[2]),
6579 byte_swap_32 (digest_buf
[3]),
6580 byte_swap_32 (digest_buf
[4]));
6582 else if (hash_mode
== 5100)
6584 snprintf (out_buf
, len
-1, "%08x%08x",
6588 else if (hash_mode
== 5200)
6590 snprintf (out_buf
, len
-1, "%s", hashfile
);
6592 else if (hash_mode
== 5300)
6594 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6596 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6598 int buf_len
= len
-1;
6602 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6604 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6606 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6608 snprintf (out_buf
, buf_len
, ":");
6614 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6622 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6624 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6626 if ((i
== 0) || (i
== 5))
6628 snprintf (out_buf
, buf_len
, ":");
6634 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6642 for (uint i
= 0; i
< 4; i
++)
6646 snprintf (out_buf
, buf_len
, ":");
6652 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6658 else if (hash_mode
== 5400)
6660 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6662 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6664 int buf_len
= len
-1;
6668 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6670 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6672 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6674 snprintf (out_buf
, buf_len
, ":");
6680 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6688 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6690 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6692 if ((i
== 0) || (i
== 5))
6694 snprintf (out_buf
, buf_len
, ":");
6700 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6708 for (uint i
= 0; i
< 5; i
++)
6712 snprintf (out_buf
, buf_len
, ":");
6718 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6724 else if (hash_mode
== 5500)
6726 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6728 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6730 char user_buf
[64] = { 0 };
6731 char domain_buf
[64] = { 0 };
6732 char srvchall_buf
[1024] = { 0 };
6733 char clichall_buf
[1024] = { 0 };
6735 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6737 char *ptr
= (char *) netntlm
->userdomain_buf
;
6739 user_buf
[i
] = ptr
[j
];
6742 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6744 char *ptr
= (char *) netntlm
->userdomain_buf
;
6746 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6749 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6751 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6753 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6756 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6758 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6760 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6763 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6771 byte_swap_32 (salt
.salt_buf_pc
[0]),
6772 byte_swap_32 (salt
.salt_buf_pc
[1]),
6775 else if (hash_mode
== 5600)
6777 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6779 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6781 char user_buf
[64] = { 0 };
6782 char domain_buf
[64] = { 0 };
6783 char srvchall_buf
[1024] = { 0 };
6784 char clichall_buf
[1024] = { 0 };
6786 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6788 char *ptr
= (char *) netntlm
->userdomain_buf
;
6790 user_buf
[i
] = ptr
[j
];
6793 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6795 char *ptr
= (char *) netntlm
->userdomain_buf
;
6797 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6800 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6802 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6804 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6807 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6809 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6811 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6814 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6824 else if (hash_mode
== 5700)
6826 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6828 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6829 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6830 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6831 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6832 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6833 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6834 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6835 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6837 memcpy (tmp_buf
, digest_buf
, 32);
6839 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6843 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6845 else if (hash_mode
== 5800)
6847 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6848 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6849 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6850 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6851 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6853 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6860 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6862 snprintf (out_buf
, len
-1, "%s", hashfile
);
6864 else if (hash_mode
== 6300)
6866 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6868 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6869 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6870 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6871 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6873 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6875 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6877 else if (hash_mode
== 6400)
6879 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6881 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6883 else if (hash_mode
== 6500)
6885 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6887 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6889 else if (hash_mode
== 6600)
6891 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6893 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6895 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6896 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6898 uint buf_len
= len
- 1;
6900 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6903 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6905 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6910 else if (hash_mode
== 6700)
6912 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6914 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6916 else if (hash_mode
== 6800)
6918 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6920 else if (hash_mode
== 7100)
6922 uint
*ptr
= digest_buf
;
6924 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6926 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6928 uint esalt
[8] = { 0 };
6930 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6931 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6932 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6933 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6934 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6935 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6936 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6937 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6939 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",
6940 SIGNATURE_SHA512OSX
,
6942 esalt
[ 0], esalt
[ 1],
6943 esalt
[ 2], esalt
[ 3],
6944 esalt
[ 4], esalt
[ 5],
6945 esalt
[ 6], esalt
[ 7],
6953 ptr
[15], ptr
[14]);
6955 else if (hash_mode
== 7200)
6957 uint
*ptr
= digest_buf
;
6959 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6961 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6965 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
6967 len_used
= strlen (out_buf
);
6969 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
6971 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
6973 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
6976 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",
6984 ptr
[15], ptr
[14]);
6986 else if (hash_mode
== 7300)
6988 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
6990 rakp_t
*rakp
= &rakps
[salt_pos
];
6992 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
6994 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
6997 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7004 else if (hash_mode
== 7400)
7006 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7008 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7009 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7010 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7011 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7012 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7013 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7014 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7015 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7017 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7019 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7021 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7025 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7028 else if (hash_mode
== 7500)
7030 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7032 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7034 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7035 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7037 char data
[128] = { 0 };
7039 char *ptr_data
= data
;
7041 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7043 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7046 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7048 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7053 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7055 (char *) krb5pa
->user
,
7056 (char *) krb5pa
->realm
,
7057 (char *) krb5pa
->salt
,
7060 else if (hash_mode
== 7700)
7062 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7063 (char *) salt
.salt_buf
,
7067 else if (hash_mode
== 7800)
7069 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7070 (char *) salt
.salt_buf
,
7077 else if (hash_mode
== 7900)
7079 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7083 char *tmp
= (char *) salt
.salt_buf_pc
;
7085 ptr_plain
[42] = tmp
[0];
7091 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7093 else if (hash_mode
== 8000)
7095 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7096 (unsigned char *) salt
.salt_buf
,
7106 else if (hash_mode
== 8100)
7108 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7109 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7111 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7112 (unsigned char *) salt
.salt_buf
,
7119 else if (hash_mode
== 8200)
7121 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7123 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7125 char data_buf
[4096] = { 0 };
7127 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7129 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7132 data_buf
[cloudkey
->data_len
* 2] = 0;
7134 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7135 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7136 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7137 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7138 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7139 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7140 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7141 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7143 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7144 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7145 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7146 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7148 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7164 else if (hash_mode
== 8300)
7166 char digest_buf_c
[34] = { 0 };
7168 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7170 digest_buf_c
[32] = 0;
7174 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7176 char domain_buf_c
[33] = { 0 };
7178 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7180 for (uint i
= 0; i
< salt_pc_len
; i
++)
7182 const char next
= domain_buf_c
[i
];
7184 domain_buf_c
[i
] = '.';
7189 domain_buf_c
[salt_pc_len
] = 0;
7193 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7195 else if (hash_mode
== 8500)
7197 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7199 else if (hash_mode
== 2612)
7201 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7203 (char *) salt
.salt_buf
,
7209 else if (hash_mode
== 3711)
7211 char *salt_ptr
= (char *) salt
.salt_buf
;
7213 salt_ptr
[salt
.salt_len
- 1] = 0;
7215 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7216 SIGNATURE_MEDIAWIKI_B
,
7223 else if (hash_mode
== 8800)
7225 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7227 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7229 char tmp
[3073] = { 0 };
7231 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7233 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7238 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7239 SIGNATURE_ANDROIDFDE
,
7240 byte_swap_32 (salt
.salt_buf
[0]),
7241 byte_swap_32 (salt
.salt_buf
[1]),
7242 byte_swap_32 (salt
.salt_buf
[2]),
7243 byte_swap_32 (salt
.salt_buf
[3]),
7244 byte_swap_32 (digest_buf
[0]),
7245 byte_swap_32 (digest_buf
[1]),
7246 byte_swap_32 (digest_buf
[2]),
7247 byte_swap_32 (digest_buf
[3]),
7250 else if (hash_mode
== 8900)
7252 uint N
= salt
.scrypt_N
;
7253 uint r
= salt
.scrypt_r
;
7254 uint p
= salt
.scrypt_p
;
7256 char base64_salt
[32] = { 0 };
7258 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7260 memset (tmp_buf
, 0, 46);
7262 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7263 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7264 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7265 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7266 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7267 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7268 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7269 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7270 digest_buf
[8] = 0; // needed for base64_encode ()
7272 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7274 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7282 else if (hash_mode
== 9000)
7284 snprintf (out_buf
, len
-1, "%s", hashfile
);
7286 else if (hash_mode
== 9200)
7290 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7292 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7294 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7298 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7299 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7300 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7301 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7302 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7303 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7304 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7305 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7306 digest_buf
[8] = 0; // needed for base64_encode ()
7308 char tmp_buf
[64] = { 0 };
7310 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7311 tmp_buf
[43] = 0; // cut it here
7315 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7317 else if (hash_mode
== 9300)
7319 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7320 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7321 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7322 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7323 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7324 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7325 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7326 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7327 digest_buf
[8] = 0; // needed for base64_encode ()
7329 char tmp_buf
[64] = { 0 };
7331 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7332 tmp_buf
[43] = 0; // cut it here
7334 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7336 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7338 else if (hash_mode
== 9400)
7340 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7342 office2007_t
*office2007
= &office2007s
[salt_pos
];
7344 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7345 SIGNATURE_OFFICE2007
,
7348 office2007
->keySize
,
7354 office2007
->encryptedVerifier
[0],
7355 office2007
->encryptedVerifier
[1],
7356 office2007
->encryptedVerifier
[2],
7357 office2007
->encryptedVerifier
[3],
7358 office2007
->encryptedVerifierHash
[0],
7359 office2007
->encryptedVerifierHash
[1],
7360 office2007
->encryptedVerifierHash
[2],
7361 office2007
->encryptedVerifierHash
[3],
7362 office2007
->encryptedVerifierHash
[4]);
7364 else if (hash_mode
== 9500)
7366 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7368 office2010_t
*office2010
= &office2010s
[salt_pos
];
7370 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,
7376 office2010
->encryptedVerifier
[0],
7377 office2010
->encryptedVerifier
[1],
7378 office2010
->encryptedVerifier
[2],
7379 office2010
->encryptedVerifier
[3],
7380 office2010
->encryptedVerifierHash
[0],
7381 office2010
->encryptedVerifierHash
[1],
7382 office2010
->encryptedVerifierHash
[2],
7383 office2010
->encryptedVerifierHash
[3],
7384 office2010
->encryptedVerifierHash
[4],
7385 office2010
->encryptedVerifierHash
[5],
7386 office2010
->encryptedVerifierHash
[6],
7387 office2010
->encryptedVerifierHash
[7]);
7389 else if (hash_mode
== 9600)
7391 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7393 office2013_t
*office2013
= &office2013s
[salt_pos
];
7395 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,
7401 office2013
->encryptedVerifier
[0],
7402 office2013
->encryptedVerifier
[1],
7403 office2013
->encryptedVerifier
[2],
7404 office2013
->encryptedVerifier
[3],
7405 office2013
->encryptedVerifierHash
[0],
7406 office2013
->encryptedVerifierHash
[1],
7407 office2013
->encryptedVerifierHash
[2],
7408 office2013
->encryptedVerifierHash
[3],
7409 office2013
->encryptedVerifierHash
[4],
7410 office2013
->encryptedVerifierHash
[5],
7411 office2013
->encryptedVerifierHash
[6],
7412 office2013
->encryptedVerifierHash
[7]);
7414 else if (hash_mode
== 9700)
7416 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7418 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7420 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7421 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7422 byte_swap_32 (salt
.salt_buf
[0]),
7423 byte_swap_32 (salt
.salt_buf
[1]),
7424 byte_swap_32 (salt
.salt_buf
[2]),
7425 byte_swap_32 (salt
.salt_buf
[3]),
7426 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7427 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7428 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7429 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7430 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7431 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7432 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7433 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7435 else if (hash_mode
== 9710)
7437 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7439 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7441 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7442 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7443 byte_swap_32 (salt
.salt_buf
[0]),
7444 byte_swap_32 (salt
.salt_buf
[1]),
7445 byte_swap_32 (salt
.salt_buf
[2]),
7446 byte_swap_32 (salt
.salt_buf
[3]),
7447 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7448 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7449 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7450 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7451 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7452 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7453 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7454 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7456 else if (hash_mode
== 9720)
7458 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7460 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7462 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7464 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7465 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7466 byte_swap_32 (salt
.salt_buf
[0]),
7467 byte_swap_32 (salt
.salt_buf
[1]),
7468 byte_swap_32 (salt
.salt_buf
[2]),
7469 byte_swap_32 (salt
.salt_buf
[3]),
7470 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7471 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7472 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7473 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7474 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7475 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7476 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7477 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7484 else if (hash_mode
== 9800)
7486 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7488 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7490 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7491 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7496 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7497 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7498 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7499 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7500 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7501 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7502 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7503 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7504 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7506 else if (hash_mode
== 9810)
7508 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7510 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7512 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7513 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7518 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7519 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7520 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7521 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7522 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7523 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7524 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7525 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7526 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7528 else if (hash_mode
== 9820)
7530 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7532 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7534 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7536 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7537 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7542 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7543 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7544 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7545 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7546 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7547 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7548 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7549 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7550 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7557 else if (hash_mode
== 10000)
7561 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7563 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7565 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7569 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7570 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7571 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7572 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7573 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7574 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7575 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7576 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7577 digest_buf
[8] = 0; // needed for base64_encode ()
7579 char tmp_buf
[64] = { 0 };
7581 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7585 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7587 else if (hash_mode
== 10100)
7589 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7594 byte_swap_32 (salt
.salt_buf
[0]),
7595 byte_swap_32 (salt
.salt_buf
[1]),
7596 byte_swap_32 (salt
.salt_buf
[2]),
7597 byte_swap_32 (salt
.salt_buf
[3]));
7599 else if (hash_mode
== 10200)
7601 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7603 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7607 char challenge
[100] = { 0 };
7609 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7613 char tmp_buf
[100] = { 0 };
7615 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7616 (char *) cram_md5
->user
,
7622 char response
[100] = { 0 };
7624 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7626 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7628 else if (hash_mode
== 10300)
7630 char tmp_buf
[100] = { 0 };
7632 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7633 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7635 uint tmp_len
= 20 + salt
.salt_len
;
7639 char base64_encoded
[100] = { 0 };
7641 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7643 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7645 else if (hash_mode
== 10400)
7647 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7649 pdf_t
*pdf
= &pdfs
[salt_pos
];
7651 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",
7659 byte_swap_32 (pdf
->id_buf
[0]),
7660 byte_swap_32 (pdf
->id_buf
[1]),
7661 byte_swap_32 (pdf
->id_buf
[2]),
7662 byte_swap_32 (pdf
->id_buf
[3]),
7664 byte_swap_32 (pdf
->u_buf
[0]),
7665 byte_swap_32 (pdf
->u_buf
[1]),
7666 byte_swap_32 (pdf
->u_buf
[2]),
7667 byte_swap_32 (pdf
->u_buf
[3]),
7668 byte_swap_32 (pdf
->u_buf
[4]),
7669 byte_swap_32 (pdf
->u_buf
[5]),
7670 byte_swap_32 (pdf
->u_buf
[6]),
7671 byte_swap_32 (pdf
->u_buf
[7]),
7673 byte_swap_32 (pdf
->o_buf
[0]),
7674 byte_swap_32 (pdf
->o_buf
[1]),
7675 byte_swap_32 (pdf
->o_buf
[2]),
7676 byte_swap_32 (pdf
->o_buf
[3]),
7677 byte_swap_32 (pdf
->o_buf
[4]),
7678 byte_swap_32 (pdf
->o_buf
[5]),
7679 byte_swap_32 (pdf
->o_buf
[6]),
7680 byte_swap_32 (pdf
->o_buf
[7])
7683 else if (hash_mode
== 10410)
7685 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7687 pdf_t
*pdf
= &pdfs
[salt_pos
];
7689 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",
7697 byte_swap_32 (pdf
->id_buf
[0]),
7698 byte_swap_32 (pdf
->id_buf
[1]),
7699 byte_swap_32 (pdf
->id_buf
[2]),
7700 byte_swap_32 (pdf
->id_buf
[3]),
7702 byte_swap_32 (pdf
->u_buf
[0]),
7703 byte_swap_32 (pdf
->u_buf
[1]),
7704 byte_swap_32 (pdf
->u_buf
[2]),
7705 byte_swap_32 (pdf
->u_buf
[3]),
7706 byte_swap_32 (pdf
->u_buf
[4]),
7707 byte_swap_32 (pdf
->u_buf
[5]),
7708 byte_swap_32 (pdf
->u_buf
[6]),
7709 byte_swap_32 (pdf
->u_buf
[7]),
7711 byte_swap_32 (pdf
->o_buf
[0]),
7712 byte_swap_32 (pdf
->o_buf
[1]),
7713 byte_swap_32 (pdf
->o_buf
[2]),
7714 byte_swap_32 (pdf
->o_buf
[3]),
7715 byte_swap_32 (pdf
->o_buf
[4]),
7716 byte_swap_32 (pdf
->o_buf
[5]),
7717 byte_swap_32 (pdf
->o_buf
[6]),
7718 byte_swap_32 (pdf
->o_buf
[7])
7721 else if (hash_mode
== 10420)
7723 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7725 pdf_t
*pdf
= &pdfs
[salt_pos
];
7727 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7729 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",
7737 byte_swap_32 (pdf
->id_buf
[0]),
7738 byte_swap_32 (pdf
->id_buf
[1]),
7739 byte_swap_32 (pdf
->id_buf
[2]),
7740 byte_swap_32 (pdf
->id_buf
[3]),
7742 byte_swap_32 (pdf
->u_buf
[0]),
7743 byte_swap_32 (pdf
->u_buf
[1]),
7744 byte_swap_32 (pdf
->u_buf
[2]),
7745 byte_swap_32 (pdf
->u_buf
[3]),
7746 byte_swap_32 (pdf
->u_buf
[4]),
7747 byte_swap_32 (pdf
->u_buf
[5]),
7748 byte_swap_32 (pdf
->u_buf
[6]),
7749 byte_swap_32 (pdf
->u_buf
[7]),
7751 byte_swap_32 (pdf
->o_buf
[0]),
7752 byte_swap_32 (pdf
->o_buf
[1]),
7753 byte_swap_32 (pdf
->o_buf
[2]),
7754 byte_swap_32 (pdf
->o_buf
[3]),
7755 byte_swap_32 (pdf
->o_buf
[4]),
7756 byte_swap_32 (pdf
->o_buf
[5]),
7757 byte_swap_32 (pdf
->o_buf
[6]),
7758 byte_swap_32 (pdf
->o_buf
[7]),
7766 else if (hash_mode
== 10500)
7768 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7770 pdf_t
*pdf
= &pdfs
[salt_pos
];
7772 if (pdf
->id_len
== 32)
7774 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",
7782 byte_swap_32 (pdf
->id_buf
[0]),
7783 byte_swap_32 (pdf
->id_buf
[1]),
7784 byte_swap_32 (pdf
->id_buf
[2]),
7785 byte_swap_32 (pdf
->id_buf
[3]),
7786 byte_swap_32 (pdf
->id_buf
[4]),
7787 byte_swap_32 (pdf
->id_buf
[5]),
7788 byte_swap_32 (pdf
->id_buf
[6]),
7789 byte_swap_32 (pdf
->id_buf
[7]),
7791 byte_swap_32 (pdf
->u_buf
[0]),
7792 byte_swap_32 (pdf
->u_buf
[1]),
7793 byte_swap_32 (pdf
->u_buf
[2]),
7794 byte_swap_32 (pdf
->u_buf
[3]),
7795 byte_swap_32 (pdf
->u_buf
[4]),
7796 byte_swap_32 (pdf
->u_buf
[5]),
7797 byte_swap_32 (pdf
->u_buf
[6]),
7798 byte_swap_32 (pdf
->u_buf
[7]),
7800 byte_swap_32 (pdf
->o_buf
[0]),
7801 byte_swap_32 (pdf
->o_buf
[1]),
7802 byte_swap_32 (pdf
->o_buf
[2]),
7803 byte_swap_32 (pdf
->o_buf
[3]),
7804 byte_swap_32 (pdf
->o_buf
[4]),
7805 byte_swap_32 (pdf
->o_buf
[5]),
7806 byte_swap_32 (pdf
->o_buf
[6]),
7807 byte_swap_32 (pdf
->o_buf
[7])
7812 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",
7820 byte_swap_32 (pdf
->id_buf
[0]),
7821 byte_swap_32 (pdf
->id_buf
[1]),
7822 byte_swap_32 (pdf
->id_buf
[2]),
7823 byte_swap_32 (pdf
->id_buf
[3]),
7825 byte_swap_32 (pdf
->u_buf
[0]),
7826 byte_swap_32 (pdf
->u_buf
[1]),
7827 byte_swap_32 (pdf
->u_buf
[2]),
7828 byte_swap_32 (pdf
->u_buf
[3]),
7829 byte_swap_32 (pdf
->u_buf
[4]),
7830 byte_swap_32 (pdf
->u_buf
[5]),
7831 byte_swap_32 (pdf
->u_buf
[6]),
7832 byte_swap_32 (pdf
->u_buf
[7]),
7834 byte_swap_32 (pdf
->o_buf
[0]),
7835 byte_swap_32 (pdf
->o_buf
[1]),
7836 byte_swap_32 (pdf
->o_buf
[2]),
7837 byte_swap_32 (pdf
->o_buf
[3]),
7838 byte_swap_32 (pdf
->o_buf
[4]),
7839 byte_swap_32 (pdf
->o_buf
[5]),
7840 byte_swap_32 (pdf
->o_buf
[6]),
7841 byte_swap_32 (pdf
->o_buf
[7])
7845 else if (hash_mode
== 10600)
7847 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7849 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7850 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7852 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7854 else if (hash_mode
== 10700)
7856 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7858 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7859 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7861 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7863 else if (hash_mode
== 10900)
7865 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7867 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7868 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7870 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7872 else if (hash_mode
== 11100)
7874 u32 salt_challenge
= salt
.salt_buf
[0];
7876 salt_challenge
= byte_swap_32 (salt_challenge
);
7878 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7880 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7881 SIGNATURE_POSTGRESQL_AUTH
,
7889 else if (hash_mode
== 11200)
7891 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7892 SIGNATURE_MYSQL_AUTH
,
7893 (unsigned char *) salt
.salt_buf
,
7900 else if (hash_mode
== 11300)
7902 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7904 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7906 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7907 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7908 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7910 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7911 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7912 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7914 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7916 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7918 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7921 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7923 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7925 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7928 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7930 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
7932 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7935 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
7936 SIGNATURE_BITCOIN_WALLET
,
7940 (unsigned char *) salt
.salt_buf
,
7948 free (cry_master_buf
);
7950 free (public_key_buf
);
7952 else if (hash_mode
== 11400)
7954 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7956 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7957 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7959 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7961 else if (hash_mode
== 11600)
7963 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
7965 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
7967 const uint data_len
= seven_zip
->data_len
;
7969 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
7971 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
7973 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
7975 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
7978 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
7979 SIGNATURE_SEVEN_ZIP
,
7983 (char *) seven_zip
->salt_buf
,
7985 seven_zip
->iv_buf
[0],
7986 seven_zip
->iv_buf
[1],
7987 seven_zip
->iv_buf
[2],
7988 seven_zip
->iv_buf
[3],
7990 seven_zip
->data_len
,
7991 seven_zip
->unpack_size
,
7996 else if (hash_mode
== 11700)
7998 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8008 else if (hash_mode
== 11800)
8010 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8028 else if (hash_mode
== 11900)
8030 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8032 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8033 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8035 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8037 else if (hash_mode
== 12000)
8039 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8041 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8042 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8044 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8046 else if (hash_mode
== 12100)
8048 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8050 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8051 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8053 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8055 else if (hash_mode
== 12200)
8057 uint
*ptr_digest
= digest_buf
;
8058 uint
*ptr_salt
= salt
.salt_buf
;
8060 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8067 else if (hash_mode
== 12300)
8069 uint
*ptr_digest
= digest_buf
;
8070 uint
*ptr_salt
= salt
.salt_buf
;
8072 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",
8073 ptr_digest
[ 0], ptr_digest
[ 1],
8074 ptr_digest
[ 2], ptr_digest
[ 3],
8075 ptr_digest
[ 4], ptr_digest
[ 5],
8076 ptr_digest
[ 6], ptr_digest
[ 7],
8077 ptr_digest
[ 8], ptr_digest
[ 9],
8078 ptr_digest
[10], ptr_digest
[11],
8079 ptr_digest
[12], ptr_digest
[13],
8080 ptr_digest
[14], ptr_digest
[15],
8086 else if (hash_mode
== 12400)
8088 // encode iteration count
8090 char salt_iter
[5] = { 0 };
8092 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8093 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8094 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8095 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8100 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8101 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8102 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8103 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8108 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8110 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8111 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8113 memcpy (tmp_buf
, digest_buf
, 8);
8115 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8119 // fill the resulting buffer
8121 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8123 else if (hash_mode
== 12500)
8125 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8127 byte_swap_32 (salt
.salt_buf
[0]),
8128 byte_swap_32 (salt
.salt_buf
[1]),
8134 else if (hash_mode
== 12600)
8136 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8137 digest_buf
[0] + salt
.salt_buf_pc
[0],
8138 digest_buf
[1] + salt
.salt_buf_pc
[1],
8139 digest_buf
[2] + salt
.salt_buf_pc
[2],
8140 digest_buf
[3] + salt
.salt_buf_pc
[3],
8141 digest_buf
[4] + salt
.salt_buf_pc
[4],
8142 digest_buf
[5] + salt
.salt_buf_pc
[5],
8143 digest_buf
[6] + salt
.salt_buf_pc
[6],
8144 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8146 else if (hash_mode
== 12700)
8148 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8150 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8151 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8153 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8155 else if (hash_mode
== 12800)
8157 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8159 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",
8172 byte_swap_32 (digest_buf
[0]),
8173 byte_swap_32 (digest_buf
[1]),
8174 byte_swap_32 (digest_buf
[2]),
8175 byte_swap_32 (digest_buf
[3]),
8176 byte_swap_32 (digest_buf
[4]),
8177 byte_swap_32 (digest_buf
[5]),
8178 byte_swap_32 (digest_buf
[6]),
8179 byte_swap_32 (digest_buf
[7])
8182 else if (hash_mode
== 12900)
8184 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",
8193 byte_swap_32 (digest_buf
[0]),
8194 byte_swap_32 (digest_buf
[1]),
8195 byte_swap_32 (digest_buf
[2]),
8196 byte_swap_32 (digest_buf
[3]),
8197 byte_swap_32 (digest_buf
[4]),
8198 byte_swap_32 (digest_buf
[5]),
8199 byte_swap_32 (digest_buf
[6]),
8200 byte_swap_32 (digest_buf
[7]),
8207 else if (hash_mode
== 13000)
8209 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8211 rar5_t
*rar5
= &rar5s
[salt_pos
];
8213 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8223 byte_swap_32 (digest_buf
[0]),
8224 byte_swap_32 (digest_buf
[1])
8229 if (hash_type
== HASH_TYPE_MD4
)
8231 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8237 else if (hash_type
== HASH_TYPE_MD5
)
8239 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8245 else if (hash_type
== HASH_TYPE_SHA1
)
8247 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8254 else if (hash_type
== HASH_TYPE_SHA256
)
8256 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8266 else if (hash_type
== HASH_TYPE_SHA384
)
8268 uint
*ptr
= digest_buf
;
8270 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8278 else if (hash_type
== HASH_TYPE_SHA512
)
8280 uint
*ptr
= digest_buf
;
8282 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8292 else if (hash_type
== HASH_TYPE_LM
)
8294 snprintf (out_buf
, len
-1, "%08x%08x",
8298 else if (hash_type
== HASH_TYPE_ORACLEH
)
8300 snprintf (out_buf
, len
-1, "%08X%08X",
8304 else if (hash_type
== HASH_TYPE_BCRYPT
)
8306 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8307 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8309 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8311 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8313 else if (hash_type
== HASH_TYPE_KECCAK
)
8315 uint
*ptr
= digest_buf
;
8317 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",
8345 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8347 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8349 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8356 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8358 digest_buf
[ 0] = digest_buf
[ 0];
8359 digest_buf
[ 1] = digest_buf
[ 1];
8360 digest_buf
[ 2] = digest_buf
[ 2];
8361 digest_buf
[ 3] = digest_buf
[ 3];
8362 digest_buf
[ 4] = digest_buf
[ 4];
8363 digest_buf
[ 5] = digest_buf
[ 5];
8364 digest_buf
[ 6] = digest_buf
[ 6];
8365 digest_buf
[ 7] = digest_buf
[ 7];
8366 digest_buf
[ 8] = digest_buf
[ 8];
8367 digest_buf
[ 9] = digest_buf
[ 9];
8368 digest_buf
[10] = digest_buf
[10];
8369 digest_buf
[11] = digest_buf
[11];
8370 digest_buf
[12] = digest_buf
[12];
8371 digest_buf
[13] = digest_buf
[13];
8372 digest_buf
[14] = digest_buf
[14];
8373 digest_buf
[15] = digest_buf
[15];
8375 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8393 else if (hash_type
== HASH_TYPE_GOST
)
8395 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8405 else if (hash_type
== HASH_TYPE_MYSQL
)
8407 snprintf (out_buf
, len
-1, "%08x%08x",
8411 else if (hash_type
== HASH_TYPE_LOTUS5
)
8413 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8419 else if (hash_type
== HASH_TYPE_LOTUS6
)
8421 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8422 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8423 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8424 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8426 char buf
[16] = { 0 };
8428 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8429 memcpy (buf
+ 5, digest_buf
, 9);
8433 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8435 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8438 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8440 else if (hash_type
== HASH_TYPE_LOTUS8
)
8442 char buf
[52] = { 0 };
8446 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8452 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8456 buf
[26] = salt
.salt_buf_pc
[0];
8457 buf
[27] = salt
.salt_buf_pc
[1];
8461 memcpy (buf
+ 28, digest_buf
, 8);
8463 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8467 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8469 else if (hash_type
== HASH_TYPE_CRC32
)
8471 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8475 if (salt_type
== SALT_TYPE_INTERN
)
8477 size_t pos
= strlen (out_buf
);
8479 out_buf
[pos
] = data
.separator
;
8481 char *ptr
= (char *) salt
.salt_buf
;
8483 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8485 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8489 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8491 memset (hccap
, 0, sizeof (hccap_t
));
8493 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8495 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8497 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8498 wpa_t
*wpa
= &wpas
[salt_pos
];
8500 hccap
->keyver
= wpa
->keyver
;
8502 hccap
->eapol_size
= wpa
->eapol_size
;
8504 if (wpa
->keyver
!= 1)
8506 uint eapol_tmp
[64] = { 0 };
8508 for (uint i
= 0; i
< 64; i
++)
8510 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8513 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8517 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8520 uint pke_tmp
[25] = { 0 };
8522 for (int i
= 5; i
< 25; i
++)
8524 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8527 char *pke_ptr
= (char *) pke_tmp
;
8529 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8530 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8531 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8532 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8534 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8536 uint dgst_size
= data
.dgst_size
;
8538 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8540 if (wpa
->keyver
!= 1)
8542 uint digest_tmp
[4] = { 0 };
8544 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8545 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8546 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8547 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8549 memcpy (hccap
->keymic
, digest_tmp
, 16);
8553 memcpy (hccap
->keymic
, digest_ptr
, 16);
8557 void SuspendThreads ()
8559 if (data
.devices_status
== STATUS_RUNNING
)
8561 hc_timer_set (&data
.timer_paused
);
8563 data
.devices_status
= STATUS_PAUSED
;
8565 log_info ("Paused");
8569 void ResumeThreads ()
8571 if (data
.devices_status
== STATUS_PAUSED
)
8575 hc_timer_get (data
.timer_paused
, ms_paused
);
8577 data
.ms_paused
+= ms_paused
;
8579 data
.devices_status
= STATUS_RUNNING
;
8581 log_info ("Resumed");
8587 if (data
.devices_status
!= STATUS_RUNNING
) return;
8589 data
.devices_status
= STATUS_BYPASS
;
8591 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8594 void stop_at_checkpoint ()
8596 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8598 if (data
.devices_status
!= STATUS_RUNNING
) return;
8601 // this feature only makes sense if --restore-disable was not specified
8603 if (data
.restore_disable
== 1)
8605 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8610 // check if monitoring of Restore Point updates should be enabled or disabled
8612 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8614 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8616 // save the current restore point value
8618 data
.checkpoint_cur_words
= get_lowest_words_done ();
8620 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8624 data
.devices_status
= STATUS_RUNNING
;
8626 // reset the global value for checkpoint checks
8628 data
.checkpoint_cur_words
= 0;
8630 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8636 if (data
.devices_status
== STATUS_INIT
) return;
8637 if (data
.devices_status
== STATUS_STARTING
) return;
8639 data
.devices_status
= STATUS_ABORTED
;
8644 if (data
.devices_status
== STATUS_INIT
) return;
8645 if (data
.devices_status
== STATUS_STARTING
) return;
8647 data
.devices_status
= STATUS_QUIT
;
8650 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8652 FILE *fp
= fopen (kernel_file
, "rb");
8658 memset (&st
, 0, sizeof (st
));
8660 stat (kernel_file
, &st
);
8662 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8664 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8666 if (num_read
!= (size_t) st
.st_size
)
8668 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8675 buf
[st
.st_size
] = 0;
8677 for (int i
= 0; i
< num_devices
; i
++)
8679 kernel_lengths
[i
] = (size_t) st
.st_size
;
8681 kernel_sources
[i
] = buf
;
8686 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8694 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8696 if (binary_size
> 0)
8698 FILE *fp
= fopen (dst
, "wb");
8701 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8712 restore_data_t
*init_restore (int argc
, char **argv
)
8714 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8716 if (data
.restore_disable
== 0)
8718 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8722 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8726 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8735 char pidbin
[BUFSIZ
] = { 0 };
8737 int pidbin_len
= -1;
8740 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8742 FILE *fd
= fopen (pidbin
, "rb");
8746 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8748 pidbin
[pidbin_len
] = 0;
8752 char *argv0_r
= strrchr (argv
[0], '/');
8754 char *pidbin_r
= strrchr (pidbin
, '/');
8756 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8758 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8760 if (strcmp (argv0_r
, pidbin_r
) == 0)
8762 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8769 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8771 char pidbin2
[BUFSIZ
] = { 0 };
8773 int pidbin2_len
= -1;
8775 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8776 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8778 pidbin
[pidbin_len
] = 0;
8779 pidbin2
[pidbin2_len
] = 0;
8783 if (strcmp (pidbin
, pidbin2
) == 0)
8785 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8793 if (rd
->version_bin
< RESTORE_MIN
)
8795 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8802 memset (rd
, 0, sizeof (restore_data_t
));
8804 rd
->version_bin
= VERSION_BIN
;
8807 rd
->pid
= getpid ();
8809 rd
->pid
= GetCurrentProcessId ();
8812 if (getcwd (rd
->cwd
, 255) == NULL
)
8825 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8827 FILE *fp
= fopen (eff_restore_file
, "rb");
8831 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8836 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8838 log_error ("ERROR: cannot read %s", eff_restore_file
);
8843 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8845 for (uint i
= 0; i
< rd
->argc
; i
++)
8847 char buf
[BUFSIZ
] = { 0 };
8849 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8851 log_error ("ERROR: cannot read %s", eff_restore_file
);
8856 size_t len
= strlen (buf
);
8858 if (len
) buf
[len
- 1] = 0;
8860 rd
->argv
[i
] = mystrdup (buf
);
8865 char new_cwd
[1024] = { 0 };
8867 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8871 log_error ("Restore file is corrupted");
8874 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8876 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8878 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8883 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8886 if (chdir (rd
->cwd
))
8888 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8894 u64
get_lowest_words_done ()
8898 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8900 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8902 if (device_param
->skipped
) continue;
8904 const u64 words_done
= device_param
->words_done
;
8906 if (words_done
< words_cur
) words_cur
= words_done
;
8909 // It's possible that a device's workload isn't finished right after a restore-case.
8910 // In that case, this function would return 0 and overwrite the real restore point
8911 // There's also data.words_cur which is set to rd->words_cur but it changes while
8912 // the attack is running therefore we should stick to rd->words_cur.
8913 // Note that -s influences rd->words_cur we should keep a close look on that.
8915 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
8920 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
8922 u64 words_cur
= get_lowest_words_done ();
8924 rd
->words_cur
= words_cur
;
8926 FILE *fp
= fopen (new_restore_file
, "wb");
8930 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
8935 if (setvbuf (fp
, NULL
, _IONBF
, 0))
8937 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
8942 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
8944 for (uint i
= 0; i
< rd
->argc
; i
++)
8946 fprintf (fp
, "%s", rd
->argv
[i
]);
8952 fsync (fileno (fp
));
8957 void cycle_restore ()
8959 const char *eff_restore_file
= data
.eff_restore_file
;
8960 const char *new_restore_file
= data
.new_restore_file
;
8962 restore_data_t
*rd
= data
.rd
;
8964 write_restore (new_restore_file
, rd
);
8968 memset (&st
, 0, sizeof(st
));
8970 if (stat (eff_restore_file
, &st
) == 0)
8972 if (unlink (eff_restore_file
))
8974 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
8978 if (rename (new_restore_file
, eff_restore_file
))
8980 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
8984 void check_checkpoint ()
8986 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
8988 u64 words_cur
= get_lowest_words_done ();
8990 if (words_cur
!= data
.checkpoint_cur_words
)
9001 uint
set_kernel_accel_osx (uint hash_mode
)
9005 case 1800: return GET_ACCEL_OSX (1800);
9006 case 2500: return GET_ACCEL_OSX (2500);
9007 case 5000: return GET_ACCEL_OSX (5000);
9008 case 6100: return GET_ACCEL_OSX (6100);
9009 case 6211: return GET_ACCEL_OSX (6211);
9010 case 6231: return GET_ACCEL_OSX (6231);
9011 case 6241: return GET_ACCEL_OSX (6241);
9012 case 6800: return GET_ACCEL_OSX (6800);
9013 case 7100: return GET_ACCEL_OSX (7100);
9014 case 7200: return GET_ACCEL_OSX (7200);
9015 case 7900: return GET_ACCEL_OSX (7900);
9016 case 8200: return GET_ACCEL_OSX (8200);
9017 case 8700: return GET_ACCEL_OSX (8700);
9018 case 9100: return GET_ACCEL_OSX (9100);
9019 case 9200: return GET_ACCEL_OSX (9200);
9020 case 9300: return GET_ACCEL_OSX (9300);
9021 case 9400: return GET_ACCEL_OSX (9400);
9022 case 9500: return GET_ACCEL_OSX (9500);
9023 case 9600: return GET_ACCEL_OSX (9600);
9024 case 10000: return GET_ACCEL_OSX (10000);
9025 case 10500: return GET_ACCEL_OSX (10500);
9026 case 11300: return GET_ACCEL_OSX (11300);
9027 case 11600: return GET_ACCEL_OSX (11600);
9028 case 11700: return GET_ACCEL_OSX (11700);
9029 case 11800: return GET_ACCEL_OSX (11800);
9030 case 12200: return GET_ACCEL_OSX (12200);
9031 case 12400: return GET_ACCEL_OSX (12400);
9032 case 12500: return GET_ACCEL_OSX (12500);
9033 case 13000: return GET_ACCEL_OSX (13000);
9039 uint
set_kernel_accel (uint hash_mode
, bool isGpu
)
9044 accel
= set_kernel_accel_osx (hash_mode
);
9050 uint
set_kernel_accel (uint hash_mode
)
9057 case 0: return GET_ACCEL (0);
9058 case 10: return GET_ACCEL (10);
9059 case 11: return GET_ACCEL (11);
9060 case 12: return GET_ACCEL (12);
9061 case 20: return GET_ACCEL (20);
9062 case 21: return GET_ACCEL (21);
9063 case 22: return GET_ACCEL (22);
9064 case 23: return GET_ACCEL (23);
9065 case 30: return GET_ACCEL (30);
9066 case 40: return GET_ACCEL (40);
9067 case 50: return GET_ACCEL (50);
9068 case 60: return GET_ACCEL (60);
9069 case 100: return GET_ACCEL (100);
9070 case 101: return GET_ACCEL (101);
9071 case 110: return GET_ACCEL (110);
9072 case 111: return GET_ACCEL (111);
9073 case 112: return GET_ACCEL (112);
9074 case 120: return GET_ACCEL (120);
9075 case 121: return GET_ACCEL (121);
9076 case 122: return GET_ACCEL (122);
9077 case 124: return GET_ACCEL (124);
9078 case 130: return GET_ACCEL (130);
9079 case 131: return GET_ACCEL (131);
9080 case 132: return GET_ACCEL (132);
9081 case 133: return GET_ACCEL (133);
9082 case 140: return GET_ACCEL (140);
9083 case 141: return GET_ACCEL (141);
9084 case 150: return GET_ACCEL (150);
9085 case 160: return GET_ACCEL (160);
9086 case 190: return GET_ACCEL (190);
9087 case 200: return GET_ACCEL (200);
9088 case 300: return GET_ACCEL (300);
9089 case 400: return GET_ACCEL (400);
9090 case 500: return GET_ACCEL (500);
9091 case 501: return GET_ACCEL (501);
9092 case 900: return GET_ACCEL (900);
9093 case 910: return GET_ACCEL (910);
9094 case 1000: return GET_ACCEL (1000);
9095 case 1100: return GET_ACCEL (1100);
9096 case 1400: return GET_ACCEL (1400);
9097 case 1410: return GET_ACCEL (1410);
9098 case 1420: return GET_ACCEL (1420);
9099 case 1421: return GET_ACCEL (1421);
9100 case 1430: return GET_ACCEL (1430);
9101 case 1440: return GET_ACCEL (1440);
9102 case 1441: return GET_ACCEL (1441);
9103 case 1450: return GET_ACCEL (1450);
9104 case 1460: return GET_ACCEL (1460);
9105 case 1500: return GET_ACCEL (1500);
9106 case 1600: return GET_ACCEL (1600);
9107 case 1700: return GET_ACCEL (1700);
9108 case 1710: return GET_ACCEL (1710);
9109 case 1711: return GET_ACCEL (1711);
9110 case 1720: return GET_ACCEL (1720);
9111 case 1722: return GET_ACCEL (1722);
9112 case 1730: return GET_ACCEL (1730);
9113 case 1731: return GET_ACCEL (1731);
9114 case 1740: return GET_ACCEL (1740);
9115 case 1750: return GET_ACCEL (1750);
9116 case 1760: return GET_ACCEL (1760);
9117 case 1800: return GET_ACCEL (1800);
9118 case 2100: return GET_ACCEL (2100);
9119 case 2400: return GET_ACCEL (2400);
9120 case 2410: return GET_ACCEL (2410);
9121 case 2500: return GET_ACCEL (2500);
9122 case 2600: return GET_ACCEL (2600);
9123 case 2611: return GET_ACCEL (2611);
9124 case 2612: return GET_ACCEL (2612);
9125 case 2711: return GET_ACCEL (2711);
9126 case 2811: return GET_ACCEL (2811);
9127 case 3000: return GET_ACCEL (3000);
9128 case 3100: return GET_ACCEL (3100);
9129 case 3200: return GET_ACCEL (3200);
9130 case 3710: return GET_ACCEL (3710);
9131 case 3711: return GET_ACCEL (3711);
9132 case 3800: return GET_ACCEL (3800);
9133 case 4300: return GET_ACCEL (4300);
9134 case 4400: return GET_ACCEL (4400);
9135 case 4500: return GET_ACCEL (4500);
9136 case 4700: return GET_ACCEL (4700);
9137 case 4800: return GET_ACCEL (4800);
9138 case 4900: return GET_ACCEL (4900);
9139 case 5000: return GET_ACCEL (5000);
9140 case 5100: return GET_ACCEL (5100);
9141 case 5200: return GET_ACCEL (5200);
9142 case 5300: return GET_ACCEL (5300);
9143 case 5400: return GET_ACCEL (5400);
9144 case 5500: return GET_ACCEL (5500);
9145 case 5600: return GET_ACCEL (5600);
9146 case 5700: return GET_ACCEL (5700);
9147 case 5800: return GET_ACCEL (5800);
9148 case 6000: return GET_ACCEL (6000);
9149 case 6100: return GET_ACCEL (6100);
9150 case 6211: return GET_ACCEL (6211);
9151 case 6212: return GET_ACCEL (6212);
9152 case 6213: return GET_ACCEL (6213);
9153 case 6221: return GET_ACCEL (6221);
9154 case 6222: return GET_ACCEL (6222);
9155 case 6223: return GET_ACCEL (6223);
9156 case 6231: return GET_ACCEL (6231);
9157 case 6232: return GET_ACCEL (6232);
9158 case 6233: return GET_ACCEL (6233);
9159 case 6241: return GET_ACCEL (6241);
9160 case 6242: return GET_ACCEL (6242);
9161 case 6243: return GET_ACCEL (6243);
9162 case 6300: return GET_ACCEL (6300);
9163 case 6400: return GET_ACCEL (6400);
9164 case 6500: return GET_ACCEL (6500);
9165 case 6600: return GET_ACCEL (6600);
9166 case 6700: return GET_ACCEL (6700);
9167 case 6800: return GET_ACCEL (6800);
9168 case 6900: return GET_ACCEL (6900);
9169 case 7100: return GET_ACCEL (7100);
9170 case 7200: return GET_ACCEL (7200);
9171 case 7300: return GET_ACCEL (7300);
9172 case 7400: return GET_ACCEL (7400);
9173 case 7500: return GET_ACCEL (7500);
9174 case 7600: return GET_ACCEL (7600);
9175 case 7700: return GET_ACCEL (7700);
9176 case 7800: return GET_ACCEL (7800);
9177 case 7900: return GET_ACCEL (7900);
9178 case 8000: return GET_ACCEL (8000);
9179 case 8100: return GET_ACCEL (8100);
9180 case 8200: return GET_ACCEL (8200);
9181 case 8300: return GET_ACCEL (8300);
9182 case 8400: return GET_ACCEL (8400);
9183 case 8500: return GET_ACCEL (8500);
9184 case 8600: return GET_ACCEL (8600);
9185 case 8700: return GET_ACCEL (8700);
9186 case 8800: return GET_ACCEL (8800);
9187 case 8900: return GET_ACCEL (8900);
9188 case 9000: return GET_ACCEL (9000);
9189 case 9100: return GET_ACCEL (9100);
9190 case 9200: return GET_ACCEL (9200);
9191 case 9300: return GET_ACCEL (9300);
9192 case 9400: return GET_ACCEL (9400);
9193 case 9500: return GET_ACCEL (9500);
9194 case 9600: return GET_ACCEL (9600);
9195 case 9700: return GET_ACCEL (9700);
9196 case 9710: return GET_ACCEL (9710);
9197 case 9720: return GET_ACCEL (9720);
9198 case 9800: return GET_ACCEL (9800);
9199 case 9810: return GET_ACCEL (9810);
9200 case 9820: return GET_ACCEL (9820);
9201 case 9900: return GET_ACCEL (9900);
9202 case 10000: return GET_ACCEL (10000);
9203 case 10100: return GET_ACCEL (10100);
9204 case 10200: return GET_ACCEL (10200);
9205 case 10300: return GET_ACCEL (10300);
9206 case 10400: return GET_ACCEL (10400);
9207 case 10410: return GET_ACCEL (10410);
9208 case 10420: return GET_ACCEL (10420);
9209 case 10500: return GET_ACCEL (10500);
9210 case 10600: return GET_ACCEL (10600);
9211 case 10700: return GET_ACCEL (10700);
9212 case 10800: return GET_ACCEL (10800);
9213 case 10900: return GET_ACCEL (10900);
9214 case 11000: return GET_ACCEL (11000);
9215 case 11100: return GET_ACCEL (11100);
9216 case 11200: return GET_ACCEL (11200);
9217 case 11300: return GET_ACCEL (11300);
9218 case 11400: return GET_ACCEL (11400);
9219 case 11500: return GET_ACCEL (11500);
9220 case 11600: return GET_ACCEL (11600);
9221 case 11700: return GET_ACCEL (11700);
9222 case 11800: return GET_ACCEL (11800);
9223 case 11900: return GET_ACCEL (11900);
9224 case 12000: return GET_ACCEL (12000);
9225 case 12100: return GET_ACCEL (12100);
9226 case 12200: return GET_ACCEL (12200);
9227 case 12300: return GET_ACCEL (12300);
9228 case 12400: return GET_ACCEL (12400);
9229 case 12500: return GET_ACCEL (12500);
9230 case 12600: return GET_ACCEL (12600);
9231 case 12700: return GET_ACCEL (12700);
9232 case 12800: return GET_ACCEL (12800);
9233 case 12900: return GET_ACCEL (12900);
9234 case 13000: return GET_ACCEL (13000);
9241 uint
set_kernel_loops_osx (uint hash_mode
)
9245 case 0: return GET_LOOPS_OSX (0);
9246 case 10: return GET_LOOPS_OSX (10);
9247 case 11: return GET_LOOPS_OSX (11);
9248 case 12: return GET_LOOPS_OSX (12);
9249 case 20: return GET_LOOPS_OSX (20);
9250 case 21: return GET_LOOPS_OSX (21);
9251 case 22: return GET_LOOPS_OSX (22);
9252 case 23: return GET_LOOPS_OSX (23);
9253 case 30: return GET_LOOPS_OSX (30);
9254 case 40: return GET_LOOPS_OSX (40);
9255 case 50: return GET_LOOPS_OSX (50);
9256 case 60: return GET_LOOPS_OSX (60);
9257 case 100: return GET_LOOPS_OSX (100);
9258 case 101: return GET_LOOPS_OSX (101);
9259 case 110: return GET_LOOPS_OSX (110);
9260 case 111: return GET_LOOPS_OSX (111);
9261 case 112: return GET_LOOPS_OSX (112);
9262 case 120: return GET_LOOPS_OSX (120);
9263 case 121: return GET_LOOPS_OSX (121);
9264 case 122: return GET_LOOPS_OSX (122);
9265 case 124: return GET_LOOPS_OSX (124);
9266 case 130: return GET_LOOPS_OSX (130);
9267 case 131: return GET_LOOPS_OSX (131);
9268 case 132: return GET_LOOPS_OSX (132);
9269 case 133: return GET_LOOPS_OSX (133);
9270 case 140: return GET_LOOPS_OSX (140);
9271 case 141: return GET_LOOPS_OSX (141);
9272 case 150: return GET_LOOPS_OSX (150);
9273 case 160: return GET_LOOPS_OSX (160);
9274 case 190: return GET_LOOPS_OSX (190);
9275 case 200: return GET_LOOPS_OSX (200);
9276 case 300: return GET_LOOPS_OSX (300);
9277 case 900: return GET_LOOPS_OSX (900);
9278 case 1000: return GET_LOOPS_OSX (1000);
9279 case 1100: return GET_LOOPS_OSX (1100);
9280 case 1400: return GET_LOOPS_OSX (1400);
9281 case 1410: return GET_LOOPS_OSX (1410);
9282 case 1420: return GET_LOOPS_OSX (1420);
9283 case 1421: return GET_LOOPS_OSX (1421);
9284 case 1430: return GET_LOOPS_OSX (1430);
9285 case 1440: return GET_LOOPS_OSX (1440);
9286 case 1441: return GET_LOOPS_OSX (1441);
9287 case 1450: return GET_LOOPS_OSX (1450);
9288 case 1460: return GET_LOOPS_OSX (1460);
9289 case 1700: return GET_LOOPS_OSX (1700);
9290 case 1710: return GET_LOOPS_OSX (1710);
9291 case 1711: return GET_LOOPS_OSX (1711);
9292 case 1720: return GET_LOOPS_OSX (1720);
9293 case 1722: return GET_LOOPS_OSX (1722);
9294 case 1730: return GET_LOOPS_OSX (1730);
9295 case 1731: return GET_LOOPS_OSX (1731);
9296 case 1740: return GET_LOOPS_OSX (1740);
9297 case 1750: return GET_LOOPS_OSX (1750);
9298 case 1760: return GET_LOOPS_OSX (1760);
9299 case 2400: return GET_LOOPS_OSX (2400);
9300 case 2410: return GET_LOOPS_OSX (2410);
9301 case 2600: return GET_LOOPS_OSX (2600);
9302 case 2611: return GET_LOOPS_OSX (2611);
9303 case 2612: return GET_LOOPS_OSX (2612);
9304 case 2711: return GET_LOOPS_OSX (2711);
9305 case 2811: return GET_LOOPS_OSX (2811);
9306 case 3100: return GET_LOOPS_OSX (3100);
9307 case 3200: return GET_LOOPS_OSX (3200);
9308 case 3710: return GET_LOOPS_OSX (3710);
9309 case 3711: return GET_LOOPS_OSX (3711);
9310 case 3800: return GET_LOOPS_OSX (3800);
9311 case 4300: return GET_LOOPS_OSX (4300);
9312 case 4400: return GET_LOOPS_OSX (4400);
9313 case 4500: return GET_LOOPS_OSX (4500);
9314 case 4700: return GET_LOOPS_OSX (4700);
9315 case 4800: return GET_LOOPS_OSX (4800);
9316 case 4900: return GET_LOOPS_OSX (4900);
9317 case 5000: return GET_LOOPS_OSX (5000);
9318 case 5100: return GET_LOOPS_OSX (5100);
9319 case 5300: return GET_LOOPS_OSX (5300);
9320 case 5400: return GET_LOOPS_OSX (5400);
9321 case 5500: return GET_LOOPS_OSX (5500);
9322 case 5600: return GET_LOOPS_OSX (5600);
9323 case 5700: return GET_LOOPS_OSX (5700);
9324 case 6000: return GET_LOOPS_OSX (6000);
9325 case 6100: return GET_LOOPS_OSX (6100);
9326 case 6231: return GET_LOOPS_OSX (6231);
9327 case 6232: return GET_LOOPS_OSX (6232);
9328 case 6233: return GET_LOOPS_OSX (6233);
9329 case 6900: return GET_LOOPS_OSX (6900);
9330 case 7300: return GET_LOOPS_OSX (7300);
9331 case 7500: return GET_LOOPS_OSX (7500);
9332 case 7600: return GET_LOOPS_OSX (7600);
9333 case 7700: return GET_LOOPS_OSX (7700);
9334 case 7800: return GET_LOOPS_OSX (7800);
9335 case 8000: return GET_LOOPS_OSX (8000);
9336 case 8100: return GET_LOOPS_OSX (8100);
9337 case 8200: return GET_LOOPS_OSX (8200);
9338 case 8300: return GET_LOOPS_OSX (8300);
9339 case 8400: return GET_LOOPS_OSX (8400);
9340 case 8500: return GET_LOOPS_OSX (8500);
9341 case 8600: return GET_LOOPS_OSX (8600);
9342 case 8700: return GET_LOOPS_OSX (8700);
9343 case 9700: return GET_LOOPS_OSX (9700);
9344 case 9710: return GET_LOOPS_OSX (9710);
9345 case 9720: return GET_LOOPS_OSX (9720);
9346 case 9800: return GET_LOOPS_OSX (9800);
9347 case 9810: return GET_LOOPS_OSX (9810);
9348 case 9820: return GET_LOOPS_OSX (9820);
9349 case 9900: return GET_LOOPS_OSX (9900);
9350 case 10100: return GET_LOOPS_OSX (10100);
9351 case 10200: return GET_LOOPS_OSX (10200);
9352 case 10400: return GET_LOOPS_OSX (10400);
9353 case 10410: return GET_LOOPS_OSX (10410);
9354 case 10420: return GET_LOOPS_OSX (10420);
9355 case 10600: return GET_LOOPS_OSX (10600);
9356 case 10700: return GET_LOOPS_OSX (10700);
9357 case 10800: return GET_LOOPS_OSX (10800);
9358 case 11000: return GET_LOOPS_OSX (11000);
9359 case 11100: return GET_LOOPS_OSX (11100);
9360 case 11200: return GET_LOOPS_OSX (11200);
9361 case 11300: return GET_LOOPS_OSX (11300);
9362 case 11400: return GET_LOOPS_OSX (11400);
9363 case 11500: return GET_LOOPS_OSX (11500);
9364 case 11700: return GET_LOOPS_OSX (11700);
9365 case 11800: return GET_LOOPS_OSX (11800);
9366 case 12600: return GET_LOOPS_OSX (12600);
9372 uint
set_kernel_loops (uint hash_mode
, bool isGpu
)
9376 loops
= set_kernel_loops_osx (hash_mode
);
9383 uint
set_kernel_loops (uint hash_mode
)
9390 case 0: return GET_LOOPS (0);
9391 case 10: return GET_LOOPS (10);
9392 case 11: return GET_LOOPS (11);
9393 case 12: return GET_LOOPS (12);
9394 case 20: return GET_LOOPS (20);
9395 case 21: return GET_LOOPS (21);
9396 case 22: return GET_LOOPS (22);
9397 case 23: return GET_LOOPS (23);
9398 case 30: return GET_LOOPS (30);
9399 case 40: return GET_LOOPS (40);
9400 case 50: return GET_LOOPS (50);
9401 case 60: return GET_LOOPS (60);
9402 case 100: return GET_LOOPS (100);
9403 case 101: return GET_LOOPS (101);
9404 case 110: return GET_LOOPS (110);
9405 case 111: return GET_LOOPS (111);
9406 case 112: return GET_LOOPS (112);
9407 case 120: return GET_LOOPS (120);
9408 case 121: return GET_LOOPS (121);
9409 case 122: return GET_LOOPS (122);
9410 case 124: return GET_LOOPS (124);
9411 case 130: return GET_LOOPS (130);
9412 case 131: return GET_LOOPS (131);
9413 case 132: return GET_LOOPS (132);
9414 case 133: return GET_LOOPS (133);
9415 case 140: return GET_LOOPS (140);
9416 case 141: return GET_LOOPS (141);
9417 case 150: return GET_LOOPS (150);
9418 case 160: return GET_LOOPS (160);
9419 case 190: return GET_LOOPS (190);
9420 case 200: return GET_LOOPS (200);
9421 case 300: return GET_LOOPS (300);
9422 case 400: return GET_LOOPS (400);
9423 case 500: return GET_LOOPS (500);
9424 case 501: return GET_LOOPS (501);
9425 case 900: return GET_LOOPS (900);
9426 case 910: return GET_LOOPS (910);
9427 case 1000: return GET_LOOPS (1000);
9428 case 1100: return GET_LOOPS (1100);
9429 case 1400: return GET_LOOPS (1400);
9430 case 1410: return GET_LOOPS (1410);
9431 case 1420: return GET_LOOPS (1420);
9432 case 1421: return GET_LOOPS (1421);
9433 case 1430: return GET_LOOPS (1430);
9434 case 1440: return GET_LOOPS (1440);
9435 case 1441: return GET_LOOPS (1441);
9436 case 1450: return GET_LOOPS (1450);
9437 case 1460: return GET_LOOPS (1460);
9438 case 1500: return GET_LOOPS (1500);
9439 case 1600: return GET_LOOPS (1600);
9440 case 1700: return GET_LOOPS (1700);
9441 case 1710: return GET_LOOPS (1710);
9442 case 1711: return GET_LOOPS (1711);
9443 case 1720: return GET_LOOPS (1720);
9444 case 1722: return GET_LOOPS (1722);
9445 case 1730: return GET_LOOPS (1730);
9446 case 1731: return GET_LOOPS (1731);
9447 case 1740: return GET_LOOPS (1740);
9448 case 1750: return GET_LOOPS (1750);
9449 case 1760: return GET_LOOPS (1760);
9450 case 1800: return GET_LOOPS (1800);
9451 case 2100: return GET_LOOPS (2100);
9452 case 2400: return GET_LOOPS (2400);
9453 case 2410: return GET_LOOPS (2410);
9454 case 2500: return GET_LOOPS (2500);
9455 case 2600: return GET_LOOPS (2600);
9456 case 2611: return GET_LOOPS (2611);
9457 case 2612: return GET_LOOPS (2612);
9458 case 2711: return GET_LOOPS (2711);
9459 case 2811: return GET_LOOPS (2811);
9460 case 3000: return GET_LOOPS (3000);
9461 case 3100: return GET_LOOPS (3100);
9462 case 3200: return GET_LOOPS (3200);
9463 case 3710: return GET_LOOPS (3710);
9464 case 3711: return GET_LOOPS (3711);
9465 case 3800: return GET_LOOPS (3800);
9466 case 4300: return GET_LOOPS (4300);
9467 case 4400: return GET_LOOPS (4400);
9468 case 4500: return GET_LOOPS (4500);
9469 case 4700: return GET_LOOPS (4700);
9470 case 4800: return GET_LOOPS (4800);
9471 case 4900: return GET_LOOPS (4900);
9472 case 5000: return GET_LOOPS (5000);
9473 case 5100: return GET_LOOPS (5100);
9474 case 5200: return GET_LOOPS (5200);
9475 case 5300: return GET_LOOPS (5300);
9476 case 5400: return GET_LOOPS (5400);
9477 case 5500: return GET_LOOPS (5500);
9478 case 5600: return GET_LOOPS (5600);
9479 case 5700: return GET_LOOPS (5700);
9480 case 5800: return GET_LOOPS (5800);
9481 case 6000: return GET_LOOPS (6000);
9482 case 6100: return GET_LOOPS (6100);
9483 case 6211: return GET_LOOPS (6211);
9484 case 6212: return GET_LOOPS (6212);
9485 case 6213: return GET_LOOPS (6213);
9486 case 6221: return GET_LOOPS (6221);
9487 case 6222: return GET_LOOPS (6222);
9488 case 6223: return GET_LOOPS (6223);
9489 case 6231: return GET_LOOPS (6231);
9490 case 6232: return GET_LOOPS (6232);
9491 case 6233: return GET_LOOPS (6233);
9492 case 6241: return GET_LOOPS (6241);
9493 case 6242: return GET_LOOPS (6242);
9494 case 6243: return GET_LOOPS (6243);
9495 case 6300: return GET_LOOPS (6300);
9496 case 6400: return GET_LOOPS (6400);
9497 case 6500: return GET_LOOPS (6500);
9498 case 6600: return GET_LOOPS (6600);
9499 case 6700: return GET_LOOPS (6700);
9500 case 6800: return GET_LOOPS (6800);
9501 case 6900: return GET_LOOPS (6900);
9502 case 7100: return GET_LOOPS (7100);
9503 case 7200: return GET_LOOPS (7200);
9504 case 7300: return GET_LOOPS (7300);
9505 case 7400: return GET_LOOPS (7400);
9506 case 7500: return GET_LOOPS (7500);
9507 case 7600: return GET_LOOPS (7600);
9508 case 7700: return GET_LOOPS (7700);
9509 case 7800: return GET_LOOPS (7800);
9510 case 7900: return GET_LOOPS (7900);
9511 case 8000: return GET_LOOPS (8000);
9512 case 8100: return GET_LOOPS (8100);
9513 case 8200: return GET_LOOPS (8200);
9514 case 8300: return GET_LOOPS (8300);
9515 case 8400: return GET_LOOPS (8400);
9516 case 8500: return GET_LOOPS (8500);
9517 case 8600: return GET_LOOPS (8600);
9518 case 8700: return GET_LOOPS (8700);
9519 case 8800: return GET_LOOPS (8800);
9520 case 8900: return GET_LOOPS (8900);
9521 case 9000: return GET_LOOPS (9000);
9522 case 9100: return GET_LOOPS (9100);
9523 case 9200: return GET_LOOPS (9200);
9524 case 9300: return GET_LOOPS (9300);
9525 case 9400: return GET_LOOPS (9400);
9526 case 9500: return GET_LOOPS (9500);
9527 case 9600: return GET_LOOPS (9600);
9528 case 9700: return GET_LOOPS (9700);
9529 case 9710: return GET_LOOPS (9710);
9530 case 9720: return GET_LOOPS (9720);
9531 case 9800: return GET_LOOPS (9800);
9532 case 9810: return GET_LOOPS (9810);
9533 case 9820: return GET_LOOPS (9820);
9534 case 9900: return GET_LOOPS (9900);
9535 case 10000: return GET_LOOPS (10000);
9536 case 10100: return GET_LOOPS (10100);
9537 case 10200: return GET_LOOPS (10200);
9538 case 10300: return GET_LOOPS (10300);
9539 case 10400: return GET_LOOPS (10400);
9540 case 10410: return GET_LOOPS (10410);
9541 case 10420: return GET_LOOPS (10420);
9542 case 10500: return GET_LOOPS (10500);
9543 case 10600: return GET_LOOPS (10600);
9544 case 10700: return GET_LOOPS (10700);
9545 case 10800: return GET_LOOPS (10800);
9546 case 10900: return GET_LOOPS (10900);
9547 case 11000: return GET_LOOPS (11000);
9548 case 11100: return GET_LOOPS (11100);
9549 case 11200: return GET_LOOPS (11200);
9550 case 11300: return GET_LOOPS (11300);
9551 case 11400: return GET_LOOPS (11400);
9552 case 11500: return GET_LOOPS (11500);
9553 case 11600: return GET_LOOPS (11600);
9554 case 11700: return GET_LOOPS (11700);
9555 case 11800: return GET_LOOPS (11800);
9556 case 11900: return GET_LOOPS (11900);
9557 case 12000: return GET_LOOPS (12000);
9558 case 12100: return GET_LOOPS (12100);
9559 case 12200: return GET_LOOPS (12200);
9560 case 12300: return GET_LOOPS (12300);
9561 case 12400: return GET_LOOPS (12400);
9562 case 12500: return GET_LOOPS (12500);
9563 case 12600: return GET_LOOPS (12600);
9564 case 12700: return GET_LOOPS (12700);
9565 case 12800: return GET_LOOPS (12800);
9566 case 12900: return GET_LOOPS (12900);
9567 case 13000: return GET_LOOPS (13000);
9577 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9579 u8 tmp
[256] = { 0 };
9581 if (salt_len
> sizeof (tmp
))
9586 memcpy (tmp
, in
, salt_len
);
9588 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9590 if ((salt_len
% 2) == 0)
9592 u32 new_salt_len
= salt_len
/ 2;
9594 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9599 tmp
[i
] = hex_convert (p1
) << 0;
9600 tmp
[i
] |= hex_convert (p0
) << 4;
9603 salt_len
= new_salt_len
;
9610 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9612 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9615 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9617 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9621 u32
*tmp_uint
= (u32
*) tmp
;
9623 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9624 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9625 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9626 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9627 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9628 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9629 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9630 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9631 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9632 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9634 salt_len
= salt_len
* 2;
9642 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9644 lowercase (tmp
, salt_len
);
9647 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9649 uppercase (tmp
, salt_len
);
9654 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9659 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9664 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9666 u32
*tmp_uint
= (uint
*) tmp
;
9672 for (u32 i
= 0; i
< max
; i
++)
9674 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9677 // Important: we may need to increase the length of memcpy since
9678 // we don't want to "loose" some swapped bytes (could happen if
9679 // they do not perfectly fit in the 4-byte blocks)
9680 // Memcpy does always copy the bytes in the BE order, but since
9681 // we swapped them, some important bytes could be in positions
9682 // we normally skip with the original len
9684 if (len
% 4) len
+= 4 - (len
% 4);
9687 memcpy (out
, tmp
, len
);
9692 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9694 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9696 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9698 u32
*digest
= (u32
*) hash_buf
->digest
;
9700 salt_t
*salt
= hash_buf
->salt
;
9702 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9704 char *iter_pos
= input_buf
+ 4;
9706 salt
->salt_iter
= 1 << atoi (iter_pos
);
9708 char *salt_pos
= strchr (iter_pos
, '$');
9710 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9716 salt
->salt_len
= salt_len
;
9718 u8 tmp_buf
[100] = { 0 };
9720 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9722 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9724 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9726 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9727 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9728 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9729 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9731 char *hash_pos
= salt_pos
+ 22;
9733 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9735 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9737 memcpy (digest
, tmp_buf
, 24);
9739 digest
[0] = byte_swap_32 (digest
[0]);
9740 digest
[1] = byte_swap_32 (digest
[1]);
9741 digest
[2] = byte_swap_32 (digest
[2]);
9742 digest
[3] = byte_swap_32 (digest
[3]);
9743 digest
[4] = byte_swap_32 (digest
[4]);
9744 digest
[5] = byte_swap_32 (digest
[5]);
9746 digest
[5] &= ~0xff; // its just 23 not 24 !
9751 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9753 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9755 u32
*digest
= (u32
*) hash_buf
->digest
;
9757 u8 tmp_buf
[100] = { 0 };
9759 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9761 memcpy (digest
, tmp_buf
, 32);
9763 digest
[0] = byte_swap_32 (digest
[0]);
9764 digest
[1] = byte_swap_32 (digest
[1]);
9765 digest
[2] = byte_swap_32 (digest
[2]);
9766 digest
[3] = byte_swap_32 (digest
[3]);
9767 digest
[4] = byte_swap_32 (digest
[4]);
9768 digest
[5] = byte_swap_32 (digest
[5]);
9769 digest
[6] = byte_swap_32 (digest
[6]);
9770 digest
[7] = byte_swap_32 (digest
[7]);
9772 digest
[0] -= SHA256M_A
;
9773 digest
[1] -= SHA256M_B
;
9774 digest
[2] -= SHA256M_C
;
9775 digest
[3] -= SHA256M_D
;
9776 digest
[4] -= SHA256M_E
;
9777 digest
[5] -= SHA256M_F
;
9778 digest
[6] -= SHA256M_G
;
9779 digest
[7] -= SHA256M_H
;
9784 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9786 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9788 u32
*digest
= (u32
*) hash_buf
->digest
;
9790 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9791 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9793 digest
[0] = byte_swap_32 (digest
[0]);
9794 digest
[1] = byte_swap_32 (digest
[1]);
9798 IP (digest
[0], digest
[1], tt
);
9800 digest
[0] = digest
[0];
9801 digest
[1] = digest
[1];
9808 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9810 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9812 u32
*digest
= (u32
*) hash_buf
->digest
;
9814 salt_t
*salt
= hash_buf
->salt
;
9816 char *hash_pos
= input_buf
+ 8;
9818 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9819 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9820 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9821 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9822 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9824 digest
[0] -= SHA1M_A
;
9825 digest
[1] -= SHA1M_B
;
9826 digest
[2] -= SHA1M_C
;
9827 digest
[3] -= SHA1M_D
;
9828 digest
[4] -= SHA1M_E
;
9832 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9834 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9836 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9838 salt
->salt_len
= salt_len
;
9843 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9845 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9847 u64
*digest
= (u64
*) hash_buf
->digest
;
9849 salt_t
*salt
= hash_buf
->salt
;
9851 char *hash_pos
= input_buf
+ 8;
9853 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9854 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9855 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9856 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9857 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9858 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9859 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9860 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9862 digest
[0] -= SHA512M_A
;
9863 digest
[1] -= SHA512M_B
;
9864 digest
[2] -= SHA512M_C
;
9865 digest
[3] -= SHA512M_D
;
9866 digest
[4] -= SHA512M_E
;
9867 digest
[5] -= SHA512M_F
;
9868 digest
[6] -= SHA512M_G
;
9869 digest
[7] -= SHA512M_H
;
9873 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9875 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9877 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9879 salt
->salt_len
= salt_len
;
9884 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9886 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9888 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9892 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9895 u32
*digest
= (u32
*) hash_buf
->digest
;
9897 salt_t
*salt
= hash_buf
->salt
;
9899 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9900 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9901 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9902 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9904 digest
[0] = byte_swap_32 (digest
[0]);
9905 digest
[1] = byte_swap_32 (digest
[1]);
9906 digest
[2] = byte_swap_32 (digest
[2]);
9907 digest
[3] = byte_swap_32 (digest
[3]);
9909 digest
[0] -= MD5M_A
;
9910 digest
[1] -= MD5M_B
;
9911 digest
[2] -= MD5M_C
;
9912 digest
[3] -= MD5M_D
;
9914 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9916 uint salt_len
= input_len
- 32 - 1;
9918 char *salt_buf
= input_buf
+ 32 + 1;
9920 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9922 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9924 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9926 salt
->salt_len
= salt_len
;
9931 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9933 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9935 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9939 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9944 char clean_input_buf
[32] = { 0 };
9946 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9947 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9949 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9953 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9959 clean_input_buf
[k
] = input_buf
[i
];
9967 u32
*digest
= (u32
*) hash_buf
->digest
;
9969 salt_t
*salt
= hash_buf
->salt
;
9971 u32 a
, b
, c
, d
, e
, f
;
9973 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9974 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9975 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9976 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9977 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9978 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9980 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9981 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9983 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9984 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9985 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9986 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9987 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9988 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9990 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9991 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9993 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9994 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9995 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9996 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9997 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9998 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10000 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10001 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10003 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10004 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10005 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10006 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10007 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10008 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10010 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10011 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10013 digest
[0] = byte_swap_32 (digest
[0]);
10014 digest
[1] = byte_swap_32 (digest
[1]);
10015 digest
[2] = byte_swap_32 (digest
[2]);
10016 digest
[3] = byte_swap_32 (digest
[3]);
10018 digest
[0] -= MD5M_A
;
10019 digest
[1] -= MD5M_B
;
10020 digest
[2] -= MD5M_C
;
10021 digest
[3] -= MD5M_D
;
10023 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10025 uint salt_len
= input_len
- 30 - 1;
10027 char *salt_buf
= input_buf
+ 30 + 1;
10029 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10031 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10033 // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
10034 if (salt_len
> 10) return (PARSER_SALT_LENGTH
);
10036 salt
->salt_len
= salt_len
;
10038 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10040 salt
->salt_len
+= 22;
10042 return (PARSER_OK
);
10045 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10047 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10049 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10053 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10056 u32
*digest
= (u32
*) hash_buf
->digest
;
10058 salt_t
*salt
= hash_buf
->salt
;
10060 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10061 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10062 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10063 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10064 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10066 digest
[0] -= SHA1M_A
;
10067 digest
[1] -= SHA1M_B
;
10068 digest
[2] -= SHA1M_C
;
10069 digest
[3] -= SHA1M_D
;
10070 digest
[4] -= SHA1M_E
;
10072 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10074 uint salt_len
= input_len
- 40 - 1;
10076 char *salt_buf
= input_buf
+ 40 + 1;
10078 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10080 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10082 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10084 salt
->salt_len
= salt_len
;
10086 return (PARSER_OK
);
10089 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10091 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10093 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10097 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10100 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10102 char *iter_pos
= input_buf
+ 6;
10104 salt_t
*salt
= hash_buf
->salt
;
10106 uint iter
= atoi (iter_pos
);
10110 iter
= ROUNDS_DCC2
;
10113 salt
->salt_iter
= iter
- 1;
10115 char *salt_pos
= strchr (iter_pos
, '#');
10117 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10121 char *digest_pos
= strchr (salt_pos
, '#');
10123 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10127 uint salt_len
= digest_pos
- salt_pos
- 1;
10129 u32
*digest
= (u32
*) hash_buf
->digest
;
10131 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10132 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10133 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10134 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10136 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10138 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10140 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10142 salt
->salt_len
= salt_len
;
10144 return (PARSER_OK
);
10147 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10149 u32
*digest
= (u32
*) hash_buf
->digest
;
10151 salt_t
*salt
= hash_buf
->salt
;
10153 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10157 memcpy (&in
, input_buf
, input_len
);
10159 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10161 memcpy (digest
, in
.keymic
, 16);
10164 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10165 The phrase "Pairwise key expansion"
10166 Access Point Address (referred to as Authenticator Address AA)
10167 Supplicant Address (referred to as Supplicant Address SA)
10168 Access Point Nonce (referred to as Authenticator Anonce)
10169 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10172 uint salt_len
= strlen (in
.essid
);
10174 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10176 salt
->salt_len
= salt_len
;
10178 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10180 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10182 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10184 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10186 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10187 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10191 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10192 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10195 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10197 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10198 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10202 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10203 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10206 for (int i
= 0; i
< 25; i
++)
10208 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10211 wpa
->keyver
= in
.keyver
;
10213 if (wpa
->keyver
> 255)
10215 log_info ("ATTENTION!");
10216 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10217 log_info (" This could be due to a recent aircrack-ng bug.");
10218 log_info (" The key version was automatically reset to a reasonable value.");
10221 wpa
->keyver
&= 0xff;
10224 wpa
->eapol_size
= in
.eapol_size
;
10226 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10228 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10230 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10232 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10234 if (wpa
->keyver
== 1)
10240 digest
[0] = byte_swap_32 (digest
[0]);
10241 digest
[1] = byte_swap_32 (digest
[1]);
10242 digest
[2] = byte_swap_32 (digest
[2]);
10243 digest
[3] = byte_swap_32 (digest
[3]);
10245 for (int i
= 0; i
< 64; i
++)
10247 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10251 salt
->salt_buf
[10] = digest
[1];
10252 salt
->salt_buf
[11] = digest
[2];
10254 return (PARSER_OK
);
10257 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10259 u32
*digest
= (u32
*) hash_buf
->digest
;
10261 salt_t
*salt
= hash_buf
->salt
;
10263 if (input_len
== 0)
10265 log_error ("Password Safe v2 container not specified");
10270 FILE *fp
= fopen (input_buf
, "rb");
10274 log_error ("%s: %s", input_buf
, strerror (errno
));
10281 memset (&buf
, 0, sizeof (psafe2_hdr
));
10283 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10287 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10289 salt
->salt_buf
[0] = buf
.random
[0];
10290 salt
->salt_buf
[1] = buf
.random
[1];
10292 salt
->salt_len
= 8;
10293 salt
->salt_iter
= 1000;
10295 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10296 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10297 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10298 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10299 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10301 return (PARSER_OK
);
10304 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10306 u32
*digest
= (u32
*) hash_buf
->digest
;
10308 salt_t
*salt
= hash_buf
->salt
;
10310 if (input_len
== 0)
10312 log_error (".psafe3 not specified");
10317 FILE *fp
= fopen (input_buf
, "rb");
10321 log_error ("%s: %s", input_buf
, strerror (errno
));
10328 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10332 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10334 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10336 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10338 salt
->salt_iter
= in
.iterations
+ 1;
10340 salt
->salt_buf
[0] = in
.salt_buf
[0];
10341 salt
->salt_buf
[1] = in
.salt_buf
[1];
10342 salt
->salt_buf
[2] = in
.salt_buf
[2];
10343 salt
->salt_buf
[3] = in
.salt_buf
[3];
10344 salt
->salt_buf
[4] = in
.salt_buf
[4];
10345 salt
->salt_buf
[5] = in
.salt_buf
[5];
10346 salt
->salt_buf
[6] = in
.salt_buf
[6];
10347 salt
->salt_buf
[7] = in
.salt_buf
[7];
10349 salt
->salt_len
= 32;
10351 digest
[0] = in
.hash_buf
[0];
10352 digest
[1] = in
.hash_buf
[1];
10353 digest
[2] = in
.hash_buf
[2];
10354 digest
[3] = in
.hash_buf
[3];
10355 digest
[4] = in
.hash_buf
[4];
10356 digest
[5] = in
.hash_buf
[5];
10357 digest
[6] = in
.hash_buf
[6];
10358 digest
[7] = in
.hash_buf
[7];
10360 digest
[0] = byte_swap_32 (digest
[0]);
10361 digest
[1] = byte_swap_32 (digest
[1]);
10362 digest
[2] = byte_swap_32 (digest
[2]);
10363 digest
[3] = byte_swap_32 (digest
[3]);
10364 digest
[4] = byte_swap_32 (digest
[4]);
10365 digest
[5] = byte_swap_32 (digest
[5]);
10366 digest
[6] = byte_swap_32 (digest
[6]);
10367 digest
[7] = byte_swap_32 (digest
[7]);
10369 return (PARSER_OK
);
10372 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10374 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10376 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10378 u32
*digest
= (u32
*) hash_buf
->digest
;
10380 salt_t
*salt
= hash_buf
->salt
;
10382 char *iter_pos
= input_buf
+ 3;
10384 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10386 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10388 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10390 salt
->salt_iter
= salt_iter
;
10392 char *salt_pos
= iter_pos
+ 1;
10396 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10398 salt
->salt_len
= salt_len
;
10400 char *hash_pos
= salt_pos
+ salt_len
;
10402 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10404 return (PARSER_OK
);
10407 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10409 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10411 u32
*digest
= (u32
*) hash_buf
->digest
;
10413 salt_t
*salt
= hash_buf
->salt
;
10415 char *salt_pos
= input_buf
+ 3;
10417 uint iterations_len
= 0;
10419 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10423 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10425 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10426 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10430 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10434 iterations_len
+= 8;
10438 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10441 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10443 char *hash_pos
= strchr (salt_pos
, '$');
10445 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10447 uint salt_len
= hash_pos
- salt_pos
;
10449 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10451 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10453 salt
->salt_len
= salt_len
;
10457 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10459 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10461 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10463 return (PARSER_OK
);
10466 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10468 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10470 u32
*digest
= (u32
*) hash_buf
->digest
;
10472 salt_t
*salt
= hash_buf
->salt
;
10474 char *salt_pos
= input_buf
+ 6;
10476 uint iterations_len
= 0;
10478 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10482 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10484 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10485 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10489 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10493 iterations_len
+= 8;
10497 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10500 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10502 char *hash_pos
= strchr (salt_pos
, '$');
10504 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10506 uint salt_len
= hash_pos
- salt_pos
;
10508 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10510 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10512 salt
->salt_len
= salt_len
;
10516 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10518 return (PARSER_OK
);
10521 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10523 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10525 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10527 u32
*digest
= (u32
*) hash_buf
->digest
;
10529 salt_t
*salt
= hash_buf
->salt
;
10531 char *salt_pos
= input_buf
+ 14;
10533 char *hash_pos
= strchr (salt_pos
, '*');
10535 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10539 uint salt_len
= hash_pos
- salt_pos
- 1;
10541 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10543 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10545 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10547 salt
->salt_len
= salt_len
;
10549 u8 tmp_buf
[100] = { 0 };
10551 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10553 memcpy (digest
, tmp_buf
, 20);
10555 digest
[0] = byte_swap_32 (digest
[0]);
10556 digest
[1] = byte_swap_32 (digest
[1]);
10557 digest
[2] = byte_swap_32 (digest
[2]);
10558 digest
[3] = byte_swap_32 (digest
[3]);
10559 digest
[4] = byte_swap_32 (digest
[4]);
10561 digest
[0] -= SHA1M_A
;
10562 digest
[1] -= SHA1M_B
;
10563 digest
[2] -= SHA1M_C
;
10564 digest
[3] -= SHA1M_D
;
10565 digest
[4] -= SHA1M_E
;
10567 return (PARSER_OK
);
10570 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10572 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10574 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10576 if (c12
& 3) return (PARSER_HASH_VALUE
);
10578 u32
*digest
= (u32
*) hash_buf
->digest
;
10580 salt_t
*salt
= hash_buf
->salt
;
10582 // for ascii_digest
10583 salt
->salt_sign
[0] = input_buf
[0];
10584 salt
->salt_sign
[1] = input_buf
[1];
10586 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10587 | itoa64_to_int (input_buf
[1]) << 6;
10589 salt
->salt_len
= 2;
10591 u8 tmp_buf
[100] = { 0 };
10593 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10595 memcpy (digest
, tmp_buf
, 8);
10599 IP (digest
[0], digest
[1], tt
);
10604 return (PARSER_OK
);
10607 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10609 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10611 u32
*digest
= (u32
*) hash_buf
->digest
;
10613 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10614 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10615 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10616 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10618 digest
[0] = byte_swap_32 (digest
[0]);
10619 digest
[1] = byte_swap_32 (digest
[1]);
10620 digest
[2] = byte_swap_32 (digest
[2]);
10621 digest
[3] = byte_swap_32 (digest
[3]);
10623 digest
[0] -= MD4M_A
;
10624 digest
[1] -= MD4M_B
;
10625 digest
[2] -= MD4M_C
;
10626 digest
[3] -= MD4M_D
;
10628 return (PARSER_OK
);
10631 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10633 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10635 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10639 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10642 u32
*digest
= (u32
*) hash_buf
->digest
;
10644 salt_t
*salt
= hash_buf
->salt
;
10646 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10647 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10648 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10649 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10651 digest
[0] = byte_swap_32 (digest
[0]);
10652 digest
[1] = byte_swap_32 (digest
[1]);
10653 digest
[2] = byte_swap_32 (digest
[2]);
10654 digest
[3] = byte_swap_32 (digest
[3]);
10656 digest
[0] -= MD4M_A
;
10657 digest
[1] -= MD4M_B
;
10658 digest
[2] -= MD4M_C
;
10659 digest
[3] -= MD4M_D
;
10661 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10663 uint salt_len
= input_len
- 32 - 1;
10665 char *salt_buf
= input_buf
+ 32 + 1;
10667 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10669 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10671 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10673 salt
->salt_len
= salt_len
;
10675 return (PARSER_OK
);
10678 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10680 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10682 u32
*digest
= (u32
*) hash_buf
->digest
;
10684 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10685 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10686 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10687 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10689 digest
[0] = byte_swap_32 (digest
[0]);
10690 digest
[1] = byte_swap_32 (digest
[1]);
10691 digest
[2] = byte_swap_32 (digest
[2]);
10692 digest
[3] = byte_swap_32 (digest
[3]);
10694 digest
[0] -= MD5M_A
;
10695 digest
[1] -= MD5M_B
;
10696 digest
[2] -= MD5M_C
;
10697 digest
[3] -= MD5M_D
;
10699 return (PARSER_OK
);
10702 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10704 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10706 u32
*digest
= (u32
*) hash_buf
->digest
;
10708 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10709 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10713 digest
[0] = byte_swap_32 (digest
[0]);
10714 digest
[1] = byte_swap_32 (digest
[1]);
10716 return (PARSER_OK
);
10719 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10721 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10723 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10727 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10730 u32
*digest
= (u32
*) hash_buf
->digest
;
10732 salt_t
*salt
= hash_buf
->salt
;
10734 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10735 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10736 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10737 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10739 digest
[0] = byte_swap_32 (digest
[0]);
10740 digest
[1] = byte_swap_32 (digest
[1]);
10741 digest
[2] = byte_swap_32 (digest
[2]);
10742 digest
[3] = byte_swap_32 (digest
[3]);
10744 digest
[0] -= MD5M_A
;
10745 digest
[1] -= MD5M_B
;
10746 digest
[2] -= MD5M_C
;
10747 digest
[3] -= MD5M_D
;
10749 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10751 uint salt_len
= input_len
- 32 - 1;
10753 char *salt_buf
= input_buf
+ 32 + 1;
10755 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10757 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10759 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10761 salt
->salt_len
= salt_len
;
10763 return (PARSER_OK
);
10766 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10768 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10770 u32
*digest
= (u32
*) hash_buf
->digest
;
10772 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10773 | itoa64_to_int (input_buf
[ 1]) << 6
10774 | itoa64_to_int (input_buf
[ 2]) << 12
10775 | itoa64_to_int (input_buf
[ 3]) << 18;
10776 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10777 | itoa64_to_int (input_buf
[ 5]) << 6
10778 | itoa64_to_int (input_buf
[ 6]) << 12
10779 | itoa64_to_int (input_buf
[ 7]) << 18;
10780 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10781 | itoa64_to_int (input_buf
[ 9]) << 6
10782 | itoa64_to_int (input_buf
[10]) << 12
10783 | itoa64_to_int (input_buf
[11]) << 18;
10784 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10785 | itoa64_to_int (input_buf
[13]) << 6
10786 | itoa64_to_int (input_buf
[14]) << 12
10787 | itoa64_to_int (input_buf
[15]) << 18;
10789 digest
[0] -= MD5M_A
;
10790 digest
[1] -= MD5M_B
;
10791 digest
[2] -= MD5M_C
;
10792 digest
[3] -= MD5M_D
;
10794 digest
[0] &= 0x00ffffff;
10795 digest
[1] &= 0x00ffffff;
10796 digest
[2] &= 0x00ffffff;
10797 digest
[3] &= 0x00ffffff;
10799 return (PARSER_OK
);
10802 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10804 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10806 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10810 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10813 u32
*digest
= (u32
*) hash_buf
->digest
;
10815 salt_t
*salt
= hash_buf
->salt
;
10817 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10818 | itoa64_to_int (input_buf
[ 1]) << 6
10819 | itoa64_to_int (input_buf
[ 2]) << 12
10820 | itoa64_to_int (input_buf
[ 3]) << 18;
10821 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10822 | itoa64_to_int (input_buf
[ 5]) << 6
10823 | itoa64_to_int (input_buf
[ 6]) << 12
10824 | itoa64_to_int (input_buf
[ 7]) << 18;
10825 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10826 | itoa64_to_int (input_buf
[ 9]) << 6
10827 | itoa64_to_int (input_buf
[10]) << 12
10828 | itoa64_to_int (input_buf
[11]) << 18;
10829 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10830 | itoa64_to_int (input_buf
[13]) << 6
10831 | itoa64_to_int (input_buf
[14]) << 12
10832 | itoa64_to_int (input_buf
[15]) << 18;
10834 digest
[0] -= MD5M_A
;
10835 digest
[1] -= MD5M_B
;
10836 digest
[2] -= MD5M_C
;
10837 digest
[3] -= MD5M_D
;
10839 digest
[0] &= 0x00ffffff;
10840 digest
[1] &= 0x00ffffff;
10841 digest
[2] &= 0x00ffffff;
10842 digest
[3] &= 0x00ffffff;
10844 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10846 uint salt_len
= input_len
- 16 - 1;
10848 char *salt_buf
= input_buf
+ 16 + 1;
10850 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10852 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10854 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10856 salt
->salt_len
= salt_len
;
10858 return (PARSER_OK
);
10861 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10863 key
[0] = (nthash
[0] >> 0);
10864 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10865 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10866 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10867 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10868 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10869 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10870 key
[7] = (nthash
[6] << 1);
10882 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10884 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10886 u32
*digest
= (u32
*) hash_buf
->digest
;
10888 salt_t
*salt
= hash_buf
->salt
;
10890 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10896 char *user_pos
= input_buf
;
10898 char *unused_pos
= strchr (user_pos
, ':');
10900 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10902 uint user_len
= unused_pos
- user_pos
;
10904 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10908 char *domain_pos
= strchr (unused_pos
, ':');
10910 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10912 uint unused_len
= domain_pos
- unused_pos
;
10914 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10918 char *srvchall_pos
= strchr (domain_pos
, ':');
10920 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10922 uint domain_len
= srvchall_pos
- domain_pos
;
10924 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10928 char *hash_pos
= strchr (srvchall_pos
, ':');
10930 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10932 uint srvchall_len
= hash_pos
- srvchall_pos
;
10934 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10938 char *clichall_pos
= strchr (hash_pos
, ':');
10940 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10942 uint hash_len
= clichall_pos
- hash_pos
;
10944 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10948 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10950 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10953 * store some data for later use
10956 netntlm
->user_len
= user_len
* 2;
10957 netntlm
->domain_len
= domain_len
* 2;
10958 netntlm
->srvchall_len
= srvchall_len
/ 2;
10959 netntlm
->clichall_len
= clichall_len
/ 2;
10961 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10962 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10965 * handle username and domainname
10968 for (uint i
= 0; i
< user_len
; i
++)
10970 *userdomain_ptr
++ = user_pos
[i
];
10971 *userdomain_ptr
++ = 0;
10974 for (uint i
= 0; i
< domain_len
; i
++)
10976 *userdomain_ptr
++ = domain_pos
[i
];
10977 *userdomain_ptr
++ = 0;
10981 * handle server challenge encoding
10984 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10986 const char p0
= srvchall_pos
[i
+ 0];
10987 const char p1
= srvchall_pos
[i
+ 1];
10989 *chall_ptr
++ = hex_convert (p1
) << 0
10990 | hex_convert (p0
) << 4;
10994 * handle client challenge encoding
10997 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10999 const char p0
= clichall_pos
[i
+ 0];
11000 const char p1
= clichall_pos
[i
+ 1];
11002 *chall_ptr
++ = hex_convert (p1
) << 0
11003 | hex_convert (p0
) << 4;
11010 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11012 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11014 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11016 salt
->salt_len
= salt_len
;
11018 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11019 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11020 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11021 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11023 digest
[0] = byte_swap_32 (digest
[0]);
11024 digest
[1] = byte_swap_32 (digest
[1]);
11025 digest
[2] = byte_swap_32 (digest
[2]);
11026 digest
[3] = byte_swap_32 (digest
[3]);
11028 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11030 uint digest_tmp
[2] = { 0 };
11032 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11033 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11035 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11036 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11038 /* special case 2: ESS */
11040 if (srvchall_len
== 48)
11042 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11044 uint w
[16] = { 0 };
11046 w
[ 0] = netntlm
->chall_buf
[6];
11047 w
[ 1] = netntlm
->chall_buf
[7];
11048 w
[ 2] = netntlm
->chall_buf
[0];
11049 w
[ 3] = netntlm
->chall_buf
[1];
11053 uint dgst
[4] = { 0 };
11062 salt
->salt_buf
[0] = dgst
[0];
11063 salt
->salt_buf
[1] = dgst
[1];
11067 /* precompute netntlmv1 exploit start */
11069 for (uint i
= 0; i
< 0x10000; i
++)
11071 uint key_md4
[2] = { i
, 0 };
11072 uint key_des
[2] = { 0, 0 };
11074 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11076 uint Kc
[16] = { 0 };
11077 uint Kd
[16] = { 0 };
11079 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11081 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11083 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11085 if (data3
[0] != digest_tmp
[0]) continue;
11086 if (data3
[1] != digest_tmp
[1]) continue;
11088 salt
->salt_buf
[2] = i
;
11090 salt
->salt_len
= 24;
11095 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11096 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11098 /* precompute netntlmv1 exploit stop */
11102 IP (digest
[0], digest
[1], tt
);
11103 IP (digest
[2], digest
[3], tt
);
11105 digest
[0] = rotr32 (digest
[0], 29);
11106 digest
[1] = rotr32 (digest
[1], 29);
11107 digest
[2] = rotr32 (digest
[2], 29);
11108 digest
[3] = rotr32 (digest
[3], 29);
11110 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11112 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11113 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11115 return (PARSER_OK
);
11118 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11120 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11122 u32
*digest
= (u32
*) hash_buf
->digest
;
11124 salt_t
*salt
= hash_buf
->salt
;
11126 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11132 char *user_pos
= input_buf
;
11134 char *unused_pos
= strchr (user_pos
, ':');
11136 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11138 uint user_len
= unused_pos
- user_pos
;
11140 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11144 char *domain_pos
= strchr (unused_pos
, ':');
11146 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11148 uint unused_len
= domain_pos
- unused_pos
;
11150 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11154 char *srvchall_pos
= strchr (domain_pos
, ':');
11156 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11158 uint domain_len
= srvchall_pos
- domain_pos
;
11160 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11164 char *hash_pos
= strchr (srvchall_pos
, ':');
11166 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11168 uint srvchall_len
= hash_pos
- srvchall_pos
;
11170 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11174 char *clichall_pos
= strchr (hash_pos
, ':');
11176 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11178 uint hash_len
= clichall_pos
- hash_pos
;
11180 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11184 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11186 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11188 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11191 * store some data for later use
11194 netntlm
->user_len
= user_len
* 2;
11195 netntlm
->domain_len
= domain_len
* 2;
11196 netntlm
->srvchall_len
= srvchall_len
/ 2;
11197 netntlm
->clichall_len
= clichall_len
/ 2;
11199 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11200 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11203 * handle username and domainname
11206 for (uint i
= 0; i
< user_len
; i
++)
11208 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11209 *userdomain_ptr
++ = 0;
11212 for (uint i
= 0; i
< domain_len
; i
++)
11214 *userdomain_ptr
++ = domain_pos
[i
];
11215 *userdomain_ptr
++ = 0;
11218 *userdomain_ptr
++ = 0x80;
11221 * handle server challenge encoding
11224 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11226 const char p0
= srvchall_pos
[i
+ 0];
11227 const char p1
= srvchall_pos
[i
+ 1];
11229 *chall_ptr
++ = hex_convert (p1
) << 0
11230 | hex_convert (p0
) << 4;
11234 * handle client challenge encoding
11237 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11239 const char p0
= clichall_pos
[i
+ 0];
11240 const char p1
= clichall_pos
[i
+ 1];
11242 *chall_ptr
++ = hex_convert (p1
) << 0
11243 | hex_convert (p0
) << 4;
11246 *chall_ptr
++ = 0x80;
11249 * handle hash itself
11252 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11253 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11254 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11255 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11257 digest
[0] = byte_swap_32 (digest
[0]);
11258 digest
[1] = byte_swap_32 (digest
[1]);
11259 digest
[2] = byte_swap_32 (digest
[2]);
11260 digest
[3] = byte_swap_32 (digest
[3]);
11263 * reuse challange data as salt_buf, its the buffer that is most likely unique
11266 salt
->salt_buf
[0] = 0;
11267 salt
->salt_buf
[1] = 0;
11268 salt
->salt_buf
[2] = 0;
11269 salt
->salt_buf
[3] = 0;
11270 salt
->salt_buf
[4] = 0;
11271 salt
->salt_buf
[5] = 0;
11272 salt
->salt_buf
[6] = 0;
11273 salt
->salt_buf
[7] = 0;
11277 uptr
= (uint
*) netntlm
->userdomain_buf
;
11279 for (uint i
= 0; i
< 16; i
+= 16)
11281 md5_64 (uptr
, salt
->salt_buf
);
11284 uptr
= (uint
*) netntlm
->chall_buf
;
11286 for (uint i
= 0; i
< 256; i
+= 16)
11288 md5_64 (uptr
, salt
->salt_buf
);
11291 salt
->salt_len
= 16;
11293 return (PARSER_OK
);
11296 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11298 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11300 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11304 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11307 u32
*digest
= (u32
*) hash_buf
->digest
;
11309 salt_t
*salt
= hash_buf
->salt
;
11311 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11312 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11313 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11314 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11316 digest
[0] = byte_swap_32 (digest
[0]);
11317 digest
[1] = byte_swap_32 (digest
[1]);
11318 digest
[2] = byte_swap_32 (digest
[2]);
11319 digest
[3] = byte_swap_32 (digest
[3]);
11321 digest
[0] -= MD5M_A
;
11322 digest
[1] -= MD5M_B
;
11323 digest
[2] -= MD5M_C
;
11324 digest
[3] -= MD5M_D
;
11326 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11328 uint salt_len
= input_len
- 32 - 1;
11330 char *salt_buf
= input_buf
+ 32 + 1;
11332 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11334 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11336 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11338 salt
->salt_len
= salt_len
;
11340 return (PARSER_OK
);
11343 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11345 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11347 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11351 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11354 u32
*digest
= (u32
*) hash_buf
->digest
;
11356 salt_t
*salt
= hash_buf
->salt
;
11358 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11359 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11360 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11361 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11363 digest
[0] = byte_swap_32 (digest
[0]);
11364 digest
[1] = byte_swap_32 (digest
[1]);
11365 digest
[2] = byte_swap_32 (digest
[2]);
11366 digest
[3] = byte_swap_32 (digest
[3]);
11368 digest
[0] -= MD5M_A
;
11369 digest
[1] -= MD5M_B
;
11370 digest
[2] -= MD5M_C
;
11371 digest
[3] -= MD5M_D
;
11373 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11375 uint salt_len
= input_len
- 32 - 1;
11377 char *salt_buf
= input_buf
+ 32 + 1;
11379 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11381 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11383 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11385 salt
->salt_len
= salt_len
;
11387 return (PARSER_OK
);
11390 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11392 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11394 u32
*digest
= (u32
*) hash_buf
->digest
;
11396 salt_t
*salt
= hash_buf
->salt
;
11398 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11399 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11400 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11401 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11403 digest
[0] = byte_swap_32 (digest
[0]);
11404 digest
[1] = byte_swap_32 (digest
[1]);
11405 digest
[2] = byte_swap_32 (digest
[2]);
11406 digest
[3] = byte_swap_32 (digest
[3]);
11408 digest
[0] -= MD5M_A
;
11409 digest
[1] -= MD5M_B
;
11410 digest
[2] -= MD5M_C
;
11411 digest
[3] -= MD5M_D
;
11414 * This is a virtual salt. While the algorithm is basically not salted
11415 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11416 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11419 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11421 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11423 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11425 salt
->salt_len
= salt_len
;
11427 return (PARSER_OK
);
11430 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11432 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11434 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11438 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11441 u32
*digest
= (u32
*) hash_buf
->digest
;
11443 salt_t
*salt
= hash_buf
->salt
;
11445 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11446 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11447 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11448 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11450 digest
[0] = byte_swap_32 (digest
[0]);
11451 digest
[1] = byte_swap_32 (digest
[1]);
11452 digest
[2] = byte_swap_32 (digest
[2]);
11453 digest
[3] = byte_swap_32 (digest
[3]);
11455 digest
[0] -= MD5M_A
;
11456 digest
[1] -= MD5M_B
;
11457 digest
[2] -= MD5M_C
;
11458 digest
[3] -= MD5M_D
;
11460 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11462 uint salt_len
= input_len
- 32 - 1;
11464 char *salt_buf
= input_buf
+ 32 + 1;
11466 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11468 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11470 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11472 salt
->salt_len
= salt_len
;
11474 return (PARSER_OK
);
11477 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11479 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11481 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11485 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11488 u32
*digest
= (u32
*) hash_buf
->digest
;
11490 salt_t
*salt
= hash_buf
->salt
;
11492 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11493 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11494 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11495 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11497 digest
[0] = byte_swap_32 (digest
[0]);
11498 digest
[1] = byte_swap_32 (digest
[1]);
11499 digest
[2] = byte_swap_32 (digest
[2]);
11500 digest
[3] = byte_swap_32 (digest
[3]);
11502 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11504 uint salt_len
= input_len
- 32 - 1;
11506 char *salt_buf
= input_buf
+ 32 + 1;
11508 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11510 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11512 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11514 salt
->salt_len
= salt_len
;
11516 return (PARSER_OK
);
11519 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11521 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11523 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11527 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11530 u32
*digest
= (u32
*) hash_buf
->digest
;
11532 salt_t
*salt
= hash_buf
->salt
;
11534 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11535 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11536 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11537 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11539 digest
[0] = byte_swap_32 (digest
[0]);
11540 digest
[1] = byte_swap_32 (digest
[1]);
11541 digest
[2] = byte_swap_32 (digest
[2]);
11542 digest
[3] = byte_swap_32 (digest
[3]);
11544 digest
[0] -= MD4M_A
;
11545 digest
[1] -= MD4M_B
;
11546 digest
[2] -= MD4M_C
;
11547 digest
[3] -= MD4M_D
;
11549 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11551 uint salt_len
= input_len
- 32 - 1;
11553 char *salt_buf
= input_buf
+ 32 + 1;
11555 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11557 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11559 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11561 salt
->salt_len
= salt_len
;
11563 return (PARSER_OK
);
11566 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11568 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11570 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11574 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11577 u32
*digest
= (u32
*) hash_buf
->digest
;
11579 salt_t
*salt
= hash_buf
->salt
;
11581 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11582 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11583 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11584 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11586 digest
[0] = byte_swap_32 (digest
[0]);
11587 digest
[1] = byte_swap_32 (digest
[1]);
11588 digest
[2] = byte_swap_32 (digest
[2]);
11589 digest
[3] = byte_swap_32 (digest
[3]);
11591 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11593 uint salt_len
= input_len
- 32 - 1;
11595 char *salt_buf
= input_buf
+ 32 + 1;
11597 uint salt_pc_block
[16] = { 0 };
11599 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11601 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11603 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11605 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11607 salt_pc_block
[14] = salt_len
* 8;
11609 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11611 md5_64 (salt_pc_block
, salt_pc_digest
);
11613 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11614 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11615 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11616 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11618 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11620 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11622 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11624 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11625 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11626 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11627 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11629 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11631 return (PARSER_OK
);
11634 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11636 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11638 u32
*digest
= (u32
*) hash_buf
->digest
;
11640 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11641 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11642 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11643 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11644 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11646 digest
[0] -= SHA1M_A
;
11647 digest
[1] -= SHA1M_B
;
11648 digest
[2] -= SHA1M_C
;
11649 digest
[3] -= SHA1M_D
;
11650 digest
[4] -= SHA1M_E
;
11652 return (PARSER_OK
);
11655 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11657 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11659 u32
*digest
= (u32
*) hash_buf
->digest
;
11661 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11662 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11663 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11664 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11665 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11667 return (PARSER_OK
);
11670 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11672 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11674 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11678 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11681 u32
*digest
= (u32
*) hash_buf
->digest
;
11683 salt_t
*salt
= hash_buf
->salt
;
11685 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11686 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11687 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11688 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11689 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11691 digest
[0] -= SHA1M_A
;
11692 digest
[1] -= SHA1M_B
;
11693 digest
[2] -= SHA1M_C
;
11694 digest
[3] -= SHA1M_D
;
11695 digest
[4] -= SHA1M_E
;
11697 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11699 uint salt_len
= input_len
- 40 - 1;
11701 char *salt_buf
= input_buf
+ 40 + 1;
11703 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11705 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11707 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11709 salt
->salt_len
= salt_len
;
11711 return (PARSER_OK
);
11714 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11716 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11718 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11720 u32
*digest
= (u32
*) hash_buf
->digest
;
11722 u8 tmp_buf
[100] = { 0 };
11724 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11726 memcpy (digest
, tmp_buf
, 20);
11728 digest
[0] = byte_swap_32 (digest
[0]);
11729 digest
[1] = byte_swap_32 (digest
[1]);
11730 digest
[2] = byte_swap_32 (digest
[2]);
11731 digest
[3] = byte_swap_32 (digest
[3]);
11732 digest
[4] = byte_swap_32 (digest
[4]);
11734 digest
[0] -= SHA1M_A
;
11735 digest
[1] -= SHA1M_B
;
11736 digest
[2] -= SHA1M_C
;
11737 digest
[3] -= SHA1M_D
;
11738 digest
[4] -= SHA1M_E
;
11740 return (PARSER_OK
);
11743 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11745 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11747 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11749 u32
*digest
= (u32
*) hash_buf
->digest
;
11751 salt_t
*salt
= hash_buf
->salt
;
11753 u8 tmp_buf
[100] = { 0 };
11755 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11757 memcpy (digest
, tmp_buf
, 20);
11759 salt
->salt_len
= tmp_len
- 20;
11761 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11763 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11765 char *ptr
= (char *) salt
->salt_buf
;
11767 ptr
[salt
->salt_len
] = 0x80;
11770 digest
[0] = byte_swap_32 (digest
[0]);
11771 digest
[1] = byte_swap_32 (digest
[1]);
11772 digest
[2] = byte_swap_32 (digest
[2]);
11773 digest
[3] = byte_swap_32 (digest
[3]);
11774 digest
[4] = byte_swap_32 (digest
[4]);
11776 digest
[0] -= SHA1M_A
;
11777 digest
[1] -= SHA1M_B
;
11778 digest
[2] -= SHA1M_C
;
11779 digest
[3] -= SHA1M_D
;
11780 digest
[4] -= SHA1M_E
;
11782 return (PARSER_OK
);
11785 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11787 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11789 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11791 u32
*digest
= (u32
*) hash_buf
->digest
;
11793 salt_t
*salt
= hash_buf
->salt
;
11795 char *salt_buf
= input_buf
+ 6;
11799 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11801 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11803 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11805 salt
->salt_len
= salt_len
;
11807 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11809 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11810 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11811 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11812 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11813 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11815 digest
[0] -= SHA1M_A
;
11816 digest
[1] -= SHA1M_B
;
11817 digest
[2] -= SHA1M_C
;
11818 digest
[3] -= SHA1M_D
;
11819 digest
[4] -= SHA1M_E
;
11821 return (PARSER_OK
);
11824 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11826 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11828 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11830 u32
*digest
= (u32
*) hash_buf
->digest
;
11832 salt_t
*salt
= hash_buf
->salt
;
11834 char *salt_buf
= input_buf
+ 6;
11838 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11840 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11842 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11844 salt
->salt_len
= salt_len
;
11846 char *hash_pos
= input_buf
+ 6 + 8;
11848 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11849 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11850 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11851 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11852 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11854 digest
[0] -= SHA1M_A
;
11855 digest
[1] -= SHA1M_B
;
11856 digest
[2] -= SHA1M_C
;
11857 digest
[3] -= SHA1M_D
;
11858 digest
[4] -= SHA1M_E
;
11860 return (PARSER_OK
);
11863 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11865 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11867 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11869 u64
*digest
= (u64
*) hash_buf
->digest
;
11871 salt_t
*salt
= hash_buf
->salt
;
11873 char *salt_buf
= input_buf
+ 6;
11877 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11879 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11881 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11883 salt
->salt_len
= salt_len
;
11885 char *hash_pos
= input_buf
+ 6 + 8;
11887 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11888 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11889 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11890 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11891 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11892 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11893 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11894 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11896 digest
[0] -= SHA512M_A
;
11897 digest
[1] -= SHA512M_B
;
11898 digest
[2] -= SHA512M_C
;
11899 digest
[3] -= SHA512M_D
;
11900 digest
[4] -= SHA512M_E
;
11901 digest
[5] -= SHA512M_F
;
11902 digest
[6] -= SHA512M_G
;
11903 digest
[7] -= SHA512M_H
;
11905 return (PARSER_OK
);
11908 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11910 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11912 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11916 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11919 u32
*digest
= (u32
*) hash_buf
->digest
;
11921 salt_t
*salt
= hash_buf
->salt
;
11923 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11924 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11928 digest
[0] = byte_swap_32 (digest
[0]);
11929 digest
[1] = byte_swap_32 (digest
[1]);
11931 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11933 uint salt_len
= input_len
- 16 - 1;
11935 char *salt_buf
= input_buf
+ 16 + 1;
11937 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11939 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11941 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11943 salt
->salt_len
= salt_len
;
11945 return (PARSER_OK
);
11948 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11950 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11952 u32
*digest
= (u32
*) hash_buf
->digest
;
11954 salt_t
*salt
= hash_buf
->salt
;
11956 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11957 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11958 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11959 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11960 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11962 digest
[0] -= SHA1M_A
;
11963 digest
[1] -= SHA1M_B
;
11964 digest
[2] -= SHA1M_C
;
11965 digest
[3] -= SHA1M_D
;
11966 digest
[4] -= SHA1M_E
;
11968 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11970 uint salt_len
= input_len
- 40 - 1;
11972 char *salt_buf
= input_buf
+ 40 + 1;
11974 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11976 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11978 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11980 salt
->salt_len
= salt_len
;
11982 return (PARSER_OK
);
11985 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11987 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11989 u32
*digest
= (u32
*) hash_buf
->digest
;
11991 salt_t
*salt
= hash_buf
->salt
;
11993 char *hash_pos
= input_buf
;
11995 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11996 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11997 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
11998 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
11999 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12000 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12001 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12002 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12003 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12004 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12005 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12006 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12007 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12008 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12009 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12010 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12012 char *salt_pos
= input_buf
+ 128;
12014 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12015 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12016 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12017 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12019 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12020 salt
->salt_len
= 16;
12022 return (PARSER_OK
);
12025 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12027 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12029 u32
*digest
= (u32
*) hash_buf
->digest
;
12031 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12032 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12033 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12034 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12035 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12036 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12037 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12038 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12040 digest
[0] -= SHA256M_A
;
12041 digest
[1] -= SHA256M_B
;
12042 digest
[2] -= SHA256M_C
;
12043 digest
[3] -= SHA256M_D
;
12044 digest
[4] -= SHA256M_E
;
12045 digest
[5] -= SHA256M_F
;
12046 digest
[6] -= SHA256M_G
;
12047 digest
[7] -= SHA256M_H
;
12049 return (PARSER_OK
);
12052 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12054 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12056 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12060 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12063 u32
*digest
= (u32
*) hash_buf
->digest
;
12065 salt_t
*salt
= hash_buf
->salt
;
12067 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12068 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12069 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12070 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12071 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12072 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12073 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12074 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12076 digest
[0] -= SHA256M_A
;
12077 digest
[1] -= SHA256M_B
;
12078 digest
[2] -= SHA256M_C
;
12079 digest
[3] -= SHA256M_D
;
12080 digest
[4] -= SHA256M_E
;
12081 digest
[5] -= SHA256M_F
;
12082 digest
[6] -= SHA256M_G
;
12083 digest
[7] -= SHA256M_H
;
12085 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12087 uint salt_len
= input_len
- 64 - 1;
12089 char *salt_buf
= input_buf
+ 64 + 1;
12091 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12093 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12095 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12097 salt
->salt_len
= salt_len
;
12099 return (PARSER_OK
);
12102 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12104 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12106 u64
*digest
= (u64
*) hash_buf
->digest
;
12108 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12109 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12110 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12111 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12112 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12113 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12117 digest
[0] -= SHA384M_A
;
12118 digest
[1] -= SHA384M_B
;
12119 digest
[2] -= SHA384M_C
;
12120 digest
[3] -= SHA384M_D
;
12121 digest
[4] -= SHA384M_E
;
12122 digest
[5] -= SHA384M_F
;
12126 return (PARSER_OK
);
12129 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12131 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12133 u64
*digest
= (u64
*) hash_buf
->digest
;
12135 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12136 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12137 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12138 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12139 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12140 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12141 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12142 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12144 digest
[0] -= SHA512M_A
;
12145 digest
[1] -= SHA512M_B
;
12146 digest
[2] -= SHA512M_C
;
12147 digest
[3] -= SHA512M_D
;
12148 digest
[4] -= SHA512M_E
;
12149 digest
[5] -= SHA512M_F
;
12150 digest
[6] -= SHA512M_G
;
12151 digest
[7] -= SHA512M_H
;
12153 return (PARSER_OK
);
12156 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12158 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12160 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12164 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12167 u64
*digest
= (u64
*) hash_buf
->digest
;
12169 salt_t
*salt
= hash_buf
->salt
;
12171 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12172 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12173 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12174 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12175 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12176 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12177 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12178 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12180 digest
[0] -= SHA512M_A
;
12181 digest
[1] -= SHA512M_B
;
12182 digest
[2] -= SHA512M_C
;
12183 digest
[3] -= SHA512M_D
;
12184 digest
[4] -= SHA512M_E
;
12185 digest
[5] -= SHA512M_F
;
12186 digest
[6] -= SHA512M_G
;
12187 digest
[7] -= SHA512M_H
;
12189 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12191 uint salt_len
= input_len
- 128 - 1;
12193 char *salt_buf
= input_buf
+ 128 + 1;
12195 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12197 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12199 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12201 salt
->salt_len
= salt_len
;
12203 return (PARSER_OK
);
12206 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12208 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12210 u64
*digest
= (u64
*) hash_buf
->digest
;
12212 salt_t
*salt
= hash_buf
->salt
;
12214 char *salt_pos
= input_buf
+ 3;
12216 uint iterations_len
= 0;
12218 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12222 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12224 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12225 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12229 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12233 iterations_len
+= 8;
12237 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12240 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12242 char *hash_pos
= strchr (salt_pos
, '$');
12244 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12246 uint salt_len
= hash_pos
- salt_pos
;
12248 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12250 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12252 salt
->salt_len
= salt_len
;
12256 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12258 return (PARSER_OK
);
12261 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12263 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12265 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12267 u64
*digest
= (u64
*) hash_buf
->digest
;
12269 salt_t
*salt
= hash_buf
->salt
;
12271 uint keccak_mdlen
= input_len
/ 2;
12273 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12275 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12277 digest
[i
] = byte_swap_64 (digest
[i
]);
12280 salt
->keccak_mdlen
= keccak_mdlen
;
12282 return (PARSER_OK
);
12285 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12287 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12289 u32
*digest
= (u32
*) hash_buf
->digest
;
12291 salt_t
*salt
= hash_buf
->salt
;
12293 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12296 * Parse that strange long line
12301 size_t in_len
[9] = { 0 };
12303 in_off
[0] = strtok (input_buf
, ":");
12305 in_len
[0] = strlen (in_off
[0]);
12309 for (i
= 1; i
< 9; i
++)
12311 in_off
[i
] = strtok (NULL
, ":");
12313 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12315 in_len
[i
] = strlen (in_off
[i
]);
12318 char *ptr
= (char *) ikepsk
->msg_buf
;
12320 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12321 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12322 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12323 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12324 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12325 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12329 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12331 ptr
= (char *) ikepsk
->nr_buf
;
12333 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12334 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12338 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12341 * Store to database
12346 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12347 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12348 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12349 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12351 digest
[0] = byte_swap_32 (digest
[0]);
12352 digest
[1] = byte_swap_32 (digest
[1]);
12353 digest
[2] = byte_swap_32 (digest
[2]);
12354 digest
[3] = byte_swap_32 (digest
[3]);
12356 salt
->salt_len
= 32;
12358 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12359 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12360 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12361 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12362 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12363 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12364 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12365 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12367 return (PARSER_OK
);
12370 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12372 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12374 u32
*digest
= (u32
*) hash_buf
->digest
;
12376 salt_t
*salt
= hash_buf
->salt
;
12378 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12381 * Parse that strange long line
12386 size_t in_len
[9] = { 0 };
12388 in_off
[0] = strtok (input_buf
, ":");
12390 in_len
[0] = strlen (in_off
[0]);
12394 for (i
= 1; i
< 9; i
++)
12396 in_off
[i
] = strtok (NULL
, ":");
12398 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12400 in_len
[i
] = strlen (in_off
[i
]);
12403 char *ptr
= (char *) ikepsk
->msg_buf
;
12405 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12406 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12407 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12408 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12409 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12410 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12414 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12416 ptr
= (char *) ikepsk
->nr_buf
;
12418 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12419 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12423 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12426 * Store to database
12431 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12432 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12433 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12434 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12435 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12437 salt
->salt_len
= 32;
12439 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12440 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12441 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12442 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12443 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12444 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12445 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12446 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12448 return (PARSER_OK
);
12451 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12453 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12455 u32
*digest
= (u32
*) hash_buf
->digest
;
12457 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12458 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12459 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12460 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12461 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12463 digest
[0] = byte_swap_32 (digest
[0]);
12464 digest
[1] = byte_swap_32 (digest
[1]);
12465 digest
[2] = byte_swap_32 (digest
[2]);
12466 digest
[3] = byte_swap_32 (digest
[3]);
12467 digest
[4] = byte_swap_32 (digest
[4]);
12469 return (PARSER_OK
);
12472 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12474 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12476 u32
*digest
= (u32
*) hash_buf
->digest
;
12478 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12479 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12480 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12481 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12482 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12483 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12484 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12485 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12486 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12487 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12488 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12489 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12490 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12491 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12492 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12493 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12495 return (PARSER_OK
);
12498 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12500 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) 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]);
12512 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12514 uint salt_len
= input_len
- 40 - 1;
12516 char *salt_buf
= input_buf
+ 40 + 1;
12518 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12520 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12522 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12524 salt
->salt_len
= salt_len
;
12526 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12528 return (PARSER_OK
);
12531 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12533 u32
*digest
= (u32
*) hash_buf
->digest
;
12535 salt_t
*salt
= hash_buf
->salt
;
12537 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12539 if (input_len
== 0)
12541 log_error ("TrueCrypt container not specified");
12546 FILE *fp
= fopen (input_buf
, "rb");
12550 log_error ("%s: %s", input_buf
, strerror (errno
));
12555 char buf
[512] = { 0 };
12557 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12561 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12563 memcpy (tc
->salt_buf
, buf
, 64);
12565 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12567 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12569 salt
->salt_len
= 4;
12571 salt
->salt_iter
= 1000 - 1;
12573 digest
[0] = tc
->data_buf
[0];
12575 return (PARSER_OK
);
12578 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12580 u32
*digest
= (u32
*) hash_buf
->digest
;
12582 salt_t
*salt
= hash_buf
->salt
;
12584 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12586 if (input_len
== 0)
12588 log_error ("TrueCrypt container not specified");
12593 FILE *fp
= fopen (input_buf
, "rb");
12597 log_error ("%s: %s", input_buf
, strerror (errno
));
12602 char buf
[512] = { 0 };
12604 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12608 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12610 memcpy (tc
->salt_buf
, buf
, 64);
12612 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12614 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12616 salt
->salt_len
= 4;
12618 salt
->salt_iter
= 2000 - 1;
12620 digest
[0] = tc
->data_buf
[0];
12622 return (PARSER_OK
);
12625 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12627 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12629 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12631 u32
*digest
= (u32
*) hash_buf
->digest
;
12633 salt_t
*salt
= hash_buf
->salt
;
12635 char *salt_pos
= input_buf
+ 6;
12637 char *hash_pos
= strchr (salt_pos
, '$');
12639 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12641 uint salt_len
= hash_pos
- salt_pos
;
12643 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12645 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12647 salt
->salt_len
= salt_len
;
12649 salt
->salt_iter
= 1000;
12653 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12655 return (PARSER_OK
);
12658 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12660 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12662 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12664 u32
*digest
= (u32
*) hash_buf
->digest
;
12666 salt_t
*salt
= hash_buf
->salt
;
12668 char *iter_pos
= input_buf
+ 7;
12670 char *salt_pos
= strchr (iter_pos
, '$');
12672 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12676 char *hash_pos
= strchr (salt_pos
, '$');
12678 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12680 uint salt_len
= hash_pos
- salt_pos
;
12682 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12684 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12686 salt
->salt_len
= salt_len
;
12688 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12690 salt
->salt_sign
[0] = atoi (salt_iter
);
12692 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12696 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12698 digest
[0] = byte_swap_32 (digest
[0]);
12699 digest
[1] = byte_swap_32 (digest
[1]);
12700 digest
[2] = byte_swap_32 (digest
[2]);
12701 digest
[3] = byte_swap_32 (digest
[3]);
12702 digest
[4] = byte_swap_32 (digest
[4]);
12704 return (PARSER_OK
);
12707 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12709 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12711 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12713 u32
*digest
= (u32
*) hash_buf
->digest
;
12715 salt_t
*salt
= hash_buf
->salt
;
12717 char *iter_pos
= input_buf
+ 9;
12719 char *salt_pos
= strchr (iter_pos
, '$');
12721 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12725 char *hash_pos
= strchr (salt_pos
, '$');
12727 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12729 uint salt_len
= hash_pos
- salt_pos
;
12731 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12733 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12735 salt
->salt_len
= salt_len
;
12737 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12739 salt
->salt_sign
[0] = atoi (salt_iter
);
12741 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12745 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12747 digest
[0] = byte_swap_32 (digest
[0]);
12748 digest
[1] = byte_swap_32 (digest
[1]);
12749 digest
[2] = byte_swap_32 (digest
[2]);
12750 digest
[3] = byte_swap_32 (digest
[3]);
12751 digest
[4] = byte_swap_32 (digest
[4]);
12752 digest
[5] = byte_swap_32 (digest
[5]);
12753 digest
[6] = byte_swap_32 (digest
[6]);
12754 digest
[7] = byte_swap_32 (digest
[7]);
12756 return (PARSER_OK
);
12759 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12761 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12763 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12765 u64
*digest
= (u64
*) hash_buf
->digest
;
12767 salt_t
*salt
= hash_buf
->salt
;
12769 char *iter_pos
= input_buf
+ 9;
12771 char *salt_pos
= strchr (iter_pos
, '$');
12773 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12777 char *hash_pos
= strchr (salt_pos
, '$');
12779 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12781 uint salt_len
= hash_pos
- salt_pos
;
12783 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12785 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12787 salt
->salt_len
= salt_len
;
12789 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12791 salt
->salt_sign
[0] = atoi (salt_iter
);
12793 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12797 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12799 digest
[0] = byte_swap_64 (digest
[0]);
12800 digest
[1] = byte_swap_64 (digest
[1]);
12801 digest
[2] = byte_swap_64 (digest
[2]);
12802 digest
[3] = byte_swap_64 (digest
[3]);
12803 digest
[4] = byte_swap_64 (digest
[4]);
12804 digest
[5] = byte_swap_64 (digest
[5]);
12805 digest
[6] = byte_swap_64 (digest
[6]);
12806 digest
[7] = byte_swap_64 (digest
[7]);
12808 return (PARSER_OK
);
12811 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12813 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12815 u32
*digest
= (u32
*) hash_buf
->digest
;
12817 salt_t
*salt
= hash_buf
->salt
;
12819 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12825 char *iterations_pos
= input_buf
;
12827 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12829 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12831 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12833 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12837 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12839 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12841 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12843 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12845 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12847 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12852 * pbkdf2 iterations
12855 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12858 * handle salt encoding
12861 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12863 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12865 const char p0
= saltbuf_pos
[i
+ 0];
12866 const char p1
= saltbuf_pos
[i
+ 1];
12868 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12869 | hex_convert (p0
) << 4;
12872 salt
->salt_len
= saltbuf_len
/ 2;
12875 * handle cipher encoding
12878 uint
*tmp
= (uint
*) mymalloc (32);
12880 char *cipherbuf_ptr
= (char *) tmp
;
12882 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12884 const char p0
= cipherbuf_pos
[i
+ 0];
12885 const char p1
= cipherbuf_pos
[i
+ 1];
12887 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12888 | hex_convert (p0
) << 4;
12891 // iv is stored at salt_buf 4 (length 16)
12892 // data is stored at salt_buf 8 (length 16)
12894 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12895 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12896 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12897 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12899 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12900 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12901 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12902 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12906 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12908 const char p0
= cipherbuf_pos
[j
+ 0];
12909 const char p1
= cipherbuf_pos
[j
+ 1];
12911 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12912 | hex_convert (p0
) << 4;
12919 digest
[0] = 0x10101010;
12920 digest
[1] = 0x10101010;
12921 digest
[2] = 0x10101010;
12922 digest
[3] = 0x10101010;
12924 return (PARSER_OK
);
12927 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12929 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12931 u32
*digest
= (u32
*) hash_buf
->digest
;
12933 salt_t
*salt
= hash_buf
->salt
;
12935 char *hashbuf_pos
= input_buf
;
12937 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12939 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12941 uint hash_len
= iterations_pos
- hashbuf_pos
;
12943 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12947 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12949 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12951 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12955 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12957 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12959 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12961 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12963 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12965 salt
->salt_len
= salt_len
;
12967 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12969 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
12970 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
12971 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
12972 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
12974 return (PARSER_OK
);
12977 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12979 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12981 u32
*digest
= (u32
*) hash_buf
->digest
;
12983 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12984 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12985 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12986 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12987 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12988 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12989 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12990 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12992 digest
[0] = byte_swap_32 (digest
[0]);
12993 digest
[1] = byte_swap_32 (digest
[1]);
12994 digest
[2] = byte_swap_32 (digest
[2]);
12995 digest
[3] = byte_swap_32 (digest
[3]);
12996 digest
[4] = byte_swap_32 (digest
[4]);
12997 digest
[5] = byte_swap_32 (digest
[5]);
12998 digest
[6] = byte_swap_32 (digest
[6]);
12999 digest
[7] = byte_swap_32 (digest
[7]);
13001 return (PARSER_OK
);
13004 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13006 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13008 u32
*digest
= (u32
*) hash_buf
->digest
;
13010 salt_t
*salt
= hash_buf
->salt
;
13012 char *salt_pos
= input_buf
+ 3;
13014 uint iterations_len
= 0;
13016 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13020 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13022 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13023 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13027 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13031 iterations_len
+= 8;
13035 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13038 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13040 char *hash_pos
= strchr (salt_pos
, '$');
13042 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13044 uint salt_len
= hash_pos
- salt_pos
;
13046 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13048 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13050 salt
->salt_len
= salt_len
;
13054 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13056 return (PARSER_OK
);
13059 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13061 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13063 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13065 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13067 u64
*digest
= (u64
*) hash_buf
->digest
;
13069 salt_t
*salt
= hash_buf
->salt
;
13071 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13073 char *iter_pos
= input_buf
+ 4;
13075 char *salt_pos
= strchr (iter_pos
, '$');
13077 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13081 char *hash_pos
= strchr (salt_pos
, '$');
13083 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13085 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13089 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13090 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13091 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13092 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13093 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13094 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13095 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13096 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13098 uint salt_len
= hash_pos
- salt_pos
- 1;
13100 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13102 salt
->salt_len
= salt_len
/ 2;
13104 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13105 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13106 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13107 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13108 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13109 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13110 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13111 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13113 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13114 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13115 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13116 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13117 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13118 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13119 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13120 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13121 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13122 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13124 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13126 salt
->salt_iter
= atoi (iter_pos
) - 1;
13128 return (PARSER_OK
);
13131 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13133 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13135 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13137 u32
*digest
= (u32
*) hash_buf
->digest
;
13139 salt_t
*salt
= hash_buf
->salt
;
13141 char *salt_pos
= input_buf
+ 14;
13143 char *hash_pos
= strchr (salt_pos
, '*');
13145 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13149 uint salt_len
= hash_pos
- salt_pos
- 1;
13151 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13153 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13155 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13157 salt
->salt_len
= salt_len
;
13159 u8 tmp_buf
[100] = { 0 };
13161 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13163 memcpy (digest
, tmp_buf
, 32);
13165 digest
[0] = byte_swap_32 (digest
[0]);
13166 digest
[1] = byte_swap_32 (digest
[1]);
13167 digest
[2] = byte_swap_32 (digest
[2]);
13168 digest
[3] = byte_swap_32 (digest
[3]);
13169 digest
[4] = byte_swap_32 (digest
[4]);
13170 digest
[5] = byte_swap_32 (digest
[5]);
13171 digest
[6] = byte_swap_32 (digest
[6]);
13172 digest
[7] = byte_swap_32 (digest
[7]);
13174 digest
[0] -= SHA256M_A
;
13175 digest
[1] -= SHA256M_B
;
13176 digest
[2] -= SHA256M_C
;
13177 digest
[3] -= SHA256M_D
;
13178 digest
[4] -= SHA256M_E
;
13179 digest
[5] -= SHA256M_F
;
13180 digest
[6] -= SHA256M_G
;
13181 digest
[7] -= SHA256M_H
;
13183 return (PARSER_OK
);
13186 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13188 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13190 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13192 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13194 u64
*digest
= (u64
*) hash_buf
->digest
;
13196 salt_t
*salt
= hash_buf
->salt
;
13198 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13200 char *iter_pos
= input_buf
+ 19;
13202 char *salt_pos
= strchr (iter_pos
, '.');
13204 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13208 char *hash_pos
= strchr (salt_pos
, '.');
13210 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13212 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13216 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13217 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13218 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13219 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13220 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13221 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13222 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13223 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13225 uint salt_len
= hash_pos
- salt_pos
- 1;
13229 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13233 for (i
= 0; i
< salt_len
; i
++)
13235 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13238 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13239 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13241 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13243 salt
->salt_len
= salt_len
;
13245 salt
->salt_iter
= atoi (iter_pos
) - 1;
13247 return (PARSER_OK
);
13250 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13252 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13254 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13256 u64
*digest
= (u64
*) hash_buf
->digest
;
13258 salt_t
*salt
= hash_buf
->salt
;
13260 u8 tmp_buf
[120] = { 0 };
13262 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13264 memcpy (digest
, tmp_buf
, 64);
13266 digest
[0] = byte_swap_64 (digest
[0]);
13267 digest
[1] = byte_swap_64 (digest
[1]);
13268 digest
[2] = byte_swap_64 (digest
[2]);
13269 digest
[3] = byte_swap_64 (digest
[3]);
13270 digest
[4] = byte_swap_64 (digest
[4]);
13271 digest
[5] = byte_swap_64 (digest
[5]);
13272 digest
[6] = byte_swap_64 (digest
[6]);
13273 digest
[7] = byte_swap_64 (digest
[7]);
13275 digest
[0] -= SHA512M_A
;
13276 digest
[1] -= SHA512M_B
;
13277 digest
[2] -= SHA512M_C
;
13278 digest
[3] -= SHA512M_D
;
13279 digest
[4] -= SHA512M_E
;
13280 digest
[5] -= SHA512M_F
;
13281 digest
[6] -= SHA512M_G
;
13282 digest
[7] -= SHA512M_H
;
13284 salt
->salt_len
= tmp_len
- 64;
13286 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13288 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13290 char *ptr
= (char *) salt
->salt_buf
;
13292 ptr
[salt
->salt_len
] = 0x80;
13295 return (PARSER_OK
);
13298 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13300 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13302 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13306 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13309 u32
*digest
= (u32
*) hash_buf
->digest
;
13311 salt_t
*salt
= hash_buf
->salt
;
13313 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13314 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13315 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13316 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13318 digest
[0] = byte_swap_32 (digest
[0]);
13319 digest
[1] = byte_swap_32 (digest
[1]);
13320 digest
[2] = byte_swap_32 (digest
[2]);
13321 digest
[3] = byte_swap_32 (digest
[3]);
13323 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13325 uint salt_len
= input_len
- 32 - 1;
13327 char *salt_buf
= input_buf
+ 32 + 1;
13329 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13331 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13333 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13335 salt
->salt_len
= salt_len
;
13337 return (PARSER_OK
);
13340 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13342 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13344 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13348 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13351 u32
*digest
= (u32
*) hash_buf
->digest
;
13353 salt_t
*salt
= hash_buf
->salt
;
13355 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13356 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13357 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13358 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13359 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13361 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13363 uint salt_len
= input_len
- 40 - 1;
13365 char *salt_buf
= input_buf
+ 40 + 1;
13367 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13369 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13371 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13373 salt
->salt_len
= salt_len
;
13375 return (PARSER_OK
);
13378 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13380 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13382 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13386 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13389 u32
*digest
= (u32
*) hash_buf
->digest
;
13391 salt_t
*salt
= hash_buf
->salt
;
13393 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13394 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13395 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13396 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13397 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13398 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13399 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13400 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13402 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13404 uint salt_len
= input_len
- 64 - 1;
13406 char *salt_buf
= input_buf
+ 64 + 1;
13408 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13410 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13412 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13414 salt
->salt_len
= salt_len
;
13416 return (PARSER_OK
);
13419 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13421 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13423 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13427 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13430 u64
*digest
= (u64
*) hash_buf
->digest
;
13432 salt_t
*salt
= hash_buf
->salt
;
13434 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13435 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13436 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13437 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13438 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13439 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13440 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13441 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13443 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13445 uint salt_len
= input_len
- 128 - 1;
13447 char *salt_buf
= input_buf
+ 128 + 1;
13449 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13451 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13453 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13455 salt
->salt_len
= salt_len
;
13457 return (PARSER_OK
);
13460 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13462 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13464 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13466 u32
*digest
= (u32
*) hash_buf
->digest
;
13468 salt_t
*salt
= hash_buf
->salt
;
13470 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13476 char *user_pos
= input_buf
+ 10 + 1;
13478 char *realm_pos
= strchr (user_pos
, '$');
13480 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13482 uint user_len
= realm_pos
- user_pos
;
13484 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13488 char *salt_pos
= strchr (realm_pos
, '$');
13490 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13492 uint realm_len
= salt_pos
- realm_pos
;
13494 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13498 char *data_pos
= strchr (salt_pos
, '$');
13500 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13502 uint salt_len
= data_pos
- salt_pos
;
13504 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13508 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13510 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13516 memcpy (krb5pa
->user
, user_pos
, user_len
);
13517 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13518 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13520 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13522 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13524 const char p0
= data_pos
[i
+ 0];
13525 const char p1
= data_pos
[i
+ 1];
13527 *timestamp_ptr
++ = hex_convert (p1
) << 0
13528 | hex_convert (p0
) << 4;
13531 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13533 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13535 const char p0
= data_pos
[i
+ 0];
13536 const char p1
= data_pos
[i
+ 1];
13538 *checksum_ptr
++ = hex_convert (p1
) << 0
13539 | hex_convert (p0
) << 4;
13543 * copy some data to generic buffers to make sorting happy
13546 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13547 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13548 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13549 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13550 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13551 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13552 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13553 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13554 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13556 salt
->salt_len
= 36;
13558 digest
[0] = krb5pa
->checksum
[0];
13559 digest
[1] = krb5pa
->checksum
[1];
13560 digest
[2] = krb5pa
->checksum
[2];
13561 digest
[3] = krb5pa
->checksum
[3];
13563 return (PARSER_OK
);
13566 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13568 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13570 u32
*digest
= (u32
*) hash_buf
->digest
;
13572 salt_t
*salt
= hash_buf
->salt
;
13578 char *salt_pos
= input_buf
;
13580 char *hash_pos
= strchr (salt_pos
, '$');
13582 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13584 uint salt_len
= hash_pos
- salt_pos
;
13586 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13590 uint hash_len
= input_len
- 1 - salt_len
;
13592 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13600 for (uint i
= 0; i
< salt_len
; i
++)
13602 if (salt_pos
[i
] == ' ') continue;
13607 // SAP user names cannot be longer than 12 characters
13608 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13610 // SAP user name cannot start with ! or ?
13611 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13617 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13619 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13621 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13623 salt
->salt_len
= salt_len
;
13625 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13626 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13630 digest
[0] = byte_swap_32 (digest
[0]);
13631 digest
[1] = byte_swap_32 (digest
[1]);
13633 return (PARSER_OK
);
13636 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13638 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13640 u32
*digest
= (u32
*) hash_buf
->digest
;
13642 salt_t
*salt
= hash_buf
->salt
;
13648 char *salt_pos
= input_buf
;
13650 char *hash_pos
= strchr (salt_pos
, '$');
13652 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13654 uint salt_len
= hash_pos
- salt_pos
;
13656 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13660 uint hash_len
= input_len
- 1 - salt_len
;
13662 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13670 for (uint i
= 0; i
< salt_len
; i
++)
13672 if (salt_pos
[i
] == ' ') continue;
13677 // SAP user names cannot be longer than 12 characters
13678 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13679 // so far nobody complained so we stay with this because it helps in optimization
13680 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13682 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13684 // SAP user name cannot start with ! or ?
13685 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13691 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13693 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13695 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13697 salt
->salt_len
= salt_len
;
13699 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13700 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13701 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13702 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13703 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13705 return (PARSER_OK
);
13708 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13710 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13712 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13714 u64
*digest
= (u64
*) hash_buf
->digest
;
13716 salt_t
*salt
= hash_buf
->salt
;
13718 char *iter_pos
= input_buf
+ 3;
13720 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13722 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13724 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13726 salt
->salt_iter
= salt_iter
;
13728 char *salt_pos
= iter_pos
+ 1;
13732 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13734 salt
->salt_len
= salt_len
;
13736 char *hash_pos
= salt_pos
+ salt_len
;
13738 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13742 char *tmp
= (char *) salt
->salt_buf_pc
;
13744 tmp
[0] = hash_pos
[42];
13748 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13749 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13750 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13751 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13757 return (PARSER_OK
);
13760 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13762 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13764 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13766 u32
*digest
= (u32
*) hash_buf
->digest
;
13768 salt_t
*salt
= hash_buf
->salt
;
13770 char *salt_buf
= input_buf
+ 6;
13772 uint salt_len
= 16;
13774 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13776 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13778 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13780 salt
->salt_len
= salt_len
;
13782 char *hash_pos
= input_buf
+ 6 + 16;
13784 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13785 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13786 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13787 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13788 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13789 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13790 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13791 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13793 return (PARSER_OK
);
13796 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13798 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13800 u32
*digest
= (u32
*) hash_buf
->digest
;
13802 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13803 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13807 return (PARSER_OK
);
13810 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13812 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13814 u32
*digest
= (u32
*) hash_buf
->digest
;
13816 salt_t
*salt
= hash_buf
->salt
;
13818 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13820 char *saltbuf_pos
= input_buf
;
13822 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13824 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13826 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13828 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13829 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13831 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13835 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13837 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13839 char *salt_ptr
= (char *) saltbuf_pos
;
13840 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13845 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13847 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13850 rakp_ptr
[j
] = 0x80;
13852 rakp
->salt_len
= j
;
13854 for (i
= 0; i
< 64; i
++)
13856 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13859 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13860 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13861 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13862 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13863 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13864 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13865 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13866 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13868 salt
->salt_len
= 32; // muss min. 32 haben
13870 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13871 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13872 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13873 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13874 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13876 return (PARSER_OK
);
13879 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13881 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13883 u32
*digest
= (u32
*) hash_buf
->digest
;
13885 salt_t
*salt
= hash_buf
->salt
;
13887 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13889 char *salt_pos
= input_buf
+ 1;
13891 memcpy (salt
->salt_buf
, salt_pos
, 8);
13893 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13894 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13896 salt
->salt_len
= 8;
13898 char *hash_pos
= salt_pos
+ 8;
13900 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13901 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13902 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13903 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13904 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13906 digest
[0] -= SHA1M_A
;
13907 digest
[1] -= SHA1M_B
;
13908 digest
[2] -= SHA1M_C
;
13909 digest
[3] -= SHA1M_D
;
13910 digest
[4] -= SHA1M_E
;
13912 return (PARSER_OK
);
13915 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13917 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13919 u32
*digest
= (u32
*) hash_buf
->digest
;
13921 salt_t
*salt
= hash_buf
->salt
;
13923 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13924 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13925 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13926 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13928 digest
[0] = byte_swap_32 (digest
[0]);
13929 digest
[1] = byte_swap_32 (digest
[1]);
13930 digest
[2] = byte_swap_32 (digest
[2]);
13931 digest
[3] = byte_swap_32 (digest
[3]);
13933 digest
[0] -= MD5M_A
;
13934 digest
[1] -= MD5M_B
;
13935 digest
[2] -= MD5M_C
;
13936 digest
[3] -= MD5M_D
;
13938 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13940 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13942 u32
*salt_buf
= salt
->salt_buf
;
13944 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
13945 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
13946 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
13947 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
13949 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13950 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13951 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13952 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13954 salt
->salt_len
= 16 + 1;
13956 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13958 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13960 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
13962 return (PARSER_OK
);
13965 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13967 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13969 u32
*digest
= (u32
*) hash_buf
->digest
;
13971 salt_t
*salt
= hash_buf
->salt
;
13973 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13979 char *hashbuf_pos
= input_buf
;
13981 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13983 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13985 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13987 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13991 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13993 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13995 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13997 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14001 char *databuf_pos
= strchr (iteration_pos
, ':');
14003 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14005 const uint iteration_len
= databuf_pos
- iteration_pos
;
14007 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14008 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14010 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14012 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14013 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14019 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14020 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14021 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14022 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14023 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14024 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14025 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14026 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14030 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14032 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14034 const char p0
= saltbuf_pos
[i
+ 0];
14035 const char p1
= saltbuf_pos
[i
+ 1];
14037 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14038 | hex_convert (p0
) << 4;
14041 salt
->salt_buf
[4] = 0x01000000;
14042 salt
->salt_buf
[5] = 0x80;
14044 salt
->salt_len
= saltbuf_len
/ 2;
14048 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14052 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14054 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14056 const char p0
= databuf_pos
[i
+ 0];
14057 const char p1
= databuf_pos
[i
+ 1];
14059 *databuf_ptr
++ = hex_convert (p1
) << 0
14060 | hex_convert (p0
) << 4;
14063 *databuf_ptr
++ = 0x80;
14065 for (uint i
= 0; i
< 512; i
++)
14067 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14070 cloudkey
->data_len
= databuf_len
/ 2;
14072 return (PARSER_OK
);
14075 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14077 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14079 u32
*digest
= (u32
*) hash_buf
->digest
;
14081 salt_t
*salt
= hash_buf
->salt
;
14087 char *hashbuf_pos
= input_buf
;
14089 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14091 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14093 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14095 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14099 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14101 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14103 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14105 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14107 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14111 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14113 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14115 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14117 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14119 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14123 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14125 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14126 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14128 // ok, the plan for this algorithm is the following:
14129 // we have 2 salts here, the domain-name and a random salt
14130 // while both are used in the initial transformation,
14131 // only the random salt is used in the following iterations
14132 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14133 // and one that includes only the real salt (stored into salt_buf[]).
14134 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14136 u8 tmp_buf
[100] = { 0 };
14138 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14140 memcpy (digest
, tmp_buf
, 20);
14142 digest
[0] = byte_swap_32 (digest
[0]);
14143 digest
[1] = byte_swap_32 (digest
[1]);
14144 digest
[2] = byte_swap_32 (digest
[2]);
14145 digest
[3] = byte_swap_32 (digest
[3]);
14146 digest
[4] = byte_swap_32 (digest
[4]);
14150 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14152 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14154 char *len_ptr
= NULL
;
14156 for (uint i
= 0; i
< domainbuf_len
; i
++)
14158 if (salt_buf_pc_ptr
[i
] == '.')
14160 len_ptr
= &salt_buf_pc_ptr
[i
];
14170 salt
->salt_buf_pc
[7] = domainbuf_len
;
14174 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14176 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14178 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14180 salt
->salt_len
= salt_len
;
14184 salt
->salt_iter
= atoi (iteration_pos
);
14186 return (PARSER_OK
);
14189 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14191 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14193 u32
*digest
= (u32
*) hash_buf
->digest
;
14195 salt_t
*salt
= hash_buf
->salt
;
14197 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14198 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14199 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14200 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14201 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14203 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14205 uint salt_len
= input_len
- 40 - 1;
14207 char *salt_buf
= input_buf
+ 40 + 1;
14209 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14211 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14213 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14215 salt
->salt_len
= salt_len
;
14217 return (PARSER_OK
);
14220 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14222 const u8 ascii_to_ebcdic
[] =
14224 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14225 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14226 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14227 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14228 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14229 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14230 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14231 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14232 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14233 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14234 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14235 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14236 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14237 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14238 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14239 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14242 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14244 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14246 u32
*digest
= (u32
*) hash_buf
->digest
;
14248 salt_t
*salt
= hash_buf
->salt
;
14250 char *salt_pos
= input_buf
+ 6 + 1;
14252 char *digest_pos
= strchr (salt_pos
, '*');
14254 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14256 uint salt_len
= digest_pos
- salt_pos
;
14258 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14260 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14262 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14266 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14267 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14269 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14271 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14273 salt
->salt_len
= salt_len
;
14275 for (uint i
= 0; i
< salt_len
; i
++)
14277 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14279 for (uint i
= salt_len
; i
< 8; i
++)
14281 salt_buf_pc_ptr
[i
] = 0x40;
14286 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14288 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14289 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14291 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14292 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14294 digest
[0] = byte_swap_32 (digest
[0]);
14295 digest
[1] = byte_swap_32 (digest
[1]);
14297 IP (digest
[0], digest
[1], tt
);
14299 digest
[0] = rotr32 (digest
[0], 29);
14300 digest
[1] = rotr32 (digest
[1], 29);
14304 return (PARSER_OK
);
14307 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14309 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14311 u32
*digest
= (u32
*) hash_buf
->digest
;
14313 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14314 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14315 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14316 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14318 digest
[0] = byte_swap_32 (digest
[0]);
14319 digest
[1] = byte_swap_32 (digest
[1]);
14320 digest
[2] = byte_swap_32 (digest
[2]);
14321 digest
[3] = byte_swap_32 (digest
[3]);
14323 return (PARSER_OK
);
14326 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14328 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14330 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14332 u32
*digest
= (u32
*) hash_buf
->digest
;
14334 salt_t
*salt
= hash_buf
->salt
;
14336 u8 tmp_buf
[120] = { 0 };
14338 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14340 tmp_buf
[3] += -4; // dont ask!
14342 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14344 salt
->salt_len
= 5;
14346 memcpy (digest
, tmp_buf
+ 5, 9);
14348 // yes, only 9 byte are needed to crack, but 10 to display
14350 salt
->salt_buf_pc
[7] = input_buf
[20];
14352 return (PARSER_OK
);
14355 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14357 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14359 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14361 u32
*digest
= (u32
*) hash_buf
->digest
;
14363 salt_t
*salt
= hash_buf
->salt
;
14365 u8 tmp_buf
[120] = { 0 };
14367 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14369 tmp_buf
[3] += -4; // dont ask!
14373 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14375 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)
14379 char tmp_iter_buf
[11] = { 0 };
14381 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14383 tmp_iter_buf
[10] = 0;
14385 salt
->salt_iter
= atoi (tmp_iter_buf
);
14387 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14389 return (PARSER_SALT_ITERATION
);
14392 salt
->salt_iter
--; // first round in init
14394 // 2 additional bytes for display only
14396 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14397 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14401 memcpy (digest
, tmp_buf
+ 28, 8);
14403 digest
[0] = byte_swap_32 (digest
[0]);
14404 digest
[1] = byte_swap_32 (digest
[1]);
14408 return (PARSER_OK
);
14411 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14413 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14415 u32
*digest
= (u32
*) hash_buf
->digest
;
14417 salt_t
*salt
= hash_buf
->salt
;
14419 char *salt_buf_pos
= input_buf
;
14421 char *hash_buf_pos
= salt_buf_pos
+ 6;
14423 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14424 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14425 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14426 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14427 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14428 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14429 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14430 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14432 digest
[0] -= SHA256M_A
;
14433 digest
[1] -= SHA256M_B
;
14434 digest
[2] -= SHA256M_C
;
14435 digest
[3] -= SHA256M_D
;
14436 digest
[4] -= SHA256M_E
;
14437 digest
[5] -= SHA256M_F
;
14438 digest
[6] -= SHA256M_G
;
14439 digest
[7] -= SHA256M_H
;
14441 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14443 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14445 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14447 salt
->salt_len
= salt_len
;
14449 return (PARSER_OK
);
14452 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14454 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14456 u32
*digest
= (u32
*) hash_buf
->digest
;
14458 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14460 salt_t
*salt
= hash_buf
->salt
;
14462 char *salt_buf
= input_buf
+ 6;
14464 char *digest_buf
= strchr (salt_buf
, '$');
14466 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14468 uint salt_len
= digest_buf
- salt_buf
;
14470 digest_buf
++; // skip the '$' symbol
14472 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14474 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14476 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14478 salt
->salt_len
= salt_len
;
14480 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14481 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14482 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14483 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14485 digest
[0] = byte_swap_32 (digest
[0]);
14486 digest
[1] = byte_swap_32 (digest
[1]);
14487 digest
[2] = byte_swap_32 (digest
[2]);
14488 digest
[3] = byte_swap_32 (digest
[3]);
14490 digest
[0] -= MD5M_A
;
14491 digest
[1] -= MD5M_B
;
14492 digest
[2] -= MD5M_C
;
14493 digest
[3] -= MD5M_D
;
14495 return (PARSER_OK
);
14498 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14500 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14502 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14504 u32
*digest
= (u32
*) hash_buf
->digest
;
14506 salt_t
*salt
= hash_buf
->salt
;
14508 char *salt_buf
= input_buf
+ 3;
14510 char *digest_buf
= strchr (salt_buf
, '$');
14512 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14514 uint salt_len
= digest_buf
- salt_buf
;
14516 digest_buf
++; // skip the '$' symbol
14518 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14520 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14522 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14524 salt_buf_ptr
[salt_len
] = 0x2d;
14526 salt
->salt_len
= salt_len
+ 1;
14528 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14529 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14530 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14531 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14533 digest
[0] = byte_swap_32 (digest
[0]);
14534 digest
[1] = byte_swap_32 (digest
[1]);
14535 digest
[2] = byte_swap_32 (digest
[2]);
14536 digest
[3] = byte_swap_32 (digest
[3]);
14538 digest
[0] -= MD5M_A
;
14539 digest
[1] -= MD5M_B
;
14540 digest
[2] -= MD5M_C
;
14541 digest
[3] -= MD5M_D
;
14543 return (PARSER_OK
);
14546 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14548 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14550 u32
*digest
= (u32
*) hash_buf
->digest
;
14552 u8 tmp_buf
[100] = { 0 };
14554 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14556 memcpy (digest
, tmp_buf
, 20);
14558 digest
[0] = byte_swap_32 (digest
[0]);
14559 digest
[1] = byte_swap_32 (digest
[1]);
14560 digest
[2] = byte_swap_32 (digest
[2]);
14561 digest
[3] = byte_swap_32 (digest
[3]);
14562 digest
[4] = byte_swap_32 (digest
[4]);
14564 digest
[0] -= SHA1M_A
;
14565 digest
[1] -= SHA1M_B
;
14566 digest
[2] -= SHA1M_C
;
14567 digest
[3] -= SHA1M_D
;
14568 digest
[4] -= SHA1M_E
;
14570 return (PARSER_OK
);
14573 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14575 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14577 u32
*digest
= (u32
*) hash_buf
->digest
;
14579 salt_t
*salt
= hash_buf
->salt
;
14581 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14582 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14583 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14584 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14586 digest
[0] = byte_swap_32 (digest
[0]);
14587 digest
[1] = byte_swap_32 (digest
[1]);
14588 digest
[2] = byte_swap_32 (digest
[2]);
14589 digest
[3] = byte_swap_32 (digest
[3]);
14591 digest
[0] -= MD5M_A
;
14592 digest
[1] -= MD5M_B
;
14593 digest
[2] -= MD5M_C
;
14594 digest
[3] -= MD5M_D
;
14596 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14598 uint salt_len
= input_len
- 32 - 1;
14600 char *salt_buf
= input_buf
+ 32 + 1;
14602 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14604 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14606 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14609 * add static "salt" part
14612 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14616 salt
->salt_len
= salt_len
;
14618 return (PARSER_OK
);
14621 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14623 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14625 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14627 u32
*digest
= (u32
*) hash_buf
->digest
;
14629 salt_t
*salt
= hash_buf
->salt
;
14631 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14637 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14639 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14641 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14643 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14645 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14649 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14651 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14653 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14655 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14659 char *keybuf_pos
= strchr (keylen_pos
, '$');
14661 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14663 uint keylen_len
= keybuf_pos
- keylen_pos
;
14665 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14669 char *databuf_pos
= strchr (keybuf_pos
, '$');
14671 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14673 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14675 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14679 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14681 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14687 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14688 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14689 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14690 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14692 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14693 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14694 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14695 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14697 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14698 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14699 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14700 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14702 salt
->salt_len
= 16;
14703 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14705 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14707 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14710 return (PARSER_OK
);
14713 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14715 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14717 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14719 u32
*digest
= (u32
*) hash_buf
->digest
;
14721 salt_t
*salt
= hash_buf
->salt
;
14727 // first is the N salt parameter
14729 char *N_pos
= input_buf
+ 6;
14731 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14735 salt
->scrypt_N
= atoi (N_pos
);
14739 char *r_pos
= strchr (N_pos
, ':');
14741 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14745 salt
->scrypt_r
= atoi (r_pos
);
14749 char *p_pos
= strchr (r_pos
, ':');
14751 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14755 salt
->scrypt_p
= atoi (p_pos
);
14759 char *saltbuf_pos
= strchr (p_pos
, ':');
14761 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14765 char *hash_pos
= strchr (saltbuf_pos
, ':');
14767 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14773 u8 tmp_buf
[33] = { 0 };
14775 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14777 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14779 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14781 salt
->salt_len
= tmp_len
;
14782 salt
->salt_iter
= 1;
14784 // digest - base64 decode
14786 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14788 tmp_len
= input_len
- (hash_pos
- input_buf
);
14790 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14792 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14794 memcpy (digest
, tmp_buf
, 32);
14796 return (PARSER_OK
);
14799 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14801 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14803 u32
*digest
= (u32
*) hash_buf
->digest
;
14805 salt_t
*salt
= hash_buf
->salt
;
14811 char decrypted
[76] = { 0 }; // iv + hash
14813 juniper_decrypt_hash (input_buf
, decrypted
);
14815 char *md5crypt_hash
= decrypted
+ 12;
14817 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14819 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14821 char *salt_pos
= md5crypt_hash
+ 3;
14823 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14825 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14827 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14831 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14833 return (PARSER_OK
);
14836 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14838 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14840 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14842 u32
*digest
= (u32
*) hash_buf
->digest
;
14844 salt_t
*salt
= hash_buf
->salt
;
14846 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14852 // first is *raw* salt
14854 char *salt_pos
= input_buf
+ 3;
14856 char *hash_pos
= strchr (salt_pos
, '$');
14858 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14860 uint salt_len
= hash_pos
- salt_pos
;
14862 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14866 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14868 memcpy (salt_buf_ptr
, salt_pos
, 14);
14870 salt_buf_ptr
[17] = 0x01;
14871 salt_buf_ptr
[18] = 0x80;
14873 // add some stuff to normal salt to make sorted happy
14875 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14876 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14877 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14878 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14880 salt
->salt_len
= salt_len
;
14881 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14883 // base64 decode hash
14885 u8 tmp_buf
[100] = { 0 };
14887 uint hash_len
= input_len
- 3 - salt_len
- 1;
14889 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14891 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14893 memcpy (digest
, tmp_buf
, 32);
14895 digest
[0] = byte_swap_32 (digest
[0]);
14896 digest
[1] = byte_swap_32 (digest
[1]);
14897 digest
[2] = byte_swap_32 (digest
[2]);
14898 digest
[3] = byte_swap_32 (digest
[3]);
14899 digest
[4] = byte_swap_32 (digest
[4]);
14900 digest
[5] = byte_swap_32 (digest
[5]);
14901 digest
[6] = byte_swap_32 (digest
[6]);
14902 digest
[7] = byte_swap_32 (digest
[7]);
14904 return (PARSER_OK
);
14907 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14909 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14911 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14913 u32
*digest
= (u32
*) hash_buf
->digest
;
14915 salt_t
*salt
= hash_buf
->salt
;
14921 // first is *raw* salt
14923 char *salt_pos
= input_buf
+ 3;
14925 char *hash_pos
= strchr (salt_pos
, '$');
14927 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14929 uint salt_len
= hash_pos
- salt_pos
;
14931 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14933 salt
->salt_len
= salt_len
;
14936 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14938 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14939 salt_buf_ptr
[salt_len
] = 0;
14941 // base64 decode hash
14943 u8 tmp_buf
[100] = { 0 };
14945 uint hash_len
= input_len
- 3 - salt_len
- 1;
14947 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14949 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14951 memcpy (digest
, tmp_buf
, 32);
14954 salt
->scrypt_N
= 16384;
14955 salt
->scrypt_r
= 1;
14956 salt
->scrypt_p
= 1;
14957 salt
->salt_iter
= 1;
14959 return (PARSER_OK
);
14962 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14964 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14966 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14968 u32
*digest
= (u32
*) hash_buf
->digest
;
14970 salt_t
*salt
= hash_buf
->salt
;
14972 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14978 char *version_pos
= input_buf
+ 8 + 1;
14980 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14982 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14984 u32 version_len
= verifierHashSize_pos
- version_pos
;
14986 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14988 verifierHashSize_pos
++;
14990 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14992 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14994 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14996 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15000 char *saltSize_pos
= strchr (keySize_pos
, '*');
15002 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15004 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15006 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15010 char *osalt_pos
= strchr (saltSize_pos
, '*');
15012 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15014 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15016 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15020 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15022 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15024 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15026 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15028 encryptedVerifier_pos
++;
15030 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15032 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15034 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15036 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15038 encryptedVerifierHash_pos
++;
15040 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;
15042 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15044 const uint version
= atoi (version_pos
);
15046 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15048 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15050 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15052 const uint keySize
= atoi (keySize_pos
);
15054 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15056 office2007
->keySize
= keySize
;
15058 const uint saltSize
= atoi (saltSize_pos
);
15060 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15066 salt
->salt_len
= 16;
15067 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15069 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15070 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15071 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15072 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15078 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15079 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15080 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15081 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15083 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15084 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15085 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15086 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15087 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15093 digest
[0] = office2007
->encryptedVerifierHash
[0];
15094 digest
[1] = office2007
->encryptedVerifierHash
[1];
15095 digest
[2] = office2007
->encryptedVerifierHash
[2];
15096 digest
[3] = office2007
->encryptedVerifierHash
[3];
15098 return (PARSER_OK
);
15101 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15103 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15105 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15107 u32
*digest
= (u32
*) hash_buf
->digest
;
15109 salt_t
*salt
= hash_buf
->salt
;
15111 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15117 char *version_pos
= input_buf
+ 8 + 1;
15119 char *spinCount_pos
= strchr (version_pos
, '*');
15121 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15123 u32 version_len
= spinCount_pos
- version_pos
;
15125 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15129 char *keySize_pos
= strchr (spinCount_pos
, '*');
15131 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15133 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15135 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15139 char *saltSize_pos
= strchr (keySize_pos
, '*');
15141 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15143 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15145 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15149 char *osalt_pos
= strchr (saltSize_pos
, '*');
15151 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15153 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15155 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15159 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15161 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15163 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15165 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15167 encryptedVerifier_pos
++;
15169 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15171 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15173 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15175 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15177 encryptedVerifierHash_pos
++;
15179 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;
15181 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15183 const uint version
= atoi (version_pos
);
15185 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15187 const uint spinCount
= atoi (spinCount_pos
);
15189 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15191 const uint keySize
= atoi (keySize_pos
);
15193 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15195 const uint saltSize
= atoi (saltSize_pos
);
15197 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15203 salt
->salt_len
= 16;
15204 salt
->salt_iter
= spinCount
;
15206 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15207 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15208 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15209 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15215 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15216 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15217 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15218 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15220 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15221 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15222 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15223 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15224 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15225 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15226 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15227 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15233 digest
[0] = office2010
->encryptedVerifierHash
[0];
15234 digest
[1] = office2010
->encryptedVerifierHash
[1];
15235 digest
[2] = office2010
->encryptedVerifierHash
[2];
15236 digest
[3] = office2010
->encryptedVerifierHash
[3];
15238 return (PARSER_OK
);
15241 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15243 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15245 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15247 u32
*digest
= (u32
*) hash_buf
->digest
;
15249 salt_t
*salt
= hash_buf
->salt
;
15251 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15257 char *version_pos
= input_buf
+ 8 + 1;
15259 char *spinCount_pos
= strchr (version_pos
, '*');
15261 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15263 u32 version_len
= spinCount_pos
- version_pos
;
15265 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15269 char *keySize_pos
= strchr (spinCount_pos
, '*');
15271 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15273 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15275 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15279 char *saltSize_pos
= strchr (keySize_pos
, '*');
15281 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15283 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15285 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15289 char *osalt_pos
= strchr (saltSize_pos
, '*');
15291 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15293 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15295 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15299 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15301 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15303 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15305 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15307 encryptedVerifier_pos
++;
15309 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15311 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15313 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15315 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15317 encryptedVerifierHash_pos
++;
15319 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;
15321 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15323 const uint version
= atoi (version_pos
);
15325 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15327 const uint spinCount
= atoi (spinCount_pos
);
15329 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15331 const uint keySize
= atoi (keySize_pos
);
15333 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15335 const uint saltSize
= atoi (saltSize_pos
);
15337 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15343 salt
->salt_len
= 16;
15344 salt
->salt_iter
= spinCount
;
15346 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15347 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15348 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15349 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15355 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15356 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15357 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15358 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15360 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15361 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15362 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15363 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15364 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15365 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15366 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15367 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15373 digest
[0] = office2013
->encryptedVerifierHash
[0];
15374 digest
[1] = office2013
->encryptedVerifierHash
[1];
15375 digest
[2] = office2013
->encryptedVerifierHash
[2];
15376 digest
[3] = office2013
->encryptedVerifierHash
[3];
15378 return (PARSER_OK
);
15381 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15383 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15385 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15387 u32
*digest
= (u32
*) hash_buf
->digest
;
15389 salt_t
*salt
= hash_buf
->salt
;
15391 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15397 char *version_pos
= input_buf
+ 11;
15399 char *osalt_pos
= strchr (version_pos
, '*');
15401 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15403 u32 version_len
= osalt_pos
- version_pos
;
15405 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15409 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15411 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15413 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15415 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15417 encryptedVerifier_pos
++;
15419 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15421 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15423 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15425 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15427 encryptedVerifierHash_pos
++;
15429 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15431 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15433 const uint version
= *version_pos
- 0x30;
15435 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15441 oldoffice01
->version
= version
;
15443 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15444 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15445 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15446 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15448 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15449 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15450 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15451 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15453 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15454 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15455 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15456 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15458 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15459 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15460 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15461 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15467 salt
->salt_len
= 16;
15469 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15470 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15471 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15472 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15474 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15475 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15476 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15477 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15479 // this is a workaround as office produces multiple documents with the same salt
15481 salt
->salt_len
+= 32;
15483 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15484 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15485 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15486 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15487 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15488 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15489 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15490 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15496 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15497 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15498 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15499 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15501 return (PARSER_OK
);
15504 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15506 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15509 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15511 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15513 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15515 u32
*digest
= (u32
*) hash_buf
->digest
;
15517 salt_t
*salt
= hash_buf
->salt
;
15519 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15525 char *version_pos
= input_buf
+ 11;
15527 char *osalt_pos
= strchr (version_pos
, '*');
15529 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15531 u32 version_len
= osalt_pos
- version_pos
;
15533 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15537 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15539 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15541 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15543 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15545 encryptedVerifier_pos
++;
15547 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15549 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15551 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15553 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15555 encryptedVerifierHash_pos
++;
15557 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15559 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15561 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15563 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15567 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15569 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15571 const uint version
= *version_pos
- 0x30;
15573 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15579 oldoffice01
->version
= version
;
15581 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15582 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15583 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15584 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15586 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15587 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15588 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15589 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15591 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15592 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15593 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15594 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15596 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15597 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15598 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15599 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15601 oldoffice01
->rc4key
[1] = 0;
15602 oldoffice01
->rc4key
[0] = 0;
15604 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15605 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15606 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15607 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15608 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15609 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15610 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15611 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15612 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15613 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15615 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15616 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15622 salt
->salt_len
= 16;
15624 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15625 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15626 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15627 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15629 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15630 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15631 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15632 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15634 // this is a workaround as office produces multiple documents with the same salt
15636 salt
->salt_len
+= 32;
15638 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15639 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15640 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15641 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15642 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15643 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15644 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15645 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15651 digest
[0] = oldoffice01
->rc4key
[0];
15652 digest
[1] = oldoffice01
->rc4key
[1];
15656 return (PARSER_OK
);
15659 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15661 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15663 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15665 u32
*digest
= (u32
*) hash_buf
->digest
;
15667 salt_t
*salt
= hash_buf
->salt
;
15669 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15675 char *version_pos
= input_buf
+ 11;
15677 char *osalt_pos
= strchr (version_pos
, '*');
15679 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15681 u32 version_len
= osalt_pos
- version_pos
;
15683 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15687 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15689 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15691 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15693 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15695 encryptedVerifier_pos
++;
15697 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15699 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15701 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15703 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15705 encryptedVerifierHash_pos
++;
15707 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15709 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15711 const uint version
= *version_pos
- 0x30;
15713 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15719 oldoffice34
->version
= version
;
15721 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15722 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15723 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15724 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15726 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15727 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15728 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15729 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15731 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15732 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15733 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15734 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15735 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15737 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15738 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15739 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15740 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15741 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15747 salt
->salt_len
= 16;
15749 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15750 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15751 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15752 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15754 // this is a workaround as office produces multiple documents with the same salt
15756 salt
->salt_len
+= 32;
15758 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15759 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15760 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15761 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15762 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15763 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15764 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15765 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15771 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15772 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15773 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15774 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15776 return (PARSER_OK
);
15779 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15781 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15783 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15786 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15788 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15790 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15792 u32
*digest
= (u32
*) hash_buf
->digest
;
15794 salt_t
*salt
= hash_buf
->salt
;
15796 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15802 char *version_pos
= input_buf
+ 11;
15804 char *osalt_pos
= strchr (version_pos
, '*');
15806 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15808 u32 version_len
= osalt_pos
- version_pos
;
15810 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15814 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15816 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15818 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15820 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15822 encryptedVerifier_pos
++;
15824 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15826 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15828 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15830 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15832 encryptedVerifierHash_pos
++;
15834 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15836 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15838 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15840 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15844 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15846 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15848 const uint version
= *version_pos
- 0x30;
15850 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15856 oldoffice34
->version
= version
;
15858 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15859 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15860 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15861 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15863 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15864 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15865 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15866 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15868 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15869 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15870 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15871 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15872 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15874 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15875 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15876 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15877 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15878 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15880 oldoffice34
->rc4key
[1] = 0;
15881 oldoffice34
->rc4key
[0] = 0;
15883 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15884 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15885 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15886 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15887 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15888 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15889 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15890 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15891 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15892 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15894 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15895 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15901 salt
->salt_len
= 16;
15903 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15904 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15905 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15906 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15908 // this is a workaround as office produces multiple documents with the same salt
15910 salt
->salt_len
+= 32;
15912 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15913 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15914 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15915 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15916 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15917 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15918 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15919 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15925 digest
[0] = oldoffice34
->rc4key
[0];
15926 digest
[1] = oldoffice34
->rc4key
[1];
15930 return (PARSER_OK
);
15933 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15935 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15937 u32
*digest
= (u32
*) hash_buf
->digest
;
15939 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15940 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15941 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15942 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15944 digest
[0] = byte_swap_32 (digest
[0]);
15945 digest
[1] = byte_swap_32 (digest
[1]);
15946 digest
[2] = byte_swap_32 (digest
[2]);
15947 digest
[3] = byte_swap_32 (digest
[3]);
15949 return (PARSER_OK
);
15952 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15954 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15956 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15958 u32
*digest
= (u32
*) hash_buf
->digest
;
15960 salt_t
*salt
= hash_buf
->salt
;
15962 char *signature_pos
= input_buf
;
15964 char *salt_pos
= strchr (signature_pos
, '$');
15966 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15968 u32 signature_len
= salt_pos
- signature_pos
;
15970 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15974 char *hash_pos
= strchr (salt_pos
, '$');
15976 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15978 u32 salt_len
= hash_pos
- salt_pos
;
15980 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15984 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15986 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15988 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
15989 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
15990 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
15991 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
15992 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
15994 digest
[0] -= SHA1M_A
;
15995 digest
[1] -= SHA1M_B
;
15996 digest
[2] -= SHA1M_C
;
15997 digest
[3] -= SHA1M_D
;
15998 digest
[4] -= SHA1M_E
;
16000 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16002 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16004 salt
->salt_len
= salt_len
;
16006 return (PARSER_OK
);
16009 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16011 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16013 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16015 u32
*digest
= (u32
*) hash_buf
->digest
;
16017 salt_t
*salt
= hash_buf
->salt
;
16019 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16025 char *iter_pos
= input_buf
+ 14;
16027 const int iter
= atoi (iter_pos
);
16029 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16031 salt
->salt_iter
= iter
- 1;
16033 char *salt_pos
= strchr (iter_pos
, '$');
16035 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16039 char *hash_pos
= strchr (salt_pos
, '$');
16041 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16043 const uint salt_len
= hash_pos
- salt_pos
;
16047 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16049 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16051 salt
->salt_len
= salt_len
;
16053 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16054 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16056 // add some stuff to normal salt to make sorted happy
16058 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16059 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16060 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16061 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16062 salt
->salt_buf
[4] = salt
->salt_iter
;
16064 // base64 decode hash
16066 u8 tmp_buf
[100] = { 0 };
16068 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16070 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16072 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16074 memcpy (digest
, tmp_buf
, 32);
16076 digest
[0] = byte_swap_32 (digest
[0]);
16077 digest
[1] = byte_swap_32 (digest
[1]);
16078 digest
[2] = byte_swap_32 (digest
[2]);
16079 digest
[3] = byte_swap_32 (digest
[3]);
16080 digest
[4] = byte_swap_32 (digest
[4]);
16081 digest
[5] = byte_swap_32 (digest
[5]);
16082 digest
[6] = byte_swap_32 (digest
[6]);
16083 digest
[7] = byte_swap_32 (digest
[7]);
16085 return (PARSER_OK
);
16088 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16090 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16092 u32
*digest
= (u32
*) hash_buf
->digest
;
16094 salt_t
*salt
= hash_buf
->salt
;
16096 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16097 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16101 digest
[0] = byte_swap_32 (digest
[0]);
16102 digest
[1] = byte_swap_32 (digest
[1]);
16104 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16105 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16106 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16108 char iter_c
= input_buf
[17];
16109 char iter_d
= input_buf
[19];
16111 // atm only defaults, let's see if there's more request
16112 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16113 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16115 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16117 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16118 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16119 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16120 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16122 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16123 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16124 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16125 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16127 salt
->salt_len
= 16;
16129 return (PARSER_OK
);
16132 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16134 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16136 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16138 u32
*digest
= (u32
*) hash_buf
->digest
;
16140 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16142 salt_t
*salt
= hash_buf
->salt
;
16144 char *salt_pos
= input_buf
+ 10;
16146 char *hash_pos
= strchr (salt_pos
, '$');
16148 uint salt_len
= hash_pos
- salt_pos
;
16150 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16154 uint hash_len
= input_len
- 10 - salt_len
- 1;
16156 // base64 decode salt
16158 u8 tmp_buf
[100] = { 0 };
16160 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16162 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16164 tmp_buf
[salt_len
] = 0x80;
16166 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16168 salt
->salt_len
= salt_len
;
16170 // base64 decode salt
16172 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16174 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16176 uint user_len
= hash_len
- 32;
16178 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16180 user_len
--; // skip the trailing space
16182 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16183 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16184 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16185 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16187 digest
[0] = byte_swap_32 (digest
[0]);
16188 digest
[1] = byte_swap_32 (digest
[1]);
16189 digest
[2] = byte_swap_32 (digest
[2]);
16190 digest
[3] = byte_swap_32 (digest
[3]);
16192 // store username for host only (output hash if cracked)
16194 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16195 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16197 return (PARSER_OK
);
16200 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16202 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16204 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16206 u32
*digest
= (u32
*) hash_buf
->digest
;
16208 salt_t
*salt
= hash_buf
->salt
;
16210 char *iter_pos
= input_buf
+ 10;
16212 u32 iter
= atoi (iter_pos
);
16216 return (PARSER_SALT_ITERATION
);
16219 iter
--; // first iteration is special
16221 salt
->salt_iter
= iter
;
16223 char *base64_pos
= strchr (iter_pos
, '}');
16225 if (base64_pos
== NULL
)
16227 return (PARSER_SIGNATURE_UNMATCHED
);
16232 // base64 decode salt
16234 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16236 u8 tmp_buf
[100] = { 0 };
16238 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16240 if (decoded_len
< 24)
16242 return (PARSER_SALT_LENGTH
);
16247 uint salt_len
= decoded_len
- 20;
16249 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16250 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16252 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16254 salt
->salt_len
= salt_len
;
16258 u32
*digest_ptr
= (u32
*) tmp_buf
;
16260 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16261 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16262 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16263 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16264 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16266 return (PARSER_OK
);
16269 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16271 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16273 u32
*digest
= (u32
*) hash_buf
->digest
;
16275 salt_t
*salt
= hash_buf
->salt
;
16277 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16278 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16279 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16280 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16281 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16283 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16285 uint salt_len
= input_len
- 40 - 1;
16287 char *salt_buf
= input_buf
+ 40 + 1;
16289 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16291 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16293 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16295 salt
->salt_len
= salt_len
;
16297 return (PARSER_OK
);
16300 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16302 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16304 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16306 u32
*digest
= (u32
*) hash_buf
->digest
;
16308 salt_t
*salt
= hash_buf
->salt
;
16310 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16316 char *V_pos
= input_buf
+ 5;
16318 char *R_pos
= strchr (V_pos
, '*');
16320 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16322 u32 V_len
= R_pos
- V_pos
;
16326 char *bits_pos
= strchr (R_pos
, '*');
16328 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16330 u32 R_len
= bits_pos
- R_pos
;
16334 char *P_pos
= strchr (bits_pos
, '*');
16336 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16338 u32 bits_len
= P_pos
- bits_pos
;
16342 char *enc_md_pos
= strchr (P_pos
, '*');
16344 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16346 u32 P_len
= enc_md_pos
- P_pos
;
16350 char *id_len_pos
= strchr (enc_md_pos
, '*');
16352 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16354 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16358 char *id_buf_pos
= strchr (id_len_pos
, '*');
16360 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16362 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16366 char *u_len_pos
= strchr (id_buf_pos
, '*');
16368 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16370 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16372 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16376 char *u_buf_pos
= strchr (u_len_pos
, '*');
16378 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16380 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16384 char *o_len_pos
= strchr (u_buf_pos
, '*');
16386 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16388 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16390 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16394 char *o_buf_pos
= strchr (o_len_pos
, '*');
16396 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16398 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16402 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;
16404 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16408 const int V
= atoi (V_pos
);
16409 const int R
= atoi (R_pos
);
16410 const int P
= atoi (P_pos
);
16412 if (V
!= 1) return (PARSER_SALT_VALUE
);
16413 if (R
!= 2) return (PARSER_SALT_VALUE
);
16415 const int enc_md
= atoi (enc_md_pos
);
16417 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16419 const int id_len
= atoi (id_len_pos
);
16420 const int u_len
= atoi (u_len_pos
);
16421 const int o_len
= atoi (o_len_pos
);
16423 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16424 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16425 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16427 const int bits
= atoi (bits_pos
);
16429 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16431 // copy data to esalt
16437 pdf
->enc_md
= enc_md
;
16439 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16440 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16441 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16442 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16443 pdf
->id_len
= id_len
;
16445 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16446 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16447 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16448 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16449 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16450 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16451 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16452 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16453 pdf
->u_len
= u_len
;
16455 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16456 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16457 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16458 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16459 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16460 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16461 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16462 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16463 pdf
->o_len
= o_len
;
16465 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16466 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16467 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16468 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16470 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16471 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16472 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16473 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16474 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16475 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16476 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16477 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16479 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16480 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16481 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16482 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16483 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16484 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16485 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16486 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16488 // we use ID for salt, maybe needs to change, we will see...
16490 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16491 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16492 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16493 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16494 salt
->salt_len
= pdf
->id_len
;
16496 digest
[0] = pdf
->u_buf
[0];
16497 digest
[1] = pdf
->u_buf
[1];
16498 digest
[2] = pdf
->u_buf
[2];
16499 digest
[3] = pdf
->u_buf
[3];
16501 return (PARSER_OK
);
16504 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16506 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16509 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16511 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16513 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16515 u32
*digest
= (u32
*) hash_buf
->digest
;
16517 salt_t
*salt
= hash_buf
->salt
;
16519 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16525 char *V_pos
= input_buf
+ 5;
16527 char *R_pos
= strchr (V_pos
, '*');
16529 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16531 u32 V_len
= R_pos
- V_pos
;
16535 char *bits_pos
= strchr (R_pos
, '*');
16537 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16539 u32 R_len
= bits_pos
- R_pos
;
16543 char *P_pos
= strchr (bits_pos
, '*');
16545 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16547 u32 bits_len
= P_pos
- bits_pos
;
16551 char *enc_md_pos
= strchr (P_pos
, '*');
16553 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16555 u32 P_len
= enc_md_pos
- P_pos
;
16559 char *id_len_pos
= strchr (enc_md_pos
, '*');
16561 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16563 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16567 char *id_buf_pos
= strchr (id_len_pos
, '*');
16569 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16571 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16575 char *u_len_pos
= strchr (id_buf_pos
, '*');
16577 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16579 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16581 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16585 char *u_buf_pos
= strchr (u_len_pos
, '*');
16587 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16589 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16593 char *o_len_pos
= strchr (u_buf_pos
, '*');
16595 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16597 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16599 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16603 char *o_buf_pos
= strchr (o_len_pos
, '*');
16605 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16607 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16611 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16613 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16615 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16617 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16621 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;
16623 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16627 const int V
= atoi (V_pos
);
16628 const int R
= atoi (R_pos
);
16629 const int P
= atoi (P_pos
);
16631 if (V
!= 1) return (PARSER_SALT_VALUE
);
16632 if (R
!= 2) return (PARSER_SALT_VALUE
);
16634 const int enc_md
= atoi (enc_md_pos
);
16636 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16638 const int id_len
= atoi (id_len_pos
);
16639 const int u_len
= atoi (u_len_pos
);
16640 const int o_len
= atoi (o_len_pos
);
16642 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16643 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16644 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16646 const int bits
= atoi (bits_pos
);
16648 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16650 // copy data to esalt
16656 pdf
->enc_md
= enc_md
;
16658 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16659 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16660 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16661 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16662 pdf
->id_len
= id_len
;
16664 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16665 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16666 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16667 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16668 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16669 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16670 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16671 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16672 pdf
->u_len
= u_len
;
16674 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16675 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16676 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16677 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16678 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16679 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16680 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16681 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16682 pdf
->o_len
= o_len
;
16684 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16685 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16686 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16687 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16689 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16690 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16691 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16692 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16693 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16694 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16695 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16696 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16698 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16699 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16700 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16701 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16702 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16703 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16704 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16705 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16707 pdf
->rc4key
[1] = 0;
16708 pdf
->rc4key
[0] = 0;
16710 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16711 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16712 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16713 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16714 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16715 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16716 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16717 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16718 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16719 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16721 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16722 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16724 // we use ID for salt, maybe needs to change, we will see...
16726 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16727 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16728 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16729 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16730 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16731 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16732 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16733 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16734 salt
->salt_len
= pdf
->id_len
+ 16;
16736 digest
[0] = pdf
->rc4key
[0];
16737 digest
[1] = pdf
->rc4key
[1];
16741 return (PARSER_OK
);
16744 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16746 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16748 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16750 u32
*digest
= (u32
*) hash_buf
->digest
;
16752 salt_t
*salt
= hash_buf
->salt
;
16754 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16760 char *V_pos
= input_buf
+ 5;
16762 char *R_pos
= strchr (V_pos
, '*');
16764 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16766 u32 V_len
= R_pos
- V_pos
;
16770 char *bits_pos
= strchr (R_pos
, '*');
16772 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16774 u32 R_len
= bits_pos
- R_pos
;
16778 char *P_pos
= strchr (bits_pos
, '*');
16780 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16782 u32 bits_len
= P_pos
- bits_pos
;
16786 char *enc_md_pos
= strchr (P_pos
, '*');
16788 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16790 u32 P_len
= enc_md_pos
- P_pos
;
16794 char *id_len_pos
= strchr (enc_md_pos
, '*');
16796 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16798 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16802 char *id_buf_pos
= strchr (id_len_pos
, '*');
16804 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16806 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16810 char *u_len_pos
= strchr (id_buf_pos
, '*');
16812 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16814 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16816 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16820 char *u_buf_pos
= strchr (u_len_pos
, '*');
16822 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16824 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16828 char *o_len_pos
= strchr (u_buf_pos
, '*');
16830 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16832 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16834 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16838 char *o_buf_pos
= strchr (o_len_pos
, '*');
16840 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16842 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16846 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;
16848 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16852 const int V
= atoi (V_pos
);
16853 const int R
= atoi (R_pos
);
16854 const int P
= atoi (P_pos
);
16858 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16859 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16861 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16863 const int id_len
= atoi (id_len_pos
);
16864 const int u_len
= atoi (u_len_pos
);
16865 const int o_len
= atoi (o_len_pos
);
16867 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16869 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16870 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16872 const int bits
= atoi (bits_pos
);
16874 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16880 enc_md
= atoi (enc_md_pos
);
16883 // copy data to esalt
16889 pdf
->enc_md
= enc_md
;
16891 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16892 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16893 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16894 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16898 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
16899 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
16900 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
16901 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
16904 pdf
->id_len
= id_len
;
16906 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16907 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16908 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16909 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16910 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16911 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16912 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16913 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16914 pdf
->u_len
= u_len
;
16916 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16917 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16918 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16919 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16920 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16921 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16922 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16923 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16924 pdf
->o_len
= o_len
;
16926 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16927 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16928 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16929 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16933 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16934 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16935 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16936 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16939 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16940 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16941 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16942 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16943 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16944 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16945 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16946 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16948 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16949 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16950 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16951 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16952 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16953 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16954 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16955 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16957 // precompute rc4 data for later use
16973 uint salt_pc_block
[32] = { 0 };
16975 char *salt_pc_ptr
= (char *) salt_pc_block
;
16977 memcpy (salt_pc_ptr
, padding
, 32);
16978 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16980 uint salt_pc_digest
[4] = { 0 };
16982 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16984 pdf
->rc4data
[0] = salt_pc_digest
[0];
16985 pdf
->rc4data
[1] = salt_pc_digest
[1];
16987 // we use ID for salt, maybe needs to change, we will see...
16989 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16990 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16991 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16992 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16993 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16994 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16995 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16996 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16997 salt
->salt_len
= pdf
->id_len
+ 16;
16999 salt
->salt_iter
= ROUNDS_PDF14
;
17001 digest
[0] = pdf
->u_buf
[0];
17002 digest
[1] = pdf
->u_buf
[1];
17006 return (PARSER_OK
);
17009 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17011 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17013 if (ret
!= PARSER_OK
)
17018 u32
*digest
= (u32
*) hash_buf
->digest
;
17020 salt_t
*salt
= hash_buf
->salt
;
17022 digest
[0] -= SHA256M_A
;
17023 digest
[1] -= SHA256M_B
;
17024 digest
[2] -= SHA256M_C
;
17025 digest
[3] -= SHA256M_D
;
17026 digest
[4] -= SHA256M_E
;
17027 digest
[5] -= SHA256M_F
;
17028 digest
[6] -= SHA256M_G
;
17029 digest
[7] -= SHA256M_H
;
17031 salt
->salt_buf
[2] = 0x80;
17033 return (PARSER_OK
);
17036 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17038 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17040 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17042 u32
*digest
= (u32
*) hash_buf
->digest
;
17044 salt_t
*salt
= hash_buf
->salt
;
17046 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17052 char *V_pos
= input_buf
+ 5;
17054 char *R_pos
= strchr (V_pos
, '*');
17056 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17058 u32 V_len
= R_pos
- V_pos
;
17062 char *bits_pos
= strchr (R_pos
, '*');
17064 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17066 u32 R_len
= bits_pos
- R_pos
;
17070 char *P_pos
= strchr (bits_pos
, '*');
17072 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17074 u32 bits_len
= P_pos
- bits_pos
;
17078 char *enc_md_pos
= strchr (P_pos
, '*');
17080 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17082 u32 P_len
= enc_md_pos
- P_pos
;
17086 char *id_len_pos
= strchr (enc_md_pos
, '*');
17088 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17090 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17094 char *id_buf_pos
= strchr (id_len_pos
, '*');
17096 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17098 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17102 char *u_len_pos
= strchr (id_buf_pos
, '*');
17104 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17106 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17110 char *u_buf_pos
= strchr (u_len_pos
, '*');
17112 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17114 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17118 char *o_len_pos
= strchr (u_buf_pos
, '*');
17120 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17122 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17126 char *o_buf_pos
= strchr (o_len_pos
, '*');
17128 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17130 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17134 char *last
= strchr (o_buf_pos
, '*');
17136 if (last
== NULL
) last
= input_buf
+ input_len
;
17138 u32 o_buf_len
= last
- o_buf_pos
;
17142 const int V
= atoi (V_pos
);
17143 const int R
= atoi (R_pos
);
17147 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17148 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17150 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17152 const int bits
= atoi (bits_pos
);
17154 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17156 int enc_md
= atoi (enc_md_pos
);
17158 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17160 const uint id_len
= atoi (id_len_pos
);
17161 const uint u_len
= atoi (u_len_pos
);
17162 const uint o_len
= atoi (o_len_pos
);
17164 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17165 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17166 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17167 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17168 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17169 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17170 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17171 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17173 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17174 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17175 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17177 // copy data to esalt
17179 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17181 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17183 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17186 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17187 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17189 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17190 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17192 salt
->salt_len
= 8;
17193 salt
->salt_iter
= ROUNDS_PDF17L8
;
17195 digest
[0] = pdf
->u_buf
[0];
17196 digest
[1] = pdf
->u_buf
[1];
17197 digest
[2] = pdf
->u_buf
[2];
17198 digest
[3] = pdf
->u_buf
[3];
17199 digest
[4] = pdf
->u_buf
[4];
17200 digest
[5] = pdf
->u_buf
[5];
17201 digest
[6] = pdf
->u_buf
[6];
17202 digest
[7] = pdf
->u_buf
[7];
17204 return (PARSER_OK
);
17207 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17209 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17211 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17213 u32
*digest
= (u32
*) hash_buf
->digest
;
17215 salt_t
*salt
= hash_buf
->salt
;
17217 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17225 char *iter_pos
= input_buf
+ 7;
17227 u32 iter
= atoi (iter_pos
);
17229 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17230 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17232 // first is *raw* salt
17234 char *salt_pos
= strchr (iter_pos
, ':');
17236 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17240 char *hash_pos
= strchr (salt_pos
, ':');
17242 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17244 u32 salt_len
= hash_pos
- salt_pos
;
17246 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17250 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17252 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17256 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17258 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17260 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17262 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17263 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17265 salt
->salt_len
= salt_len
;
17266 salt
->salt_iter
= iter
- 1;
17270 u8 tmp_buf
[100] = { 0 };
17272 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17274 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17276 memcpy (digest
, tmp_buf
, 16);
17278 digest
[0] = byte_swap_32 (digest
[0]);
17279 digest
[1] = byte_swap_32 (digest
[1]);
17280 digest
[2] = byte_swap_32 (digest
[2]);
17281 digest
[3] = byte_swap_32 (digest
[3]);
17283 // add some stuff to normal salt to make sorted happy
17285 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17286 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17287 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17288 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17289 salt
->salt_buf
[4] = salt
->salt_iter
;
17291 return (PARSER_OK
);
17294 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17296 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17298 u32
*digest
= (u32
*) hash_buf
->digest
;
17300 salt_t
*salt
= hash_buf
->salt
;
17302 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17303 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17304 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17305 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17307 digest
[0] = byte_swap_32 (digest
[0]);
17308 digest
[1] = byte_swap_32 (digest
[1]);
17309 digest
[2] = byte_swap_32 (digest
[2]);
17310 digest
[3] = byte_swap_32 (digest
[3]);
17312 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17314 uint salt_len
= input_len
- 32 - 1;
17316 char *salt_buf
= input_buf
+ 32 + 1;
17318 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17320 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17322 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17324 salt
->salt_len
= salt_len
;
17326 return (PARSER_OK
);
17329 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17331 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17333 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17335 u32
*digest
= (u32
*) hash_buf
->digest
;
17337 salt_t
*salt
= hash_buf
->salt
;
17339 char *user_pos
= input_buf
+ 10;
17341 char *salt_pos
= strchr (user_pos
, '*');
17343 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17347 char *hash_pos
= strchr (salt_pos
, '*');
17351 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17353 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17355 uint user_len
= salt_pos
- user_pos
- 1;
17357 uint salt_len
= hash_pos
- salt_pos
- 1;
17359 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17365 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17366 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17367 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17368 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17370 digest
[0] = byte_swap_32 (digest
[0]);
17371 digest
[1] = byte_swap_32 (digest
[1]);
17372 digest
[2] = byte_swap_32 (digest
[2]);
17373 digest
[3] = byte_swap_32 (digest
[3]);
17375 digest
[0] -= MD5M_A
;
17376 digest
[1] -= MD5M_B
;
17377 digest
[2] -= MD5M_C
;
17378 digest
[3] -= MD5M_D
;
17384 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17386 // first 4 bytes are the "challenge"
17388 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17389 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17390 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17391 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17393 // append the user name
17395 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17397 salt
->salt_len
= 4 + user_len
;
17399 return (PARSER_OK
);
17402 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17404 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17406 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17408 u32
*digest
= (u32
*) hash_buf
->digest
;
17410 salt_t
*salt
= hash_buf
->salt
;
17412 char *salt_pos
= input_buf
+ 9;
17414 char *hash_pos
= strchr (salt_pos
, '*');
17416 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17420 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17422 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17424 uint salt_len
= hash_pos
- salt_pos
- 1;
17426 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17432 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17433 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17434 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17435 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17436 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17442 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17444 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17446 salt
->salt_len
= salt_len
;
17448 return (PARSER_OK
);
17451 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17453 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17455 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17457 u32
*digest
= (u32
*) hash_buf
->digest
;
17459 salt_t
*salt
= hash_buf
->salt
;
17461 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17467 char *cry_master_len_pos
= input_buf
+ 9;
17469 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17471 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17473 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17475 cry_master_buf_pos
++;
17477 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17479 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17481 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17483 cry_salt_len_pos
++;
17485 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17487 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17489 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17491 cry_salt_buf_pos
++;
17493 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17495 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17497 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17501 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17503 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17505 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17509 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17511 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17513 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17517 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17519 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17521 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17523 public_key_len_pos
++;
17525 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17527 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17529 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17531 public_key_buf_pos
++;
17533 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;
17535 const uint cry_master_len
= atoi (cry_master_len_pos
);
17536 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17537 const uint ckey_len
= atoi (ckey_len_pos
);
17538 const uint public_key_len
= atoi (public_key_len_pos
);
17540 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17541 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17542 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17543 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17545 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17547 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17549 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17552 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17554 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17556 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17559 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17561 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17563 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17566 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17567 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17568 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17571 * store digest (should be unique enought, hopefully)
17574 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17575 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17576 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17577 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17583 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17585 const uint cry_rounds
= atoi (cry_rounds_pos
);
17587 salt
->salt_iter
= cry_rounds
- 1;
17589 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17591 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17593 salt
->salt_len
= salt_len
;
17595 return (PARSER_OK
);
17598 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17600 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17602 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17604 u32
*digest
= (u32
*) hash_buf
->digest
;
17606 salt_t
*salt
= hash_buf
->salt
;
17608 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17610 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17612 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17614 memcpy (temp_input_buf
, input_buf
, input_len
);
17618 char *URI_server_pos
= temp_input_buf
+ 6;
17620 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17622 if (URI_client_pos
== NULL
)
17624 myfree (temp_input_buf
);
17626 return (PARSER_SEPARATOR_UNMATCHED
);
17629 URI_client_pos
[0] = 0;
17632 uint URI_server_len
= strlen (URI_server_pos
);
17634 if (URI_server_len
> 512)
17636 myfree (temp_input_buf
);
17638 return (PARSER_SALT_LENGTH
);
17643 char *user_pos
= strchr (URI_client_pos
, '*');
17645 if (user_pos
== NULL
)
17647 myfree (temp_input_buf
);
17649 return (PARSER_SEPARATOR_UNMATCHED
);
17655 uint URI_client_len
= strlen (URI_client_pos
);
17657 if (URI_client_len
> 512)
17659 myfree (temp_input_buf
);
17661 return (PARSER_SALT_LENGTH
);
17666 char *realm_pos
= strchr (user_pos
, '*');
17668 if (realm_pos
== NULL
)
17670 myfree (temp_input_buf
);
17672 return (PARSER_SEPARATOR_UNMATCHED
);
17678 uint user_len
= strlen (user_pos
);
17680 if (user_len
> 116)
17682 myfree (temp_input_buf
);
17684 return (PARSER_SALT_LENGTH
);
17689 char *method_pos
= strchr (realm_pos
, '*');
17691 if (method_pos
== NULL
)
17693 myfree (temp_input_buf
);
17695 return (PARSER_SEPARATOR_UNMATCHED
);
17701 uint realm_len
= strlen (realm_pos
);
17703 if (realm_len
> 116)
17705 myfree (temp_input_buf
);
17707 return (PARSER_SALT_LENGTH
);
17712 char *URI_prefix_pos
= strchr (method_pos
, '*');
17714 if (URI_prefix_pos
== NULL
)
17716 myfree (temp_input_buf
);
17718 return (PARSER_SEPARATOR_UNMATCHED
);
17721 URI_prefix_pos
[0] = 0;
17724 uint method_len
= strlen (method_pos
);
17726 if (method_len
> 246)
17728 myfree (temp_input_buf
);
17730 return (PARSER_SALT_LENGTH
);
17735 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17737 if (URI_resource_pos
== NULL
)
17739 myfree (temp_input_buf
);
17741 return (PARSER_SEPARATOR_UNMATCHED
);
17744 URI_resource_pos
[0] = 0;
17745 URI_resource_pos
++;
17747 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17749 if (URI_prefix_len
> 245)
17751 myfree (temp_input_buf
);
17753 return (PARSER_SALT_LENGTH
);
17758 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17760 if (URI_suffix_pos
== NULL
)
17762 myfree (temp_input_buf
);
17764 return (PARSER_SEPARATOR_UNMATCHED
);
17767 URI_suffix_pos
[0] = 0;
17770 uint URI_resource_len
= strlen (URI_resource_pos
);
17772 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17774 myfree (temp_input_buf
);
17776 return (PARSER_SALT_LENGTH
);
17781 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17783 if (nonce_pos
== NULL
)
17785 myfree (temp_input_buf
);
17787 return (PARSER_SEPARATOR_UNMATCHED
);
17793 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17795 if (URI_suffix_len
> 245)
17797 myfree (temp_input_buf
);
17799 return (PARSER_SALT_LENGTH
);
17804 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17806 if (nonce_client_pos
== NULL
)
17808 myfree (temp_input_buf
);
17810 return (PARSER_SEPARATOR_UNMATCHED
);
17813 nonce_client_pos
[0] = 0;
17814 nonce_client_pos
++;
17816 uint nonce_len
= strlen (nonce_pos
);
17818 if (nonce_len
< 1 || nonce_len
> 50)
17820 myfree (temp_input_buf
);
17822 return (PARSER_SALT_LENGTH
);
17827 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17829 if (nonce_count_pos
== NULL
)
17831 myfree (temp_input_buf
);
17833 return (PARSER_SEPARATOR_UNMATCHED
);
17836 nonce_count_pos
[0] = 0;
17839 uint nonce_client_len
= strlen (nonce_client_pos
);
17841 if (nonce_client_len
> 50)
17843 myfree (temp_input_buf
);
17845 return (PARSER_SALT_LENGTH
);
17850 char *qop_pos
= strchr (nonce_count_pos
, '*');
17852 if (qop_pos
== NULL
)
17854 myfree (temp_input_buf
);
17856 return (PARSER_SEPARATOR_UNMATCHED
);
17862 uint nonce_count_len
= strlen (nonce_count_pos
);
17864 if (nonce_count_len
> 50)
17866 myfree (temp_input_buf
);
17868 return (PARSER_SALT_LENGTH
);
17873 char *directive_pos
= strchr (qop_pos
, '*');
17875 if (directive_pos
== NULL
)
17877 myfree (temp_input_buf
);
17879 return (PARSER_SEPARATOR_UNMATCHED
);
17882 directive_pos
[0] = 0;
17885 uint qop_len
= strlen (qop_pos
);
17889 myfree (temp_input_buf
);
17891 return (PARSER_SALT_LENGTH
);
17896 char *digest_pos
= strchr (directive_pos
, '*');
17898 if (digest_pos
== NULL
)
17900 myfree (temp_input_buf
);
17902 return (PARSER_SEPARATOR_UNMATCHED
);
17908 uint directive_len
= strlen (directive_pos
);
17910 if (directive_len
!= 3)
17912 myfree (temp_input_buf
);
17914 return (PARSER_SALT_LENGTH
);
17917 if (memcmp (directive_pos
, "MD5", 3))
17919 log_info ("ERROR: only the MD5 directive is currently supported\n");
17921 myfree (temp_input_buf
);
17923 return (PARSER_SIP_AUTH_DIRECTIVE
);
17927 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17932 uint md5_max_len
= 4 * 64;
17934 uint md5_remaining_len
= md5_max_len
;
17936 uint tmp_md5_buf
[64] = { 0 };
17938 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17940 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17942 md5_len
+= method_len
+ 1;
17943 tmp_md5_ptr
+= method_len
+ 1;
17945 if (URI_prefix_len
> 0)
17947 md5_remaining_len
= md5_max_len
- md5_len
;
17949 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17951 md5_len
+= URI_prefix_len
+ 1;
17952 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17955 md5_remaining_len
= md5_max_len
- md5_len
;
17957 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17959 md5_len
+= URI_resource_len
;
17960 tmp_md5_ptr
+= URI_resource_len
;
17962 if (URI_suffix_len
> 0)
17964 md5_remaining_len
= md5_max_len
- md5_len
;
17966 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17968 md5_len
+= 1 + URI_suffix_len
;
17971 uint tmp_digest
[4] = { 0 };
17973 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17975 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17976 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17977 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17978 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17984 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17986 uint esalt_len
= 0;
17988 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17990 // there are 2 possibilities for the esalt:
17992 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17994 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17996 if (esalt_len
> max_esalt_len
)
17998 myfree (temp_input_buf
);
18000 return (PARSER_SALT_LENGTH
);
18003 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18015 esalt_len
= 1 + nonce_len
+ 1 + 32;
18017 if (esalt_len
> max_esalt_len
)
18019 myfree (temp_input_buf
);
18021 return (PARSER_SALT_LENGTH
);
18024 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18032 // add 0x80 to esalt
18034 esalt_buf_ptr
[esalt_len
] = 0x80;
18036 sip
->esalt_len
= esalt_len
;
18042 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18044 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18046 uint max_salt_len
= 119;
18048 if (salt_len
> max_salt_len
)
18050 myfree (temp_input_buf
);
18052 return (PARSER_SALT_LENGTH
);
18055 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18057 sip
->salt_len
= salt_len
;
18060 * fake salt (for sorting)
18063 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18067 uint fake_salt_len
= salt_len
;
18069 if (fake_salt_len
> max_salt_len
)
18071 fake_salt_len
= max_salt_len
;
18074 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18076 salt
->salt_len
= fake_salt_len
;
18082 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18083 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18084 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18085 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18087 digest
[0] = byte_swap_32 (digest
[0]);
18088 digest
[1] = byte_swap_32 (digest
[1]);
18089 digest
[2] = byte_swap_32 (digest
[2]);
18090 digest
[3] = byte_swap_32 (digest
[3]);
18092 myfree (temp_input_buf
);
18094 return (PARSER_OK
);
18097 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18099 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18101 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18103 u32
*digest
= (u32
*) hash_buf
->digest
;
18105 salt_t
*salt
= hash_buf
->salt
;
18109 char *digest_pos
= input_buf
;
18111 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18118 char *salt_buf
= input_buf
+ 8 + 1;
18122 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18124 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18126 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18128 salt
->salt_len
= salt_len
;
18130 return (PARSER_OK
);
18133 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18135 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18137 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18139 u32
*digest
= (u32
*) hash_buf
->digest
;
18141 salt_t
*salt
= hash_buf
->salt
;
18143 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18149 char *p_buf_pos
= input_buf
+ 4;
18151 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18153 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18155 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18157 NumCyclesPower_pos
++;
18159 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18161 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18163 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18167 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18169 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18171 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18175 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18177 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18179 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18183 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18185 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18187 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18191 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18193 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18195 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18199 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18201 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18203 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18207 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18209 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18211 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18215 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18217 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18219 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18223 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;
18225 const uint iter
= atoi (NumCyclesPower_pos
);
18226 const uint crc
= atoi (crc_buf_pos
);
18227 const uint p_buf
= atoi (p_buf_pos
);
18228 const uint salt_len
= atoi (salt_len_pos
);
18229 const uint iv_len
= atoi (iv_len_pos
);
18230 const uint unpack_size
= atoi (unpack_size_pos
);
18231 const uint data_len
= atoi (data_len_pos
);
18237 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18238 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18240 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18242 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18244 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18250 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18251 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18252 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18253 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18255 seven_zip
->iv_len
= iv_len
;
18257 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18259 seven_zip
->salt_len
= 0;
18261 seven_zip
->crc
= crc
;
18263 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18265 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18267 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18270 seven_zip
->data_len
= data_len
;
18272 seven_zip
->unpack_size
= unpack_size
;
18276 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18277 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18278 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18279 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18281 salt
->salt_len
= 16;
18283 salt
->salt_sign
[0] = iter
;
18285 salt
->salt_iter
= 1 << iter
;
18296 return (PARSER_OK
);
18299 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18301 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18303 u32
*digest
= (u32
*) hash_buf
->digest
;
18305 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18306 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18307 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18308 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18309 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18310 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18311 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18312 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18314 digest
[0] = byte_swap_32 (digest
[0]);
18315 digest
[1] = byte_swap_32 (digest
[1]);
18316 digest
[2] = byte_swap_32 (digest
[2]);
18317 digest
[3] = byte_swap_32 (digest
[3]);
18318 digest
[4] = byte_swap_32 (digest
[4]);
18319 digest
[5] = byte_swap_32 (digest
[5]);
18320 digest
[6] = byte_swap_32 (digest
[6]);
18321 digest
[7] = byte_swap_32 (digest
[7]);
18323 return (PARSER_OK
);
18326 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18328 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18330 u32
*digest
= (u32
*) hash_buf
->digest
;
18332 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18333 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18334 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18335 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18336 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18337 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18338 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18339 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18340 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18341 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18342 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18343 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18344 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18345 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18346 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18347 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18349 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18350 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18351 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18352 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18353 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18354 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18355 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18356 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18357 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18358 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18359 digest
[10] = byte_swap_32 (digest
[10]);
18360 digest
[11] = byte_swap_32 (digest
[11]);
18361 digest
[12] = byte_swap_32 (digest
[12]);
18362 digest
[13] = byte_swap_32 (digest
[13]);
18363 digest
[14] = byte_swap_32 (digest
[14]);
18364 digest
[15] = byte_swap_32 (digest
[15]);
18366 return (PARSER_OK
);
18369 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18371 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18373 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18375 u32
*digest
= (u32
*) hash_buf
->digest
;
18377 salt_t
*salt
= hash_buf
->salt
;
18379 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18387 char *iter_pos
= input_buf
+ 4;
18389 u32 iter
= atoi (iter_pos
);
18391 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18392 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18394 // first is *raw* salt
18396 char *salt_pos
= strchr (iter_pos
, ':');
18398 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18402 char *hash_pos
= strchr (salt_pos
, ':');
18404 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18406 u32 salt_len
= hash_pos
- salt_pos
;
18408 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18412 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18414 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18418 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18420 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18422 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18424 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18425 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18427 salt
->salt_len
= salt_len
;
18428 salt
->salt_iter
= iter
- 1;
18432 u8 tmp_buf
[100] = { 0 };
18434 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18436 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18438 memcpy (digest
, tmp_buf
, 16);
18440 // add some stuff to normal salt to make sorted happy
18442 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18443 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18444 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18445 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18446 salt
->salt_buf
[4] = salt
->salt_iter
;
18448 return (PARSER_OK
);
18451 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18453 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18455 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18457 u32
*digest
= (u32
*) hash_buf
->digest
;
18459 salt_t
*salt
= hash_buf
->salt
;
18461 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18469 char *iter_pos
= input_buf
+ 5;
18471 u32 iter
= atoi (iter_pos
);
18473 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18474 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18476 // first is *raw* salt
18478 char *salt_pos
= strchr (iter_pos
, ':');
18480 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18484 char *hash_pos
= strchr (salt_pos
, ':');
18486 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18488 u32 salt_len
= hash_pos
- salt_pos
;
18490 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18494 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18496 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18500 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18502 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18504 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18506 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18507 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18509 salt
->salt_len
= salt_len
;
18510 salt
->salt_iter
= iter
- 1;
18514 u8 tmp_buf
[100] = { 0 };
18516 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18518 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18520 memcpy (digest
, tmp_buf
, 16);
18522 digest
[0] = byte_swap_32 (digest
[0]);
18523 digest
[1] = byte_swap_32 (digest
[1]);
18524 digest
[2] = byte_swap_32 (digest
[2]);
18525 digest
[3] = byte_swap_32 (digest
[3]);
18527 // add some stuff to normal salt to make sorted happy
18529 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18530 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18531 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18532 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18533 salt
->salt_buf
[4] = salt
->salt_iter
;
18535 return (PARSER_OK
);
18538 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18540 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18542 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18544 u64
*digest
= (u64
*) hash_buf
->digest
;
18546 salt_t
*salt
= hash_buf
->salt
;
18548 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18556 char *iter_pos
= input_buf
+ 7;
18558 u32 iter
= atoi (iter_pos
);
18560 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18561 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18563 // first is *raw* salt
18565 char *salt_pos
= strchr (iter_pos
, ':');
18567 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18571 char *hash_pos
= strchr (salt_pos
, ':');
18573 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18575 u32 salt_len
= hash_pos
- salt_pos
;
18577 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18581 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18583 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18587 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18589 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18591 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18593 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18594 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18596 salt
->salt_len
= salt_len
;
18597 salt
->salt_iter
= iter
- 1;
18601 u8 tmp_buf
[100] = { 0 };
18603 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18605 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18607 memcpy (digest
, tmp_buf
, 64);
18609 digest
[0] = byte_swap_64 (digest
[0]);
18610 digest
[1] = byte_swap_64 (digest
[1]);
18611 digest
[2] = byte_swap_64 (digest
[2]);
18612 digest
[3] = byte_swap_64 (digest
[3]);
18613 digest
[4] = byte_swap_64 (digest
[4]);
18614 digest
[5] = byte_swap_64 (digest
[5]);
18615 digest
[6] = byte_swap_64 (digest
[6]);
18616 digest
[7] = byte_swap_64 (digest
[7]);
18618 // add some stuff to normal salt to make sorted happy
18620 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18621 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18622 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18623 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18624 salt
->salt_buf
[4] = salt
->salt_iter
;
18626 return (PARSER_OK
);
18629 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18631 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18633 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18635 uint
*digest
= (uint
*) hash_buf
->digest
;
18637 salt_t
*salt
= hash_buf
->salt
;
18643 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18645 char *hash_pos
= strchr (salt_pos
, '$');
18647 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18649 u32 salt_len
= hash_pos
- salt_pos
;
18651 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18655 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18657 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18661 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18662 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18680 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18681 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18683 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18684 salt
->salt_len
= 8;
18686 return (PARSER_OK
);
18689 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18691 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18693 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18695 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18697 if (c19
& 3) return (PARSER_HASH_VALUE
);
18699 salt_t
*salt
= hash_buf
->salt
;
18701 u32
*digest
= (u32
*) hash_buf
->digest
;
18705 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18706 | itoa64_to_int (input_buf
[2]) << 6
18707 | itoa64_to_int (input_buf
[3]) << 12
18708 | itoa64_to_int (input_buf
[4]) << 18;
18712 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18713 | itoa64_to_int (input_buf
[6]) << 6
18714 | itoa64_to_int (input_buf
[7]) << 12
18715 | itoa64_to_int (input_buf
[8]) << 18;
18717 salt
->salt_len
= 4;
18719 u8 tmp_buf
[100] = { 0 };
18721 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18723 memcpy (digest
, tmp_buf
, 8);
18727 IP (digest
[0], digest
[1], tt
);
18729 digest
[0] = rotr32 (digest
[0], 31);
18730 digest
[1] = rotr32 (digest
[1], 31);
18734 return (PARSER_OK
);
18737 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18739 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18741 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18743 u32
*digest
= (u32
*) hash_buf
->digest
;
18745 salt_t
*salt
= hash_buf
->salt
;
18751 char *type_pos
= input_buf
+ 6 + 1;
18753 char *salt_pos
= strchr (type_pos
, '*');
18755 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18757 u32 type_len
= salt_pos
- type_pos
;
18759 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18763 char *crypted_pos
= strchr (salt_pos
, '*');
18765 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18767 u32 salt_len
= crypted_pos
- salt_pos
;
18769 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18773 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18775 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18781 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18782 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18784 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18785 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18787 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18788 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18789 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18790 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18792 salt
->salt_len
= 24;
18793 salt
->salt_iter
= ROUNDS_RAR3
;
18795 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18796 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18798 digest
[0] = 0xc43d7b00;
18799 digest
[1] = 0x40070000;
18803 return (PARSER_OK
);
18806 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18808 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18810 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18812 u32
*digest
= (u32
*) hash_buf
->digest
;
18814 salt_t
*salt
= hash_buf
->salt
;
18816 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18822 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18824 char *param1_pos
= strchr (param0_pos
, '$');
18826 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18828 u32 param0_len
= param1_pos
- param0_pos
;
18832 char *param2_pos
= strchr (param1_pos
, '$');
18834 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18836 u32 param1_len
= param2_pos
- param1_pos
;
18840 char *param3_pos
= strchr (param2_pos
, '$');
18842 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18844 u32 param2_len
= param3_pos
- param2_pos
;
18848 char *param4_pos
= strchr (param3_pos
, '$');
18850 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18852 u32 param3_len
= param4_pos
- param3_pos
;
18856 char *param5_pos
= strchr (param4_pos
, '$');
18858 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18860 u32 param4_len
= param5_pos
- param4_pos
;
18864 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18866 char *salt_buf
= param1_pos
;
18867 char *iv
= param3_pos
;
18868 char *pswcheck
= param5_pos
;
18870 const uint salt_len
= atoi (param0_pos
);
18871 const uint iterations
= atoi (param2_pos
);
18872 const uint pswcheck_len
= atoi (param4_pos
);
18878 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18879 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18880 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18882 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18883 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18884 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18890 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18891 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18892 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18893 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
18895 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
18896 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
18897 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
18898 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
18900 salt
->salt_len
= 16;
18902 salt
->salt_sign
[0] = iterations
;
18904 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18910 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
18911 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
18915 return (PARSER_OK
);
18918 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18920 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18922 u32
*digest
= (u32
*) hash_buf
->digest
;
18924 salt_t
*salt
= hash_buf
->salt
;
18926 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18927 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18928 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18929 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18930 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18931 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18932 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18933 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18935 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18937 uint salt_len
= input_len
- 64 - 1;
18939 char *salt_buf
= input_buf
+ 64 + 1;
18941 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18943 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18945 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18947 salt
->salt_len
= salt_len
;
18950 * we can precompute the first sha256 transform
18953 uint w
[16] = { 0 };
18955 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18956 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18957 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18958 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18959 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18960 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18961 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18962 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18963 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18964 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18965 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18966 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18967 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18968 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18969 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18970 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18972 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
18974 sha256_64 (w
, pc256
);
18976 salt
->salt_buf_pc
[0] = pc256
[0];
18977 salt
->salt_buf_pc
[1] = pc256
[1];
18978 salt
->salt_buf_pc
[2] = pc256
[2];
18979 salt
->salt_buf_pc
[3] = pc256
[3];
18980 salt
->salt_buf_pc
[4] = pc256
[4];
18981 salt
->salt_buf_pc
[5] = pc256
[5];
18982 salt
->salt_buf_pc
[6] = pc256
[6];
18983 salt
->salt_buf_pc
[7] = pc256
[7];
18985 digest
[0] -= pc256
[0];
18986 digest
[1] -= pc256
[1];
18987 digest
[2] -= pc256
[2];
18988 digest
[3] -= pc256
[3];
18989 digest
[4] -= pc256
[4];
18990 digest
[5] -= pc256
[5];
18991 digest
[6] -= pc256
[6];
18992 digest
[7] -= pc256
[7];
18994 return (PARSER_OK
);
18997 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18999 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
19001 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
19003 u32
*digest
= (u32
*) hash_buf
->digest
;
19005 salt_t
*salt
= hash_buf
->salt
;
19011 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
19013 char *data_buf_pos
= strchr (data_len_pos
, '$');
19015 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19017 u32 data_len_len
= data_buf_pos
- data_len_pos
;
19019 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
19020 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
19024 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
19026 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
19028 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
19030 u32 data_len
= atoi (data_len_pos
);
19032 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
19038 char *salt_pos
= data_buf_pos
;
19040 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19041 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19042 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
19043 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
19045 // this is actually the CT, which is also the hash later (if matched)
19047 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
19048 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
19049 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
19050 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
19052 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
19054 salt
->salt_iter
= 10 - 1;
19060 digest
[0] = salt
->salt_buf
[4];
19061 digest
[1] = salt
->salt_buf
[5];
19062 digest
[2] = salt
->salt_buf
[6];
19063 digest
[3] = salt
->salt_buf
[7];
19065 return (PARSER_OK
);
19068 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19070 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
19072 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19074 u32
*digest
= (u32
*) hash_buf
->digest
;
19076 salt_t
*salt
= hash_buf
->salt
;
19082 char *salt_pos
= input_buf
+ 11 + 1;
19084 char *iter_pos
= strchr (salt_pos
, ',');
19086 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19088 u32 salt_len
= iter_pos
- salt_pos
;
19090 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
19094 char *hash_pos
= strchr (iter_pos
, ',');
19096 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19098 u32 iter_len
= hash_pos
- iter_pos
;
19100 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
19104 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
19106 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
19112 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19113 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19114 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
19115 salt
->salt_buf
[3] = 0x00018000;
19117 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19118 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19119 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
19120 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
19122 salt
->salt_len
= salt_len
/ 2;
19124 salt
->salt_iter
= atoi (iter_pos
) - 1;
19130 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19131 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19132 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19133 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19134 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19135 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19136 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19137 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19139 return (PARSER_OK
);
19142 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19144 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
19146 u32
*digest
= (u32
*) hash_buf
->digest
;
19148 salt_t
*salt
= hash_buf
->salt
;
19154 char *hash_pos
= input_buf
+ 64;
19155 char *salt1_pos
= input_buf
+ 128;
19156 char *salt2_pos
= input_buf
;
19162 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
19163 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
19164 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
19165 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
19167 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
19168 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
19169 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
19170 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
19172 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
19173 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
19174 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
19175 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
19177 salt
->salt_len
= 48;
19179 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
19185 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19186 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19187 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19188 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19189 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19190 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19191 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19192 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19194 return (PARSER_OK
);
19198 * parallel running threads
19203 BOOL WINAPI
sigHandler_default (DWORD sig
)
19207 case CTRL_CLOSE_EVENT
:
19210 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
19211 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
19212 * function otherwise it is too late (e.g. after returning from this function)
19217 SetConsoleCtrlHandler (NULL
, TRUE
);
19224 case CTRL_LOGOFF_EVENT
:
19225 case CTRL_SHUTDOWN_EVENT
:
19229 SetConsoleCtrlHandler (NULL
, TRUE
);
19237 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19241 case CTRL_CLOSE_EVENT
:
19245 SetConsoleCtrlHandler (NULL
, TRUE
);
19252 case CTRL_LOGOFF_EVENT
:
19253 case CTRL_SHUTDOWN_EVENT
:
19257 SetConsoleCtrlHandler (NULL
, TRUE
);
19265 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19267 if (callback
== NULL
)
19269 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19273 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19279 void sigHandler_default (int sig
)
19283 signal (sig
, NULL
);
19286 void sigHandler_benchmark (int sig
)
19290 signal (sig
, NULL
);
19293 void hc_signal (void (callback
) (int))
19295 if (callback
== NULL
) callback
= SIG_DFL
;
19297 signal (SIGINT
, callback
);
19298 signal (SIGTERM
, callback
);
19299 signal (SIGABRT
, callback
);
19304 void status_display ();
19306 void *thread_keypress (void *p
)
19308 int benchmark
= *((int *) p
);
19310 uint quiet
= data
.quiet
;
19314 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19316 int ch
= tty_getchar();
19318 if (ch
== -1) break;
19320 if (ch
== 0) continue;
19326 hc_thread_mutex_lock (mux_display
);
19341 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19342 if (quiet
== 0) fflush (stdout
);
19354 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19355 if (quiet
== 0) fflush (stdout
);
19367 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19368 if (quiet
== 0) fflush (stdout
);
19380 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19381 if (quiet
== 0) fflush (stdout
);
19389 if (benchmark
== 1) break;
19391 stop_at_checkpoint ();
19395 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19396 if (quiet
== 0) fflush (stdout
);
19404 if (benchmark
== 1)
19416 hc_thread_mutex_unlock (mux_display
);
19428 bool class_num (const u8 c
)
19430 return ((c
>= '0') && (c
<= '9'));
19433 bool class_lower (const u8 c
)
19435 return ((c
>= 'a') && (c
<= 'z'));
19438 bool class_upper (const u8 c
)
19440 return ((c
>= 'A') && (c
<= 'Z'));
19443 bool class_alpha (const u8 c
)
19445 return (class_lower (c
) || class_upper (c
));
19448 int conv_ctoi (const u8 c
)
19454 else if (class_upper (c
))
19456 return c
- 'A' + 10;
19462 int conv_itoc (const u8 c
)
19470 return c
+ 'A' - 10;
19480 #define INCR_POS if (++rule_pos == rule_len) return (-1)
19481 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
19482 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
19483 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
19484 #define MAX_KERNEL_RULES 255
19485 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
19486 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19487 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19489 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
19490 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
19491 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19492 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19494 int cpu_rule_to_kernel_rule (char rule_buf
[BUFSIZ
], uint rule_len
, kernel_rule_t
*rule
)
19499 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19501 switch (rule_buf
[rule_pos
])
19507 case RULE_OP_MANGLE_NOOP
:
19508 SET_NAME (rule
, rule_buf
[rule_pos
]);
19511 case RULE_OP_MANGLE_LREST
:
19512 SET_NAME (rule
, rule_buf
[rule_pos
]);
19515 case RULE_OP_MANGLE_UREST
:
19516 SET_NAME (rule
, rule_buf
[rule_pos
]);
19519 case RULE_OP_MANGLE_LREST_UFIRST
:
19520 SET_NAME (rule
, rule_buf
[rule_pos
]);
19523 case RULE_OP_MANGLE_UREST_LFIRST
:
19524 SET_NAME (rule
, rule_buf
[rule_pos
]);
19527 case RULE_OP_MANGLE_TREST
:
19528 SET_NAME (rule
, rule_buf
[rule_pos
]);
19531 case RULE_OP_MANGLE_TOGGLE_AT
:
19532 SET_NAME (rule
, rule_buf
[rule_pos
]);
19533 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19536 case RULE_OP_MANGLE_REVERSE
:
19537 SET_NAME (rule
, rule_buf
[rule_pos
]);
19540 case RULE_OP_MANGLE_DUPEWORD
:
19541 SET_NAME (rule
, rule_buf
[rule_pos
]);
19544 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19545 SET_NAME (rule
, rule_buf
[rule_pos
]);
19546 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19549 case RULE_OP_MANGLE_REFLECT
:
19550 SET_NAME (rule
, rule_buf
[rule_pos
]);
19553 case RULE_OP_MANGLE_ROTATE_LEFT
:
19554 SET_NAME (rule
, rule_buf
[rule_pos
]);
19557 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19558 SET_NAME (rule
, rule_buf
[rule_pos
]);
19561 case RULE_OP_MANGLE_APPEND
:
19562 SET_NAME (rule
, rule_buf
[rule_pos
]);
19563 SET_P0 (rule
, rule_buf
[rule_pos
]);
19566 case RULE_OP_MANGLE_PREPEND
:
19567 SET_NAME (rule
, rule_buf
[rule_pos
]);
19568 SET_P0 (rule
, rule_buf
[rule_pos
]);
19571 case RULE_OP_MANGLE_DELETE_FIRST
:
19572 SET_NAME (rule
, rule_buf
[rule_pos
]);
19575 case RULE_OP_MANGLE_DELETE_LAST
:
19576 SET_NAME (rule
, rule_buf
[rule_pos
]);
19579 case RULE_OP_MANGLE_DELETE_AT
:
19580 SET_NAME (rule
, rule_buf
[rule_pos
]);
19581 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19584 case RULE_OP_MANGLE_EXTRACT
:
19585 SET_NAME (rule
, rule_buf
[rule_pos
]);
19586 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19587 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19590 case RULE_OP_MANGLE_OMIT
:
19591 SET_NAME (rule
, rule_buf
[rule_pos
]);
19592 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19593 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19596 case RULE_OP_MANGLE_INSERT
:
19597 SET_NAME (rule
, rule_buf
[rule_pos
]);
19598 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19599 SET_P1 (rule
, rule_buf
[rule_pos
]);
19602 case RULE_OP_MANGLE_OVERSTRIKE
:
19603 SET_NAME (rule
, rule_buf
[rule_pos
]);
19604 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19605 SET_P1 (rule
, rule_buf
[rule_pos
]);
19608 case RULE_OP_MANGLE_TRUNCATE_AT
:
19609 SET_NAME (rule
, rule_buf
[rule_pos
]);
19610 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19613 case RULE_OP_MANGLE_REPLACE
:
19614 SET_NAME (rule
, rule_buf
[rule_pos
]);
19615 SET_P0 (rule
, rule_buf
[rule_pos
]);
19616 SET_P1 (rule
, rule_buf
[rule_pos
]);
19619 case RULE_OP_MANGLE_PURGECHAR
:
19623 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19627 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19628 SET_NAME (rule
, rule_buf
[rule_pos
]);
19629 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19632 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19633 SET_NAME (rule
, rule_buf
[rule_pos
]);
19634 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19637 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19638 SET_NAME (rule
, rule_buf
[rule_pos
]);
19641 case RULE_OP_MANGLE_SWITCH_FIRST
:
19642 SET_NAME (rule
, rule_buf
[rule_pos
]);
19645 case RULE_OP_MANGLE_SWITCH_LAST
:
19646 SET_NAME (rule
, rule_buf
[rule_pos
]);
19649 case RULE_OP_MANGLE_SWITCH_AT
:
19650 SET_NAME (rule
, rule_buf
[rule_pos
]);
19651 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19652 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19655 case RULE_OP_MANGLE_CHR_SHIFTL
:
19656 SET_NAME (rule
, rule_buf
[rule_pos
]);
19657 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19660 case RULE_OP_MANGLE_CHR_SHIFTR
:
19661 SET_NAME (rule
, rule_buf
[rule_pos
]);
19662 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19665 case RULE_OP_MANGLE_CHR_INCR
:
19666 SET_NAME (rule
, rule_buf
[rule_pos
]);
19667 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19670 case RULE_OP_MANGLE_CHR_DECR
:
19671 SET_NAME (rule
, rule_buf
[rule_pos
]);
19672 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19675 case RULE_OP_MANGLE_REPLACE_NP1
:
19676 SET_NAME (rule
, rule_buf
[rule_pos
]);
19677 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19680 case RULE_OP_MANGLE_REPLACE_NM1
:
19681 SET_NAME (rule
, rule_buf
[rule_pos
]);
19682 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19685 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19686 SET_NAME (rule
, rule_buf
[rule_pos
]);
19687 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19690 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19691 SET_NAME (rule
, rule_buf
[rule_pos
]);
19692 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19695 case RULE_OP_MANGLE_TITLE
:
19696 SET_NAME (rule
, rule_buf
[rule_pos
]);
19705 if (rule_pos
< rule_len
) return (-1);
19710 int kernel_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], kernel_rule_t
*rule
)
19714 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19718 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19722 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19726 case RULE_OP_MANGLE_NOOP
:
19727 rule_buf
[rule_pos
] = rule_cmd
;
19730 case RULE_OP_MANGLE_LREST
:
19731 rule_buf
[rule_pos
] = rule_cmd
;
19734 case RULE_OP_MANGLE_UREST
:
19735 rule_buf
[rule_pos
] = rule_cmd
;
19738 case RULE_OP_MANGLE_LREST_UFIRST
:
19739 rule_buf
[rule_pos
] = rule_cmd
;
19742 case RULE_OP_MANGLE_UREST_LFIRST
:
19743 rule_buf
[rule_pos
] = rule_cmd
;
19746 case RULE_OP_MANGLE_TREST
:
19747 rule_buf
[rule_pos
] = rule_cmd
;
19750 case RULE_OP_MANGLE_TOGGLE_AT
:
19751 rule_buf
[rule_pos
] = rule_cmd
;
19752 GET_P0_CONV (rule
);
19755 case RULE_OP_MANGLE_REVERSE
:
19756 rule_buf
[rule_pos
] = rule_cmd
;
19759 case RULE_OP_MANGLE_DUPEWORD
:
19760 rule_buf
[rule_pos
] = rule_cmd
;
19763 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19764 rule_buf
[rule_pos
] = rule_cmd
;
19765 GET_P0_CONV (rule
);
19768 case RULE_OP_MANGLE_REFLECT
:
19769 rule_buf
[rule_pos
] = rule_cmd
;
19772 case RULE_OP_MANGLE_ROTATE_LEFT
:
19773 rule_buf
[rule_pos
] = rule_cmd
;
19776 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19777 rule_buf
[rule_pos
] = rule_cmd
;
19780 case RULE_OP_MANGLE_APPEND
:
19781 rule_buf
[rule_pos
] = rule_cmd
;
19785 case RULE_OP_MANGLE_PREPEND
:
19786 rule_buf
[rule_pos
] = rule_cmd
;
19790 case RULE_OP_MANGLE_DELETE_FIRST
:
19791 rule_buf
[rule_pos
] = rule_cmd
;
19794 case RULE_OP_MANGLE_DELETE_LAST
:
19795 rule_buf
[rule_pos
] = rule_cmd
;
19798 case RULE_OP_MANGLE_DELETE_AT
:
19799 rule_buf
[rule_pos
] = rule_cmd
;
19800 GET_P0_CONV (rule
);
19803 case RULE_OP_MANGLE_EXTRACT
:
19804 rule_buf
[rule_pos
] = rule_cmd
;
19805 GET_P0_CONV (rule
);
19806 GET_P1_CONV (rule
);
19809 case RULE_OP_MANGLE_OMIT
:
19810 rule_buf
[rule_pos
] = rule_cmd
;
19811 GET_P0_CONV (rule
);
19812 GET_P1_CONV (rule
);
19815 case RULE_OP_MANGLE_INSERT
:
19816 rule_buf
[rule_pos
] = rule_cmd
;
19817 GET_P0_CONV (rule
);
19821 case RULE_OP_MANGLE_OVERSTRIKE
:
19822 rule_buf
[rule_pos
] = rule_cmd
;
19823 GET_P0_CONV (rule
);
19827 case RULE_OP_MANGLE_TRUNCATE_AT
:
19828 rule_buf
[rule_pos
] = rule_cmd
;
19829 GET_P0_CONV (rule
);
19832 case RULE_OP_MANGLE_REPLACE
:
19833 rule_buf
[rule_pos
] = rule_cmd
;
19838 case RULE_OP_MANGLE_PURGECHAR
:
19842 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19846 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19847 rule_buf
[rule_pos
] = rule_cmd
;
19848 GET_P0_CONV (rule
);
19851 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19852 rule_buf
[rule_pos
] = rule_cmd
;
19853 GET_P0_CONV (rule
);
19856 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19857 rule_buf
[rule_pos
] = rule_cmd
;
19860 case RULE_OP_MANGLE_SWITCH_FIRST
:
19861 rule_buf
[rule_pos
] = rule_cmd
;
19864 case RULE_OP_MANGLE_SWITCH_LAST
:
19865 rule_buf
[rule_pos
] = rule_cmd
;
19868 case RULE_OP_MANGLE_SWITCH_AT
:
19869 rule_buf
[rule_pos
] = rule_cmd
;
19870 GET_P0_CONV (rule
);
19871 GET_P1_CONV (rule
);
19874 case RULE_OP_MANGLE_CHR_SHIFTL
:
19875 rule_buf
[rule_pos
] = rule_cmd
;
19876 GET_P0_CONV (rule
);
19879 case RULE_OP_MANGLE_CHR_SHIFTR
:
19880 rule_buf
[rule_pos
] = rule_cmd
;
19881 GET_P0_CONV (rule
);
19884 case RULE_OP_MANGLE_CHR_INCR
:
19885 rule_buf
[rule_pos
] = rule_cmd
;
19886 GET_P0_CONV (rule
);
19889 case RULE_OP_MANGLE_CHR_DECR
:
19890 rule_buf
[rule_pos
] = rule_cmd
;
19891 GET_P0_CONV (rule
);
19894 case RULE_OP_MANGLE_REPLACE_NP1
:
19895 rule_buf
[rule_pos
] = rule_cmd
;
19896 GET_P0_CONV (rule
);
19899 case RULE_OP_MANGLE_REPLACE_NM1
:
19900 rule_buf
[rule_pos
] = rule_cmd
;
19901 GET_P0_CONV (rule
);
19904 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19905 rule_buf
[rule_pos
] = rule_cmd
;
19906 GET_P0_CONV (rule
);
19909 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19910 rule_buf
[rule_pos
] = rule_cmd
;
19911 GET_P0_CONV (rule
);
19914 case RULE_OP_MANGLE_TITLE
:
19915 rule_buf
[rule_pos
] = rule_cmd
;
19919 return rule_pos
- 1;
19937 * CPU rules : this is from hashcat sources, cpu based rules
19940 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19941 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19943 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19944 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19945 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19947 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19948 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19949 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19951 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19955 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19960 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19964 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19969 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19973 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19978 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19983 for (l
= 0; l
< arr_len
; l
++)
19985 r
= arr_len
- 1 - l
;
19989 MANGLE_SWITCH (arr
, l
, r
);
19995 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19997 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19999 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
20001 return (arr_len
* 2);
20004 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
20006 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20008 int orig_len
= arr_len
;
20012 for (i
= 0; i
< times
; i
++)
20014 memcpy (&arr
[arr_len
], arr
, orig_len
);
20016 arr_len
+= orig_len
;
20022 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
20024 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20026 mangle_double (arr
, arr_len
);
20028 mangle_reverse (arr
+ arr_len
, arr_len
);
20030 return (arr_len
* 2);
20033 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
20038 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
20040 MANGLE_SWITCH (arr
, l
, r
);
20046 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
20051 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
20053 MANGLE_SWITCH (arr
, l
, r
);
20059 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20061 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20065 return (arr_len
+ 1);
20068 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20070 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20074 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20076 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20081 return (arr_len
+ 1);
20084 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20086 if (upos
>= arr_len
) return (arr_len
);
20090 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
20092 arr
[arr_pos
] = arr
[arr_pos
+ 1];
20095 return (arr_len
- 1);
20098 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20100 if (upos
>= arr_len
) return (arr_len
);
20102 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
20106 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
20108 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
20114 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20116 if (upos
>= arr_len
) return (arr_len
);
20118 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
20122 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
20124 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
20127 return (arr_len
- ulen
);
20130 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20132 if (upos
>= arr_len
) return (arr_len
);
20134 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20138 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
20140 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20145 return (arr_len
+ 1);
20148 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
)
20150 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20152 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
20154 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
20156 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
20158 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
20160 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
20162 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
20164 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
20166 return (arr_len
+ arr2_cpy
);
20169 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20171 if (upos
>= arr_len
) return (arr_len
);
20178 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20180 if (upos
>= arr_len
) return (arr_len
);
20182 memset (arr
+ upos
, 0, arr_len
- upos
);
20187 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
20191 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20193 if (arr
[arr_pos
] != oldc
) continue;
20195 arr
[arr_pos
] = newc
;
20201 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20207 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20209 if (arr
[arr_pos
] == c
) continue;
20211 arr
[ret_len
] = arr
[arr_pos
];
20219 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20221 if (ulen
> arr_len
) return (arr_len
);
20223 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20225 char cs
[100] = { 0 };
20227 memcpy (cs
, arr
, ulen
);
20231 for (i
= 0; i
< ulen
; i
++)
20235 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20241 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20243 if (ulen
> arr_len
) return (arr_len
);
20245 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20247 int upos
= arr_len
- ulen
;
20251 for (i
= 0; i
< ulen
; i
++)
20253 char c
= arr
[upos
+ i
];
20255 arr_len
= mangle_append (arr
, arr_len
, c
);
20261 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20263 if ( arr_len
== 0) return (arr_len
);
20264 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20266 char c
= arr
[upos
];
20270 for (i
= 0; i
< ulen
; i
++)
20272 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20278 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20280 if ( arr_len
== 0) return (arr_len
);
20281 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20285 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20287 int new_pos
= arr_pos
* 2;
20289 arr
[new_pos
] = arr
[arr_pos
];
20291 arr
[new_pos
+ 1] = arr
[arr_pos
];
20294 return (arr_len
* 2);
20297 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20299 if (upos
>= arr_len
) return (arr_len
);
20300 if (upos2
>= arr_len
) return (arr_len
);
20302 MANGLE_SWITCH (arr
, upos
, upos2
);
20307 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20309 MANGLE_SWITCH (arr
, upos
, upos2
);
20314 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20316 if (upos
>= arr_len
) return (arr_len
);
20323 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20325 if (upos
>= arr_len
) return (arr_len
);
20332 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20334 if (upos
>= arr_len
) return (arr_len
);
20341 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20343 if (upos
>= arr_len
) return (arr_len
);
20350 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20352 int upper_next
= 1;
20356 for (pos
= 0; pos
< arr_len
; pos
++)
20358 if (arr
[pos
] == ' ')
20369 MANGLE_UPPER_AT (arr
, pos
);
20373 MANGLE_LOWER_AT (arr
, pos
);
20380 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20382 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20388 for (j
= 0; j
< rp_gen_num
; j
++)
20395 switch ((char) get_random_num (0, 9))
20398 r
= get_random_num (0, sizeof (grp_op_nop
));
20399 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20403 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20404 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20405 p1
= get_random_num (0, sizeof (grp_pos
));
20406 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20410 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20411 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20412 p1
= get_random_num (1, 6);
20413 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20417 r
= get_random_num (0, sizeof (grp_op_chr
));
20418 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20419 p1
= get_random_num (0x20, 0x7e);
20420 rule_buf
[rule_pos
++] = (char) p1
;
20424 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20425 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20426 p1
= get_random_num (0x20, 0x7e);
20427 rule_buf
[rule_pos
++] = (char) p1
;
20428 p2
= get_random_num (0x20, 0x7e);
20430 p2
= get_random_num (0x20, 0x7e);
20431 rule_buf
[rule_pos
++] = (char) p2
;
20435 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20436 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20437 p1
= get_random_num (0, sizeof (grp_pos
));
20438 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20439 p2
= get_random_num (0x20, 0x7e);
20440 rule_buf
[rule_pos
++] = (char) p2
;
20444 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20445 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20446 p1
= get_random_num (0, sizeof (grp_pos
));
20447 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20448 p2
= get_random_num (0, sizeof (grp_pos
));
20450 p2
= get_random_num (0, sizeof (grp_pos
));
20451 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20455 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20456 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
20457 p1
= get_random_num (0, sizeof (grp_pos
));
20458 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20459 p2
= get_random_num (1, sizeof (grp_pos
));
20461 p2
= get_random_num (1, sizeof (grp_pos
));
20462 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20466 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
20467 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
20468 p1
= get_random_num (0, sizeof (grp_pos
));
20469 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20470 p2
= get_random_num (1, sizeof (grp_pos
));
20471 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20472 p3
= get_random_num (0, sizeof (grp_pos
));
20473 rule_buf
[rule_pos
++] = grp_pos
[p3
];
20481 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
20483 char mem
[BLOCK_SIZE
] = { 0 };
20485 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
20487 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
20489 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20491 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
20493 int out_len
= in_len
;
20494 int mem_len
= in_len
;
20496 memcpy (out
, in
, out_len
);
20500 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
20505 switch (rule
[rule_pos
])
20510 case RULE_OP_MANGLE_NOOP
:
20513 case RULE_OP_MANGLE_LREST
:
20514 out_len
= mangle_lrest (out
, out_len
);
20517 case RULE_OP_MANGLE_UREST
:
20518 out_len
= mangle_urest (out
, out_len
);
20521 case RULE_OP_MANGLE_LREST_UFIRST
:
20522 out_len
= mangle_lrest (out
, out_len
);
20523 if (out_len
) MANGLE_UPPER_AT (out
, 0);
20526 case RULE_OP_MANGLE_UREST_LFIRST
:
20527 out_len
= mangle_urest (out
, out_len
);
20528 if (out_len
) MANGLE_LOWER_AT (out
, 0);
20531 case RULE_OP_MANGLE_TREST
:
20532 out_len
= mangle_trest (out
, out_len
);
20535 case RULE_OP_MANGLE_TOGGLE_AT
:
20536 NEXT_RULEPOS (rule_pos
);
20537 NEXT_RPTOI (rule
, rule_pos
, upos
);
20538 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
20541 case RULE_OP_MANGLE_REVERSE
:
20542 out_len
= mangle_reverse (out
, out_len
);
20545 case RULE_OP_MANGLE_DUPEWORD
:
20546 out_len
= mangle_double (out
, out_len
);
20549 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20550 NEXT_RULEPOS (rule_pos
);
20551 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20552 out_len
= mangle_double_times (out
, out_len
, ulen
);
20555 case RULE_OP_MANGLE_REFLECT
:
20556 out_len
= mangle_reflect (out
, out_len
);
20559 case RULE_OP_MANGLE_ROTATE_LEFT
:
20560 mangle_rotate_left (out
, out_len
);
20563 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20564 mangle_rotate_right (out
, out_len
);
20567 case RULE_OP_MANGLE_APPEND
:
20568 NEXT_RULEPOS (rule_pos
);
20569 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
20572 case RULE_OP_MANGLE_PREPEND
:
20573 NEXT_RULEPOS (rule_pos
);
20574 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
20577 case RULE_OP_MANGLE_DELETE_FIRST
:
20578 out_len
= mangle_delete_at (out
, out_len
, 0);
20581 case RULE_OP_MANGLE_DELETE_LAST
:
20582 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
20585 case RULE_OP_MANGLE_DELETE_AT
:
20586 NEXT_RULEPOS (rule_pos
);
20587 NEXT_RPTOI (rule
, rule_pos
, upos
);
20588 out_len
= mangle_delete_at (out
, out_len
, upos
);
20591 case RULE_OP_MANGLE_EXTRACT
:
20592 NEXT_RULEPOS (rule_pos
);
20593 NEXT_RPTOI (rule
, rule_pos
, upos
);
20594 NEXT_RULEPOS (rule_pos
);
20595 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20596 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
20599 case RULE_OP_MANGLE_OMIT
:
20600 NEXT_RULEPOS (rule_pos
);
20601 NEXT_RPTOI (rule
, rule_pos
, upos
);
20602 NEXT_RULEPOS (rule_pos
);
20603 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20604 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
20607 case RULE_OP_MANGLE_INSERT
:
20608 NEXT_RULEPOS (rule_pos
);
20609 NEXT_RPTOI (rule
, rule_pos
, upos
);
20610 NEXT_RULEPOS (rule_pos
);
20611 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
20614 case RULE_OP_MANGLE_OVERSTRIKE
:
20615 NEXT_RULEPOS (rule_pos
);
20616 NEXT_RPTOI (rule
, rule_pos
, upos
);
20617 NEXT_RULEPOS (rule_pos
);
20618 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20621 case RULE_OP_MANGLE_TRUNCATE_AT
:
20622 NEXT_RULEPOS (rule_pos
);
20623 NEXT_RPTOI (rule
, rule_pos
, upos
);
20624 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20627 case RULE_OP_MANGLE_REPLACE
:
20628 NEXT_RULEPOS (rule_pos
);
20629 NEXT_RULEPOS (rule_pos
);
20630 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20633 case RULE_OP_MANGLE_PURGECHAR
:
20634 NEXT_RULEPOS (rule_pos
);
20635 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20638 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20642 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20643 NEXT_RULEPOS (rule_pos
);
20644 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20645 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20648 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20649 NEXT_RULEPOS (rule_pos
);
20650 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20651 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20654 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20655 out_len
= mangle_dupechar (out
, out_len
);
20658 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20659 NEXT_RULEPOS (rule_pos
);
20660 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20661 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20664 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20665 NEXT_RULEPOS (rule_pos
);
20666 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20667 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20670 case RULE_OP_MANGLE_SWITCH_FIRST
:
20671 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20674 case RULE_OP_MANGLE_SWITCH_LAST
:
20675 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20678 case RULE_OP_MANGLE_SWITCH_AT
:
20679 NEXT_RULEPOS (rule_pos
);
20680 NEXT_RPTOI (rule
, rule_pos
, upos
);
20681 NEXT_RULEPOS (rule_pos
);
20682 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20683 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20686 case RULE_OP_MANGLE_CHR_SHIFTL
:
20687 NEXT_RULEPOS (rule_pos
);
20688 NEXT_RPTOI (rule
, rule_pos
, upos
);
20689 mangle_chr_shiftl (out
, out_len
, upos
);
20692 case RULE_OP_MANGLE_CHR_SHIFTR
:
20693 NEXT_RULEPOS (rule_pos
);
20694 NEXT_RPTOI (rule
, rule_pos
, upos
);
20695 mangle_chr_shiftr (out
, out_len
, upos
);
20698 case RULE_OP_MANGLE_CHR_INCR
:
20699 NEXT_RULEPOS (rule_pos
);
20700 NEXT_RPTOI (rule
, rule_pos
, upos
);
20701 mangle_chr_incr (out
, out_len
, upos
);
20704 case RULE_OP_MANGLE_CHR_DECR
:
20705 NEXT_RULEPOS (rule_pos
);
20706 NEXT_RPTOI (rule
, rule_pos
, upos
);
20707 mangle_chr_decr (out
, out_len
, upos
);
20710 case RULE_OP_MANGLE_REPLACE_NP1
:
20711 NEXT_RULEPOS (rule_pos
);
20712 NEXT_RPTOI (rule
, rule_pos
, upos
);
20713 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20716 case RULE_OP_MANGLE_REPLACE_NM1
:
20717 NEXT_RULEPOS (rule_pos
);
20718 NEXT_RPTOI (rule
, rule_pos
, upos
);
20719 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20722 case RULE_OP_MANGLE_TITLE
:
20723 out_len
= mangle_title (out
, out_len
);
20726 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20727 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20728 NEXT_RULEPOS (rule_pos
);
20729 NEXT_RPTOI (rule
, rule_pos
, upos
);
20730 NEXT_RULEPOS (rule_pos
);
20731 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20732 NEXT_RULEPOS (rule_pos
);
20733 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20734 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20737 case RULE_OP_MANGLE_APPEND_MEMORY
:
20738 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20739 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20740 memcpy (out
+ out_len
, mem
, mem_len
);
20741 out_len
+= mem_len
;
20744 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20745 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20746 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20747 memcpy (mem
+ mem_len
, out
, out_len
);
20748 out_len
+= mem_len
;
20749 memcpy (out
, mem
, out_len
);
20752 case RULE_OP_MEMORIZE_WORD
:
20753 memcpy (mem
, out
, out_len
);
20757 case RULE_OP_REJECT_LESS
:
20758 NEXT_RULEPOS (rule_pos
);
20759 NEXT_RPTOI (rule
, rule_pos
, upos
);
20760 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20763 case RULE_OP_REJECT_GREATER
:
20764 NEXT_RULEPOS (rule_pos
);
20765 NEXT_RPTOI (rule
, rule_pos
, upos
);
20766 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20769 case RULE_OP_REJECT_CONTAIN
:
20770 NEXT_RULEPOS (rule_pos
);
20771 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20774 case RULE_OP_REJECT_NOT_CONTAIN
:
20775 NEXT_RULEPOS (rule_pos
);
20776 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20779 case RULE_OP_REJECT_EQUAL_FIRST
:
20780 NEXT_RULEPOS (rule_pos
);
20781 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20784 case RULE_OP_REJECT_EQUAL_LAST
:
20785 NEXT_RULEPOS (rule_pos
);
20786 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20789 case RULE_OP_REJECT_EQUAL_AT
:
20790 NEXT_RULEPOS (rule_pos
);
20791 NEXT_RPTOI (rule
, rule_pos
, upos
);
20792 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20793 NEXT_RULEPOS (rule_pos
);
20794 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20797 case RULE_OP_REJECT_CONTAINS
:
20798 NEXT_RULEPOS (rule_pos
);
20799 NEXT_RPTOI (rule
, rule_pos
, upos
);
20800 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20801 NEXT_RULEPOS (rule_pos
);
20802 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20803 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20806 case RULE_OP_REJECT_MEMORY
:
20807 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20811 return (RULE_RC_SYNTAX_ERROR
);
20816 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);