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;
4238 void set_cpu_affinity (char *cpu_affinity
)
4241 DWORD_PTR aff_mask
= 0;
4249 char *devices
= strdup (cpu_affinity
);
4251 char *next
= strtok (devices
, ",");
4255 uint cpu_id
= atoi (next
);
4270 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4276 aff_mask
|= 1 << (cpu_id
- 1);
4278 CPU_SET ((cpu_id
- 1), &cpuset
);
4281 } while ((next
= strtok (NULL
, ",")) != NULL
);
4287 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4288 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4290 pthread_t thread
= pthread_self ();
4291 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4295 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4297 char *element
, *end
;
4299 end
= (char *) base
+ nmemb
* size
;
4301 for (element
= (char *) base
; element
< end
; element
+= size
)
4302 if (!compar (element
, key
))
4308 int sort_by_salt (const void *v1
, const void *v2
)
4310 const salt_t
*s1
= (const salt_t
*) v1
;
4311 const salt_t
*s2
= (const salt_t
*) v2
;
4313 const int res1
= s1
->salt_len
- s2
->salt_len
;
4315 if (res1
!= 0) return (res1
);
4317 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4319 if (res2
!= 0) return (res2
);
4327 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4328 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4335 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4336 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4342 int sort_by_salt_buf (const void *v1
, const void *v2
)
4344 const pot_t
*p1
= (const pot_t
*) v1
;
4345 const pot_t
*p2
= (const pot_t
*) v2
;
4347 const hash_t
*h1
= &p1
->hash
;
4348 const hash_t
*h2
= &p2
->hash
;
4350 const salt_t
*s1
= h1
->salt
;
4351 const salt_t
*s2
= h2
->salt
;
4357 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4358 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4364 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4366 const hash_t
*h1
= (const hash_t
*) v1
;
4367 const hash_t
*h2
= (const hash_t
*) v2
;
4369 const salt_t
*s1
= h1
->salt
;
4370 const salt_t
*s2
= h2
->salt
;
4372 // testphase: this should work
4377 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4378 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4381 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4382 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4383 if (s1->salt_len > s2->salt_len) return ( 1);
4384 if (s1->salt_len < s2->salt_len) return (-1);
4386 uint n = s1->salt_len;
4390 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4391 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4398 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4400 const hash_t
*h1
= (const hash_t
*) v1
;
4401 const hash_t
*h2
= (const hash_t
*) v2
;
4403 const salt_t
*s1
= h1
->salt
;
4404 const salt_t
*s2
= h2
->salt
;
4406 // 16 - 2 (since last 2 uints contain the digest)
4411 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4412 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4418 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4420 const hash_t
*h1
= (const hash_t
*) v1
;
4421 const hash_t
*h2
= (const hash_t
*) v2
;
4423 const void *d1
= h1
->digest
;
4424 const void *d2
= h2
->digest
;
4426 return data
.sort_by_digest (d1
, d2
);
4429 int sort_by_hash (const void *v1
, const void *v2
)
4431 const hash_t
*h1
= (const hash_t
*) v1
;
4432 const hash_t
*h2
= (const hash_t
*) v2
;
4436 const salt_t
*s1
= h1
->salt
;
4437 const salt_t
*s2
= h2
->salt
;
4439 int res
= sort_by_salt (s1
, s2
);
4441 if (res
!= 0) return (res
);
4444 const void *d1
= h1
->digest
;
4445 const void *d2
= h2
->digest
;
4447 return data
.sort_by_digest (d1
, d2
);
4450 int sort_by_pot (const void *v1
, const void *v2
)
4452 const pot_t
*p1
= (const pot_t
*) v1
;
4453 const pot_t
*p2
= (const pot_t
*) v2
;
4455 const hash_t
*h1
= &p1
->hash
;
4456 const hash_t
*h2
= &p2
->hash
;
4458 return sort_by_hash (h1
, h2
);
4461 int sort_by_mtime (const void *p1
, const void *p2
)
4463 const char **f1
= (const char **) p1
;
4464 const char **f2
= (const char **) p2
;
4466 struct stat s1
; stat (*f1
, &s1
);
4467 struct stat s2
; stat (*f2
, &s2
);
4469 return s2
.st_mtime
- s1
.st_mtime
;
4472 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4474 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4475 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4477 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4480 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4482 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4483 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4485 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4488 int sort_by_stringptr (const void *p1
, const void *p2
)
4490 const char **s1
= (const char **) p1
;
4491 const char **s2
= (const char **) p2
;
4493 return strcmp (*s1
, *s2
);
4496 int sort_by_dictstat (const void *s1
, const void *s2
)
4498 dictstat_t
*d1
= (dictstat_t
*) s1
;
4499 dictstat_t
*d2
= (dictstat_t
*) s2
;
4502 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4504 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4507 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4510 int sort_by_bitmap (const void *p1
, const void *p2
)
4512 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4513 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4515 return b1
->collisions
- b2
->collisions
;
4518 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4520 const u32
*d1
= (const u32
*) v1
;
4521 const u32
*d2
= (const u32
*) v2
;
4527 if (d1
[n
] > d2
[n
]) return ( 1);
4528 if (d1
[n
] < d2
[n
]) return (-1);
4534 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4536 const u32
*d1
= (const u32
*) v1
;
4537 const u32
*d2
= (const u32
*) v2
;
4543 if (d1
[n
] > d2
[n
]) return ( 1);
4544 if (d1
[n
] < d2
[n
]) return (-1);
4550 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4552 const u32
*d1
= (const u32
*) v1
;
4553 const u32
*d2
= (const u32
*) v2
;
4559 if (d1
[n
] > d2
[n
]) return ( 1);
4560 if (d1
[n
] < d2
[n
]) return (-1);
4566 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4568 const u32
*d1
= (const u32
*) v1
;
4569 const u32
*d2
= (const u32
*) v2
;
4575 if (d1
[n
] > d2
[n
]) return ( 1);
4576 if (d1
[n
] < d2
[n
]) return (-1);
4582 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4584 const u32
*d1
= (const u32
*) v1
;
4585 const u32
*d2
= (const u32
*) v2
;
4591 if (d1
[n
] > d2
[n
]) return ( 1);
4592 if (d1
[n
] < d2
[n
]) return (-1);
4598 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4600 const u32
*d1
= (const u32
*) v1
;
4601 const u32
*d2
= (const u32
*) v2
;
4607 if (d1
[n
] > d2
[n
]) return ( 1);
4608 if (d1
[n
] < d2
[n
]) return (-1);
4614 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4616 const u32
*d1
= (const u32
*) v1
;
4617 const u32
*d2
= (const u32
*) v2
;
4623 if (d1
[n
] > d2
[n
]) return ( 1);
4624 if (d1
[n
] < d2
[n
]) return (-1);
4630 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4632 const u32
*d1
= (const u32
*) v1
;
4633 const u32
*d2
= (const u32
*) v2
;
4639 if (d1
[n
] > d2
[n
]) return ( 1);
4640 if (d1
[n
] < d2
[n
]) return (-1);
4646 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4648 const u64
*d1
= (const u64
*) v1
;
4649 const u64
*d2
= (const u64
*) v2
;
4655 if (d1
[n
] > d2
[n
]) return ( 1);
4656 if (d1
[n
] < d2
[n
]) return (-1);
4662 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4664 const u64
*d1
= (const u64
*) v1
;
4665 const u64
*d2
= (const u64
*) v2
;
4671 if (d1
[n
] > d2
[n
]) return ( 1);
4672 if (d1
[n
] < d2
[n
]) return (-1);
4678 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4680 const u64
*d1
= (const u64
*) v1
;
4681 const u64
*d2
= (const u64
*) v2
;
4687 if (d1
[n
] > d2
[n
]) return ( 1);
4688 if (d1
[n
] < d2
[n
]) return (-1);
4694 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4696 const u32
*d1
= (const u32
*) v1
;
4697 const u32
*d2
= (const u32
*) v2
;
4699 const uint dgst_pos0
= data
.dgst_pos0
;
4700 const uint dgst_pos1
= data
.dgst_pos1
;
4701 const uint dgst_pos2
= data
.dgst_pos2
;
4702 const uint dgst_pos3
= data
.dgst_pos3
;
4704 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4705 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4706 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4707 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4708 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4709 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4710 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4711 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4716 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
)
4718 uint outfile_autohex
= data
.outfile_autohex
;
4720 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4722 FILE *debug_fp
= NULL
;
4724 if (debug_file
!= NULL
)
4726 debug_fp
= fopen (debug_file
, "ab");
4728 lock_file (debug_fp
);
4735 if (debug_fp
== NULL
)
4737 log_info ("WARNING: Could not open debug-file for writing");
4741 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4743 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4745 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4748 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4750 if (debug_mode
== 4)
4752 fputc (':', debug_fp
);
4754 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4757 fputc ('\n', debug_fp
);
4759 if (debug_file
!= NULL
) fclose (debug_fp
);
4763 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4765 int needs_hexify
= 0;
4767 if (outfile_autohex
== 1)
4769 for (uint i
= 0; i
< plain_len
; i
++)
4771 if (plain_ptr
[i
] < 0x20)
4778 if (plain_ptr
[i
] > 0x7f)
4787 if (needs_hexify
== 1)
4789 fprintf (fp
, "$HEX[");
4791 for (uint i
= 0; i
< plain_len
; i
++)
4793 fprintf (fp
, "%02x", plain_ptr
[i
]);
4800 fwrite (plain_ptr
, plain_len
, 1, fp
);
4804 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
)
4806 uint outfile_format
= data
.outfile_format
;
4808 char separator
= data
.separator
;
4810 if (outfile_format
& OUTFILE_FMT_HASH
)
4812 fprintf (out_fp
, "%s", out_buf
);
4814 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4816 fputc (separator
, out_fp
);
4819 else if (data
.username
)
4821 if (username
!= NULL
)
4823 for (uint i
= 0; i
< user_len
; i
++)
4825 fprintf (out_fp
, "%c", username
[i
]);
4828 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4830 fputc (separator
, out_fp
);
4835 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4837 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4839 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4841 fputc (separator
, out_fp
);
4845 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4847 for (uint i
= 0; i
< plain_len
; i
++)
4849 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4852 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4854 fputc (separator
, out_fp
);
4858 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4861 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4866 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
4868 fprintf (out_fp
, "%llu", crackpos
);
4873 fputc ('\n', out_fp
);
4876 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
)
4880 pot_key
.hash
.salt
= hashes_buf
->salt
;
4881 pot_key
.hash
.digest
= hashes_buf
->digest
;
4883 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4889 input_buf
[input_len
] = 0;
4892 unsigned char *username
= NULL
;
4897 user_t
*user
= hashes_buf
->hash_info
->user
;
4901 username
= (unsigned char *) (user
->user_name
);
4903 user_len
= user
->user_len
;
4907 // do output the line
4908 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
4912 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
4913 #define LM_MASKED_PLAIN "[notfound]"
4915 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
)
4921 pot_left_key
.hash
.salt
= hash_left
->salt
;
4922 pot_left_key
.hash
.digest
= hash_left
->digest
;
4924 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4928 uint weak_hash_found
= 0;
4930 pot_t pot_right_key
;
4932 pot_right_key
.hash
.salt
= hash_right
->salt
;
4933 pot_right_key
.hash
.digest
= hash_right
->digest
;
4935 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4937 if (pot_right_ptr
== NULL
)
4939 // special case, if "weak hash"
4941 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
4943 weak_hash_found
= 1;
4945 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4947 // in theory this is not needed, but we are paranoia:
4949 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4950 pot_right_ptr
->plain_len
= 0;
4954 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
4956 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
4961 // at least one half was found:
4965 input_buf
[input_len
] = 0;
4969 unsigned char *username
= NULL
;
4974 user_t
*user
= hash_left
->hash_info
->user
;
4978 username
= (unsigned char *) (user
->user_name
);
4980 user_len
= user
->user_len
;
4984 // mask the part which was not found
4986 uint left_part_masked
= 0;
4987 uint right_part_masked
= 0;
4989 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
4991 if (pot_left_ptr
== NULL
)
4993 left_part_masked
= 1;
4995 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4997 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
4999 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5000 pot_left_ptr
->plain_len
= mask_plain_len
;
5003 if (pot_right_ptr
== NULL
)
5005 right_part_masked
= 1;
5007 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5009 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5011 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5012 pot_right_ptr
->plain_len
= mask_plain_len
;
5015 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5019 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5021 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5023 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5025 // do output the line
5027 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5029 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5031 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5032 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5035 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
)
5039 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5041 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5043 if (pot_ptr
== NULL
)
5047 input_buf
[input_len
] = 0;
5049 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5053 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
)
5059 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5061 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5065 pot_t pot_right_key
;
5067 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5069 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5071 uint weak_hash_found
= 0;
5073 if (pot_right_ptr
== NULL
)
5075 // special case, if "weak hash"
5077 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5079 weak_hash_found
= 1;
5081 // we just need that pot_right_ptr is not a NULL pointer
5083 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5087 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5089 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5094 // ... at least one part was not cracked
5098 input_buf
[input_len
] = 0;
5100 // only show the hash part which is still not cracked
5102 uint user_len
= input_len
- 32;
5104 char *hash_output
= (char *) mymalloc (33);
5106 memcpy (hash_output
, input_buf
, input_len
);
5108 if (pot_left_ptr
!= NULL
)
5110 // only show right part (because left part was already found)
5112 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5114 hash_output
[user_len
+ 16] = 0;
5117 if (pot_right_ptr
!= NULL
)
5119 // only show left part (because right part was already found)
5121 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5123 hash_output
[user_len
+ 16] = 0;
5126 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5128 myfree (hash_output
);
5130 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5133 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5135 uint opencl_platforms_filter
= 0;
5137 if (opencl_platforms
)
5139 char *platforms
= strdup (opencl_platforms
);
5141 char *next
= strtok (platforms
, ",");
5145 int platform
= atoi (next
);
5147 if (platform
< 1 || platform
> 32)
5149 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5154 opencl_platforms_filter
|= 1 << (platform
- 1);
5156 } while ((next
= strtok (NULL
, ",")) != NULL
);
5162 opencl_platforms_filter
= -1;
5165 return opencl_platforms_filter
;
5168 u32
setup_devices_filter (char *opencl_devices
)
5170 u32 devices_filter
= 0;
5174 char *devices
= strdup (opencl_devices
);
5176 char *next
= strtok (devices
, ",");
5180 int device_id
= atoi (next
);
5182 if (device_id
< 1 || device_id
> 32)
5184 log_error ("ERROR: invalid device_id %u specified", device_id
);
5189 devices_filter
|= 1 << (device_id
- 1);
5191 } while ((next
= strtok (NULL
, ",")) != NULL
);
5197 devices_filter
= -1;
5200 return devices_filter
;
5203 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5205 cl_device_type device_types_filter
= 0;
5207 if (opencl_device_types
)
5209 char *device_types
= strdup (opencl_device_types
);
5211 char *next
= strtok (device_types
, ",");
5215 int device_type
= atoi (next
);
5217 if (device_type
< 1 || device_type
> 3)
5219 log_error ("ERROR: invalid device_type %u specified", device_type
);
5224 device_types_filter
|= 1 << device_type
;
5226 } while ((next
= strtok (NULL
, ",")) != NULL
);
5228 free (device_types
);
5232 // Do not use CPU by default, this often reduces GPU performance because
5233 // the CPU is too busy to handle GPU synchronization
5235 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5238 return device_types_filter
;
5241 u32
get_random_num (const u32 min
, const u32 max
)
5243 if (min
== max
) return (min
);
5245 return ((rand () % (max
- min
)) + min
);
5248 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5250 u32 quotient
= dividend
/ divisor
;
5252 if (dividend
% divisor
) quotient
++;
5257 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5259 u64 quotient
= dividend
/ divisor
;
5261 if (dividend
% divisor
) quotient
++;
5266 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5268 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5269 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5271 if (tm
->tm_year
- 70)
5273 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5274 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5276 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5278 else if (tm
->tm_yday
)
5280 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5281 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5283 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5285 else if (tm
->tm_hour
)
5287 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5288 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5290 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5292 else if (tm
->tm_min
)
5294 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5295 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5297 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5301 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5303 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5307 void format_speed_display (float val
, char *buf
, size_t len
)
5318 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5329 /* generate output */
5333 snprintf (buf
, len
- 1, "%.0f ", val
);
5337 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5341 void lowercase (u8
*buf
, int len
)
5343 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5346 void uppercase (u8
*buf
, int len
)
5348 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5351 int fgetl (FILE *fp
, char *line_buf
)
5357 const int c
= fgetc (fp
);
5359 if (c
== EOF
) break;
5361 line_buf
[line_len
] = (char) c
;
5365 if (line_len
== BUFSIZ
) line_len
--;
5367 if (c
== '\n') break;
5370 if (line_len
== 0) return 0;
5372 if (line_buf
[line_len
- 1] == '\n')
5376 line_buf
[line_len
] = 0;
5379 if (line_len
== 0) return 0;
5381 if (line_buf
[line_len
- 1] == '\r')
5385 line_buf
[line_len
] = 0;
5391 int in_superchop (char *buf
)
5393 int len
= strlen (buf
);
5397 if (buf
[len
- 1] == '\n')
5404 if (buf
[len
- 1] == '\r')
5419 char **scan_directory (const char *path
)
5421 char *tmp_path
= mystrdup (path
);
5423 size_t tmp_path_len
= strlen (tmp_path
);
5425 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5427 tmp_path
[tmp_path_len
- 1] = 0;
5429 tmp_path_len
= strlen (tmp_path
);
5432 char **files
= NULL
;
5438 if ((d
= opendir (tmp_path
)) != NULL
)
5444 memset (&e
, 0, sizeof (e
));
5445 struct dirent
*de
= NULL
;
5447 if (readdir_r (d
, &e
, &de
) != 0)
5449 log_error ("ERROR: readdir_r() failed");
5454 if (de
== NULL
) break;
5458 while ((de
= readdir (d
)) != NULL
)
5461 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5463 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5465 char *path_file
= (char *) mymalloc (path_size
+ 1);
5467 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5469 path_file
[path_size
] = 0;
5473 if ((d_test
= opendir (path_file
)) != NULL
)
5481 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5485 files
[num_files
- 1] = path_file
;
5491 else if (errno
== ENOTDIR
)
5493 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5497 files
[num_files
- 1] = mystrdup (path
);
5500 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5504 files
[num_files
- 1] = NULL
;
5511 int count_dictionaries (char **dictionary_files
)
5513 if (dictionary_files
== NULL
) return 0;
5517 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5525 char *stroptitype (const uint opti_type
)
5529 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5530 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5531 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5532 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5533 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5534 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5535 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5536 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5537 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5538 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5539 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5540 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5541 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5542 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5543 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5544 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5545 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5546 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5552 char *strparser (const uint parser_status
)
5554 switch (parser_status
)
5556 case PARSER_OK
: return ((char *) PA_000
); break;
5557 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5558 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5559 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5560 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5561 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5562 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5563 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5564 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5565 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5566 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5567 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5568 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5569 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5570 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5571 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5572 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5575 return ((char *) PA_255
);
5578 char *strhashtype (const uint hash_mode
)
5582 case 0: return ((char *) HT_00000
); break;
5583 case 10: return ((char *) HT_00010
); break;
5584 case 11: return ((char *) HT_00011
); break;
5585 case 12: return ((char *) HT_00012
); break;
5586 case 20: return ((char *) HT_00020
); break;
5587 case 21: return ((char *) HT_00021
); break;
5588 case 22: return ((char *) HT_00022
); break;
5589 case 23: return ((char *) HT_00023
); break;
5590 case 30: return ((char *) HT_00030
); break;
5591 case 40: return ((char *) HT_00040
); break;
5592 case 50: return ((char *) HT_00050
); break;
5593 case 60: return ((char *) HT_00060
); break;
5594 case 100: return ((char *) HT_00100
); break;
5595 case 101: return ((char *) HT_00101
); break;
5596 case 110: return ((char *) HT_00110
); break;
5597 case 111: return ((char *) HT_00111
); break;
5598 case 112: return ((char *) HT_00112
); break;
5599 case 120: return ((char *) HT_00120
); break;
5600 case 121: return ((char *) HT_00121
); break;
5601 case 122: return ((char *) HT_00122
); break;
5602 case 124: return ((char *) HT_00124
); break;
5603 case 130: return ((char *) HT_00130
); break;
5604 case 131: return ((char *) HT_00131
); break;
5605 case 132: return ((char *) HT_00132
); break;
5606 case 133: return ((char *) HT_00133
); break;
5607 case 140: return ((char *) HT_00140
); break;
5608 case 141: return ((char *) HT_00141
); break;
5609 case 150: return ((char *) HT_00150
); break;
5610 case 160: return ((char *) HT_00160
); break;
5611 case 190: return ((char *) HT_00190
); break;
5612 case 200: return ((char *) HT_00200
); break;
5613 case 300: return ((char *) HT_00300
); break;
5614 case 400: return ((char *) HT_00400
); break;
5615 case 500: return ((char *) HT_00500
); break;
5616 case 501: return ((char *) HT_00501
); break;
5617 case 900: return ((char *) HT_00900
); break;
5618 case 910: return ((char *) HT_00910
); break;
5619 case 1000: return ((char *) HT_01000
); break;
5620 case 1100: return ((char *) HT_01100
); break;
5621 case 1400: return ((char *) HT_01400
); break;
5622 case 1410: return ((char *) HT_01410
); break;
5623 case 1420: return ((char *) HT_01420
); break;
5624 case 1421: return ((char *) HT_01421
); break;
5625 case 1430: return ((char *) HT_01430
); break;
5626 case 1440: return ((char *) HT_01440
); break;
5627 case 1441: return ((char *) HT_01441
); break;
5628 case 1450: return ((char *) HT_01450
); break;
5629 case 1460: return ((char *) HT_01460
); break;
5630 case 1500: return ((char *) HT_01500
); break;
5631 case 1600: return ((char *) HT_01600
); break;
5632 case 1700: return ((char *) HT_01700
); break;
5633 case 1710: return ((char *) HT_01710
); break;
5634 case 1711: return ((char *) HT_01711
); break;
5635 case 1720: return ((char *) HT_01720
); break;
5636 case 1722: return ((char *) HT_01722
); break;
5637 case 1730: return ((char *) HT_01730
); break;
5638 case 1731: return ((char *) HT_01731
); break;
5639 case 1740: return ((char *) HT_01740
); break;
5640 case 1750: return ((char *) HT_01750
); break;
5641 case 1760: return ((char *) HT_01760
); break;
5642 case 1800: return ((char *) HT_01800
); break;
5643 case 2100: return ((char *) HT_02100
); break;
5644 case 2400: return ((char *) HT_02400
); break;
5645 case 2410: return ((char *) HT_02410
); break;
5646 case 2500: return ((char *) HT_02500
); break;
5647 case 2600: return ((char *) HT_02600
); break;
5648 case 2611: return ((char *) HT_02611
); break;
5649 case 2612: return ((char *) HT_02612
); break;
5650 case 2711: return ((char *) HT_02711
); break;
5651 case 2811: return ((char *) HT_02811
); break;
5652 case 3000: return ((char *) HT_03000
); break;
5653 case 3100: return ((char *) HT_03100
); break;
5654 case 3200: return ((char *) HT_03200
); break;
5655 case 3710: return ((char *) HT_03710
); break;
5656 case 3711: return ((char *) HT_03711
); break;
5657 case 3800: return ((char *) HT_03800
); break;
5658 case 4300: return ((char *) HT_04300
); break;
5659 case 4400: return ((char *) HT_04400
); break;
5660 case 4500: return ((char *) HT_04500
); break;
5661 case 4700: return ((char *) HT_04700
); break;
5662 case 4800: return ((char *) HT_04800
); break;
5663 case 4900: return ((char *) HT_04900
); break;
5664 case 5000: return ((char *) HT_05000
); break;
5665 case 5100: return ((char *) HT_05100
); break;
5666 case 5200: return ((char *) HT_05200
); break;
5667 case 5300: return ((char *) HT_05300
); break;
5668 case 5400: return ((char *) HT_05400
); break;
5669 case 5500: return ((char *) HT_05500
); break;
5670 case 5600: return ((char *) HT_05600
); break;
5671 case 5700: return ((char *) HT_05700
); break;
5672 case 5800: return ((char *) HT_05800
); break;
5673 case 6000: return ((char *) HT_06000
); break;
5674 case 6100: return ((char *) HT_06100
); break;
5675 case 6211: return ((char *) HT_06211
); break;
5676 case 6212: return ((char *) HT_06212
); break;
5677 case 6213: return ((char *) HT_06213
); break;
5678 case 6221: return ((char *) HT_06221
); break;
5679 case 6222: return ((char *) HT_06222
); break;
5680 case 6223: return ((char *) HT_06223
); break;
5681 case 6231: return ((char *) HT_06231
); break;
5682 case 6232: return ((char *) HT_06232
); break;
5683 case 6233: return ((char *) HT_06233
); break;
5684 case 6241: return ((char *) HT_06241
); break;
5685 case 6242: return ((char *) HT_06242
); break;
5686 case 6243: return ((char *) HT_06243
); break;
5687 case 6300: return ((char *) HT_06300
); break;
5688 case 6400: return ((char *) HT_06400
); break;
5689 case 6500: return ((char *) HT_06500
); break;
5690 case 6600: return ((char *) HT_06600
); break;
5691 case 6700: return ((char *) HT_06700
); break;
5692 case 6800: return ((char *) HT_06800
); break;
5693 case 6900: return ((char *) HT_06900
); break;
5694 case 7100: return ((char *) HT_07100
); break;
5695 case 7200: return ((char *) HT_07200
); break;
5696 case 7300: return ((char *) HT_07300
); break;
5697 case 7400: return ((char *) HT_07400
); break;
5698 case 7500: return ((char *) HT_07500
); break;
5699 case 7600: return ((char *) HT_07600
); break;
5700 case 7700: return ((char *) HT_07700
); break;
5701 case 7800: return ((char *) HT_07800
); break;
5702 case 7900: return ((char *) HT_07900
); break;
5703 case 8000: return ((char *) HT_08000
); break;
5704 case 8100: return ((char *) HT_08100
); break;
5705 case 8200: return ((char *) HT_08200
); break;
5706 case 8300: return ((char *) HT_08300
); break;
5707 case 8400: return ((char *) HT_08400
); break;
5708 case 8500: return ((char *) HT_08500
); break;
5709 case 8600: return ((char *) HT_08600
); break;
5710 case 8700: return ((char *) HT_08700
); break;
5711 case 8800: return ((char *) HT_08800
); break;
5712 case 8900: return ((char *) HT_08900
); break;
5713 case 9000: return ((char *) HT_09000
); break;
5714 case 9100: return ((char *) HT_09100
); break;
5715 case 9200: return ((char *) HT_09200
); break;
5716 case 9300: return ((char *) HT_09300
); break;
5717 case 9400: return ((char *) HT_09400
); break;
5718 case 9500: return ((char *) HT_09500
); break;
5719 case 9600: return ((char *) HT_09600
); break;
5720 case 9700: return ((char *) HT_09700
); break;
5721 case 9710: return ((char *) HT_09710
); break;
5722 case 9720: return ((char *) HT_09720
); break;
5723 case 9800: return ((char *) HT_09800
); break;
5724 case 9810: return ((char *) HT_09810
); break;
5725 case 9820: return ((char *) HT_09820
); break;
5726 case 9900: return ((char *) HT_09900
); break;
5727 case 10000: return ((char *) HT_10000
); break;
5728 case 10100: return ((char *) HT_10100
); break;
5729 case 10200: return ((char *) HT_10200
); break;
5730 case 10300: return ((char *) HT_10300
); break;
5731 case 10400: return ((char *) HT_10400
); break;
5732 case 10410: return ((char *) HT_10410
); break;
5733 case 10420: return ((char *) HT_10420
); break;
5734 case 10500: return ((char *) HT_10500
); break;
5735 case 10600: return ((char *) HT_10600
); break;
5736 case 10700: return ((char *) HT_10700
); break;
5737 case 10800: return ((char *) HT_10800
); break;
5738 case 10900: return ((char *) HT_10900
); break;
5739 case 11000: return ((char *) HT_11000
); break;
5740 case 11100: return ((char *) HT_11100
); break;
5741 case 11200: return ((char *) HT_11200
); break;
5742 case 11300: return ((char *) HT_11300
); break;
5743 case 11400: return ((char *) HT_11400
); break;
5744 case 11500: return ((char *) HT_11500
); break;
5745 case 11600: return ((char *) HT_11600
); break;
5746 case 11700: return ((char *) HT_11700
); break;
5747 case 11800: return ((char *) HT_11800
); break;
5748 case 11900: return ((char *) HT_11900
); break;
5749 case 12000: return ((char *) HT_12000
); break;
5750 case 12100: return ((char *) HT_12100
); break;
5751 case 12200: return ((char *) HT_12200
); break;
5752 case 12300: return ((char *) HT_12300
); break;
5753 case 12400: return ((char *) HT_12400
); break;
5754 case 12500: return ((char *) HT_12500
); break;
5755 case 12600: return ((char *) HT_12600
); break;
5756 case 12700: return ((char *) HT_12700
); break;
5757 case 12800: return ((char *) HT_12800
); break;
5758 case 12900: return ((char *) HT_12900
); break;
5759 case 13000: return ((char *) HT_13000
); break;
5762 return ((char *) "Unknown");
5765 char *strstatus (const uint devices_status
)
5767 switch (devices_status
)
5769 case STATUS_INIT
: return ((char *) ST_0000
); break;
5770 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5771 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5772 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5773 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5774 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5775 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5776 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5777 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5778 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5781 return ((char *) "Unknown");
5784 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5786 uint hash_type
= data
.hash_type
;
5787 uint hash_mode
= data
.hash_mode
;
5788 uint salt_type
= data
.salt_type
;
5789 uint opts_type
= data
.opts_type
;
5790 uint opti_type
= data
.opti_type
;
5791 uint dgst_size
= data
.dgst_size
;
5793 char *hashfile
= data
.hashfile
;
5797 uint digest_buf
[64] = { 0 };
5799 u64
*digest_buf64
= (u64
*) digest_buf
;
5801 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5803 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5805 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5811 case HASH_TYPE_DESCRYPT
:
5812 FP (digest_buf
[1], digest_buf
[0], tt
);
5815 case HASH_TYPE_DESRACF
:
5816 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5817 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5819 FP (digest_buf
[1], digest_buf
[0], tt
);
5823 FP (digest_buf
[1], digest_buf
[0], tt
);
5826 case HASH_TYPE_NETNTLM
:
5827 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5828 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5829 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5830 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5832 FP (digest_buf
[1], digest_buf
[0], tt
);
5833 FP (digest_buf
[3], digest_buf
[2], tt
);
5836 case HASH_TYPE_BSDICRYPT
:
5837 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5838 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5840 FP (digest_buf
[1], digest_buf
[0], tt
);
5845 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5850 digest_buf
[0] += MD4M_A
;
5851 digest_buf
[1] += MD4M_B
;
5852 digest_buf
[2] += MD4M_C
;
5853 digest_buf
[3] += MD4M_D
;
5857 digest_buf
[0] += MD5M_A
;
5858 digest_buf
[1] += MD5M_B
;
5859 digest_buf
[2] += MD5M_C
;
5860 digest_buf
[3] += MD5M_D
;
5863 case HASH_TYPE_SHA1
:
5864 digest_buf
[0] += SHA1M_A
;
5865 digest_buf
[1] += SHA1M_B
;
5866 digest_buf
[2] += SHA1M_C
;
5867 digest_buf
[3] += SHA1M_D
;
5868 digest_buf
[4] += SHA1M_E
;
5871 case HASH_TYPE_SHA256
:
5872 digest_buf
[0] += SHA256M_A
;
5873 digest_buf
[1] += SHA256M_B
;
5874 digest_buf
[2] += SHA256M_C
;
5875 digest_buf
[3] += SHA256M_D
;
5876 digest_buf
[4] += SHA256M_E
;
5877 digest_buf
[5] += SHA256M_F
;
5878 digest_buf
[6] += SHA256M_G
;
5879 digest_buf
[7] += SHA256M_H
;
5882 case HASH_TYPE_SHA384
:
5883 digest_buf64
[0] += SHA384M_A
;
5884 digest_buf64
[1] += SHA384M_B
;
5885 digest_buf64
[2] += SHA384M_C
;
5886 digest_buf64
[3] += SHA384M_D
;
5887 digest_buf64
[4] += SHA384M_E
;
5888 digest_buf64
[5] += SHA384M_F
;
5889 digest_buf64
[6] += 0;
5890 digest_buf64
[7] += 0;
5893 case HASH_TYPE_SHA512
:
5894 digest_buf64
[0] += SHA512M_A
;
5895 digest_buf64
[1] += SHA512M_B
;
5896 digest_buf64
[2] += SHA512M_C
;
5897 digest_buf64
[3] += SHA512M_D
;
5898 digest_buf64
[4] += SHA512M_E
;
5899 digest_buf64
[5] += SHA512M_F
;
5900 digest_buf64
[6] += SHA512M_G
;
5901 digest_buf64
[7] += SHA512M_H
;
5906 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
5908 if (dgst_size
== DGST_SIZE_4_2
)
5910 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5912 else if (dgst_size
== DGST_SIZE_4_4
)
5914 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5916 else if (dgst_size
== DGST_SIZE_4_5
)
5918 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5920 else if (dgst_size
== DGST_SIZE_4_6
)
5922 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5924 else if (dgst_size
== DGST_SIZE_4_8
)
5926 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5928 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
5930 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
5932 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5934 else if (hash_type
== HASH_TYPE_SHA384
)
5936 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5938 else if (hash_type
== HASH_TYPE_SHA512
)
5940 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5942 else if (hash_type
== HASH_TYPE_GOST
)
5944 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5947 else if (dgst_size
== DGST_SIZE_4_64
)
5949 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5951 else if (dgst_size
== DGST_SIZE_8_25
)
5953 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5957 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
5958 | (data
.salt_type
== SALT_TYPE_EXTERN
)
5959 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
5965 memset (&salt
, 0, sizeof (salt_t
));
5967 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
5969 char *ptr
= (char *) salt
.salt_buf
;
5971 uint len
= salt
.salt_len
;
5973 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5979 case HASH_TYPE_NETNTLM
:
5981 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
5982 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
5984 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
5990 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
5992 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6000 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6002 uint max
= salt
.salt_len
/ 4;
6006 for (uint i
= 0; i
< max
; i
++)
6008 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6012 if (opts_type
& OPTS_TYPE_ST_HEX
)
6014 char tmp
[64] = { 0 };
6016 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6018 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6023 memcpy (ptr
, tmp
, len
);
6026 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6028 memset (ptr
+ len
, 0, memset_size
);
6030 salt
.salt_len
= len
;
6034 // some modes require special encoding
6037 uint out_buf_plain
[256] = { 0 };
6038 uint out_buf_salt
[256] = { 0 };
6040 char tmp_buf
[1024] = { 0 };
6042 char *ptr_plain
= (char *) out_buf_plain
;
6043 char *ptr_salt
= (char *) out_buf_salt
;
6045 if (hash_mode
== 22)
6047 char username
[30] = { 0 };
6049 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6051 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6053 u16
*ptr
= (u16
*) digest_buf
;
6055 tmp_buf
[ 0] = sig
[0];
6056 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6057 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6058 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6059 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6060 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6061 tmp_buf
[ 6] = sig
[1];
6062 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6063 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6064 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6065 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6066 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6067 tmp_buf
[12] = sig
[2];
6068 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6069 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6070 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6071 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6072 tmp_buf
[17] = sig
[3];
6073 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6074 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6075 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6076 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6077 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6078 tmp_buf
[23] = sig
[4];
6079 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6080 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6081 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6082 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6083 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6084 tmp_buf
[29] = sig
[5];
6086 snprintf (out_buf
, len
-1, "%s:%s",
6090 else if (hash_mode
== 23)
6092 // do not show the \nskyper\n part in output
6094 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6096 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6098 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6105 else if (hash_mode
== 101)
6107 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6109 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6110 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6111 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6112 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6113 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6115 memcpy (tmp_buf
, digest_buf
, 20);
6117 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6119 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6121 else if (hash_mode
== 111)
6123 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6125 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6126 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6127 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6128 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6129 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6131 memcpy (tmp_buf
, digest_buf
, 20);
6132 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6134 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6136 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6138 else if (hash_mode
== 122)
6140 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6141 (char *) salt
.salt_buf
,
6148 else if (hash_mode
== 124)
6150 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6151 (char *) salt
.salt_buf
,
6158 else if (hash_mode
== 131)
6160 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6161 (char *) salt
.salt_buf
,
6169 else if (hash_mode
== 132)
6171 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6172 (char *) salt
.salt_buf
,
6179 else if (hash_mode
== 133)
6181 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6183 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6184 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6185 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6186 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6187 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6189 memcpy (tmp_buf
, digest_buf
, 20);
6191 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6193 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6195 else if (hash_mode
== 141)
6197 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6199 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6201 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6203 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6205 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6206 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6207 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6208 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6209 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6211 memcpy (tmp_buf
, digest_buf
, 20);
6213 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6217 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6219 else if (hash_mode
== 400)
6221 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6223 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6224 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6225 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6226 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6228 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6230 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6232 else if (hash_mode
== 500)
6234 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6236 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6237 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6238 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6239 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6241 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6243 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6245 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6249 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6252 else if (hash_mode
== 501)
6254 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6256 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6257 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6259 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6261 else if (hash_mode
== 1421)
6263 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6265 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6281 else if (hash_mode
== 1441)
6283 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6285 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6287 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6289 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6291 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6292 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6293 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6294 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6295 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6296 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6297 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6298 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6300 memcpy (tmp_buf
, digest_buf
, 32);
6302 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6306 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6308 else if (hash_mode
== 1500)
6310 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6311 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6312 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6313 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6314 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6316 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6318 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6320 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6321 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6323 memcpy (tmp_buf
, digest_buf
, 8);
6325 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6327 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6331 else if (hash_mode
== 1600)
6333 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6335 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6336 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6337 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6338 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6340 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6342 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6344 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6348 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6351 else if (hash_mode
== 1711)
6353 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6355 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6356 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6357 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6358 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6359 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6360 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6361 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6362 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6364 memcpy (tmp_buf
, digest_buf
, 64);
6365 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6367 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6369 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6371 else if (hash_mode
== 1722)
6373 uint
*ptr
= digest_buf
;
6375 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6376 (unsigned char *) salt
.salt_buf
,
6386 else if (hash_mode
== 1731)
6388 uint
*ptr
= digest_buf
;
6390 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6391 (unsigned char *) salt
.salt_buf
,
6401 else if (hash_mode
== 1800)
6405 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6406 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6407 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6408 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6409 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6410 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6411 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6412 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6414 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6416 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6418 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6422 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6425 else if (hash_mode
== 2100)
6429 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6431 salt
.salt_iter
+ 1);
6433 uint signature_len
= strlen (out_buf
);
6435 pos
+= signature_len
;
6436 len
-= signature_len
;
6438 char *salt_ptr
= (char *) salt
.salt_buf
;
6440 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6442 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6443 byte_swap_32 (digest_buf
[0]),
6444 byte_swap_32 (digest_buf
[1]),
6445 byte_swap_32 (digest_buf
[2]),
6446 byte_swap_32 (digest_buf
[3]));
6448 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6450 memcpy (tmp_buf
, digest_buf
, 16);
6452 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6454 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6455 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6456 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6457 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6459 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6460 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6461 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6462 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6464 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6465 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6466 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6467 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6469 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6470 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6471 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6472 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6474 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6475 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6476 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6477 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6481 else if (hash_mode
== 2500)
6483 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6485 wpa_t
*wpa
= &wpas
[salt_pos
];
6487 uint pke
[25] = { 0 };
6489 char *pke_ptr
= (char *) pke
;
6491 for (uint i
= 0; i
< 25; i
++)
6493 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6496 unsigned char mac1
[6] = { 0 };
6497 unsigned char mac2
[6] = { 0 };
6499 memcpy (mac1
, pke_ptr
+ 23, 6);
6500 memcpy (mac2
, pke_ptr
+ 29, 6);
6502 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6503 (char *) salt
.salt_buf
,
6517 else if (hash_mode
== 4400)
6519 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6520 byte_swap_32 (digest_buf
[0]),
6521 byte_swap_32 (digest_buf
[1]),
6522 byte_swap_32 (digest_buf
[2]),
6523 byte_swap_32 (digest_buf
[3]));
6525 else if (hash_mode
== 4700)
6527 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6528 byte_swap_32 (digest_buf
[0]),
6529 byte_swap_32 (digest_buf
[1]),
6530 byte_swap_32 (digest_buf
[2]),
6531 byte_swap_32 (digest_buf
[3]),
6532 byte_swap_32 (digest_buf
[4]));
6534 else if (hash_mode
== 4800)
6536 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6538 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6543 byte_swap_32 (salt
.salt_buf
[0]),
6544 byte_swap_32 (salt
.salt_buf
[1]),
6545 byte_swap_32 (salt
.salt_buf
[2]),
6546 byte_swap_32 (salt
.salt_buf
[3]),
6549 else if (hash_mode
== 4900)
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
== 5100)
6560 snprintf (out_buf
, len
-1, "%08x%08x",
6564 else if (hash_mode
== 5200)
6566 snprintf (out_buf
, len
-1, "%s", hashfile
);
6568 else if (hash_mode
== 5300)
6570 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6572 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6574 int buf_len
= len
-1;
6578 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6580 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6582 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6584 snprintf (out_buf
, buf_len
, ":");
6590 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6598 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6600 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6602 if ((i
== 0) || (i
== 5))
6604 snprintf (out_buf
, buf_len
, ":");
6610 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6618 for (uint i
= 0; i
< 4; i
++)
6622 snprintf (out_buf
, buf_len
, ":");
6628 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6634 else if (hash_mode
== 5400)
6636 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6638 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6640 int buf_len
= len
-1;
6644 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6646 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6648 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6650 snprintf (out_buf
, buf_len
, ":");
6656 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6664 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6666 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6668 if ((i
== 0) || (i
== 5))
6670 snprintf (out_buf
, buf_len
, ":");
6676 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6684 for (uint i
= 0; i
< 5; i
++)
6688 snprintf (out_buf
, buf_len
, ":");
6694 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6700 else if (hash_mode
== 5500)
6702 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6704 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6706 char user_buf
[64] = { 0 };
6707 char domain_buf
[64] = { 0 };
6708 char srvchall_buf
[1024] = { 0 };
6709 char clichall_buf
[1024] = { 0 };
6711 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6713 char *ptr
= (char *) netntlm
->userdomain_buf
;
6715 user_buf
[i
] = ptr
[j
];
6718 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6720 char *ptr
= (char *) netntlm
->userdomain_buf
;
6722 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6725 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6727 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6729 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6732 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6734 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6736 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6739 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6747 byte_swap_32 (salt
.salt_buf_pc
[0]),
6748 byte_swap_32 (salt
.salt_buf_pc
[1]),
6751 else if (hash_mode
== 5600)
6753 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6755 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6757 char user_buf
[64] = { 0 };
6758 char domain_buf
[64] = { 0 };
6759 char srvchall_buf
[1024] = { 0 };
6760 char clichall_buf
[1024] = { 0 };
6762 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6764 char *ptr
= (char *) netntlm
->userdomain_buf
;
6766 user_buf
[i
] = ptr
[j
];
6769 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6771 char *ptr
= (char *) netntlm
->userdomain_buf
;
6773 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6776 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6778 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6780 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6783 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6785 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6787 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6790 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6800 else if (hash_mode
== 5700)
6802 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6804 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6805 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6806 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6807 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6808 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6809 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6810 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6811 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6813 memcpy (tmp_buf
, digest_buf
, 32);
6815 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6819 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6821 else if (hash_mode
== 5800)
6823 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6824 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6825 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6826 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6827 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6829 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6836 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6838 snprintf (out_buf
, len
-1, "%s", hashfile
);
6840 else if (hash_mode
== 6300)
6842 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6844 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6845 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6846 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6847 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6849 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6851 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6853 else if (hash_mode
== 6400)
6855 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6857 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6859 else if (hash_mode
== 6500)
6861 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6863 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6865 else if (hash_mode
== 6600)
6867 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6869 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6871 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6872 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6874 uint buf_len
= len
- 1;
6876 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6879 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6881 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6886 else if (hash_mode
== 6700)
6888 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6890 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6892 else if (hash_mode
== 6800)
6894 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6896 else if (hash_mode
== 7100)
6898 uint
*ptr
= digest_buf
;
6900 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6902 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6904 uint esalt
[8] = { 0 };
6906 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6907 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6908 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6909 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6910 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6911 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6912 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6913 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6915 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",
6916 SIGNATURE_SHA512OSX
,
6918 esalt
[ 0], esalt
[ 1],
6919 esalt
[ 2], esalt
[ 3],
6920 esalt
[ 4], esalt
[ 5],
6921 esalt
[ 6], esalt
[ 7],
6929 ptr
[15], ptr
[14]);
6931 else if (hash_mode
== 7200)
6933 uint
*ptr
= digest_buf
;
6935 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6937 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6941 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
6943 len_used
= strlen (out_buf
);
6945 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
6947 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
6949 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
6952 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",
6960 ptr
[15], ptr
[14]);
6962 else if (hash_mode
== 7300)
6964 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
6966 rakp_t
*rakp
= &rakps
[salt_pos
];
6968 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
6970 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
6973 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
6980 else if (hash_mode
== 7400)
6982 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6984 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6985 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6986 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6987 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6988 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6989 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6990 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6991 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6993 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6995 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
6997 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7001 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7004 else if (hash_mode
== 7500)
7006 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7008 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7010 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7011 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7013 char data
[128] = { 0 };
7015 char *ptr_data
= data
;
7017 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7019 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7022 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7024 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7029 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7031 (char *) krb5pa
->user
,
7032 (char *) krb5pa
->realm
,
7033 (char *) krb5pa
->salt
,
7036 else if (hash_mode
== 7700)
7038 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7039 (char *) salt
.salt_buf
,
7043 else if (hash_mode
== 7800)
7045 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7046 (char *) salt
.salt_buf
,
7053 else if (hash_mode
== 7900)
7055 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7059 char *tmp
= (char *) salt
.salt_buf_pc
;
7061 ptr_plain
[42] = tmp
[0];
7067 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7069 else if (hash_mode
== 8000)
7071 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7072 (unsigned char *) salt
.salt_buf
,
7082 else if (hash_mode
== 8100)
7084 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7085 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7087 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7088 (unsigned char *) salt
.salt_buf
,
7095 else if (hash_mode
== 8200)
7097 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7099 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7101 char data_buf
[4096] = { 0 };
7103 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7105 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7108 data_buf
[cloudkey
->data_len
* 2] = 0;
7110 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7111 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7112 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7113 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7114 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7115 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7116 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7117 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7119 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7120 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7121 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7122 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7124 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7140 else if (hash_mode
== 8300)
7142 char digest_buf_c
[34] = { 0 };
7144 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7146 digest_buf_c
[32] = 0;
7150 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7152 char domain_buf_c
[33] = { 0 };
7154 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7156 for (uint i
= 0; i
< salt_pc_len
; i
++)
7158 const char next
= domain_buf_c
[i
];
7160 domain_buf_c
[i
] = '.';
7165 domain_buf_c
[salt_pc_len
] = 0;
7169 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7171 else if (hash_mode
== 8500)
7173 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7175 else if (hash_mode
== 2612)
7177 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7179 (char *) salt
.salt_buf
,
7185 else if (hash_mode
== 3711)
7187 char *salt_ptr
= (char *) salt
.salt_buf
;
7189 salt_ptr
[salt
.salt_len
- 1] = 0;
7191 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7192 SIGNATURE_MEDIAWIKI_B
,
7199 else if (hash_mode
== 8800)
7201 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7203 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7205 char tmp
[3073] = { 0 };
7207 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7209 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7214 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7215 SIGNATURE_ANDROIDFDE
,
7216 byte_swap_32 (salt
.salt_buf
[0]),
7217 byte_swap_32 (salt
.salt_buf
[1]),
7218 byte_swap_32 (salt
.salt_buf
[2]),
7219 byte_swap_32 (salt
.salt_buf
[3]),
7220 byte_swap_32 (digest_buf
[0]),
7221 byte_swap_32 (digest_buf
[1]),
7222 byte_swap_32 (digest_buf
[2]),
7223 byte_swap_32 (digest_buf
[3]),
7226 else if (hash_mode
== 8900)
7228 uint N
= salt
.scrypt_N
;
7229 uint r
= salt
.scrypt_r
;
7230 uint p
= salt
.scrypt_p
;
7232 char base64_salt
[32] = { 0 };
7234 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7236 memset (tmp_buf
, 0, 46);
7238 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7239 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7240 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7241 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7242 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7243 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7244 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7245 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7246 digest_buf
[8] = 0; // needed for base64_encode ()
7248 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7250 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7258 else if (hash_mode
== 9000)
7260 snprintf (out_buf
, len
-1, "%s", hashfile
);
7262 else if (hash_mode
== 9200)
7266 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7268 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7270 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7274 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7275 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7276 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7277 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7278 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7279 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7280 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7281 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7282 digest_buf
[8] = 0; // needed for base64_encode ()
7284 char tmp_buf
[64] = { 0 };
7286 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7287 tmp_buf
[43] = 0; // cut it here
7291 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7293 else if (hash_mode
== 9300)
7295 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7296 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7297 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7298 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7299 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7300 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7301 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7302 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7303 digest_buf
[8] = 0; // needed for base64_encode ()
7305 char tmp_buf
[64] = { 0 };
7307 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7308 tmp_buf
[43] = 0; // cut it here
7310 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7312 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7314 else if (hash_mode
== 9400)
7316 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7318 office2007_t
*office2007
= &office2007s
[salt_pos
];
7320 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7321 SIGNATURE_OFFICE2007
,
7324 office2007
->keySize
,
7330 office2007
->encryptedVerifier
[0],
7331 office2007
->encryptedVerifier
[1],
7332 office2007
->encryptedVerifier
[2],
7333 office2007
->encryptedVerifier
[3],
7334 office2007
->encryptedVerifierHash
[0],
7335 office2007
->encryptedVerifierHash
[1],
7336 office2007
->encryptedVerifierHash
[2],
7337 office2007
->encryptedVerifierHash
[3],
7338 office2007
->encryptedVerifierHash
[4]);
7340 else if (hash_mode
== 9500)
7342 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7344 office2010_t
*office2010
= &office2010s
[salt_pos
];
7346 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,
7352 office2010
->encryptedVerifier
[0],
7353 office2010
->encryptedVerifier
[1],
7354 office2010
->encryptedVerifier
[2],
7355 office2010
->encryptedVerifier
[3],
7356 office2010
->encryptedVerifierHash
[0],
7357 office2010
->encryptedVerifierHash
[1],
7358 office2010
->encryptedVerifierHash
[2],
7359 office2010
->encryptedVerifierHash
[3],
7360 office2010
->encryptedVerifierHash
[4],
7361 office2010
->encryptedVerifierHash
[5],
7362 office2010
->encryptedVerifierHash
[6],
7363 office2010
->encryptedVerifierHash
[7]);
7365 else if (hash_mode
== 9600)
7367 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7369 office2013_t
*office2013
= &office2013s
[salt_pos
];
7371 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,
7377 office2013
->encryptedVerifier
[0],
7378 office2013
->encryptedVerifier
[1],
7379 office2013
->encryptedVerifier
[2],
7380 office2013
->encryptedVerifier
[3],
7381 office2013
->encryptedVerifierHash
[0],
7382 office2013
->encryptedVerifierHash
[1],
7383 office2013
->encryptedVerifierHash
[2],
7384 office2013
->encryptedVerifierHash
[3],
7385 office2013
->encryptedVerifierHash
[4],
7386 office2013
->encryptedVerifierHash
[5],
7387 office2013
->encryptedVerifierHash
[6],
7388 office2013
->encryptedVerifierHash
[7]);
7390 else if (hash_mode
== 9700)
7392 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7394 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7396 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7397 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7398 byte_swap_32 (salt
.salt_buf
[0]),
7399 byte_swap_32 (salt
.salt_buf
[1]),
7400 byte_swap_32 (salt
.salt_buf
[2]),
7401 byte_swap_32 (salt
.salt_buf
[3]),
7402 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7403 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7404 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7405 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7406 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7407 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7408 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7409 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7411 else if (hash_mode
== 9710)
7413 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7415 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7417 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7418 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7419 byte_swap_32 (salt
.salt_buf
[0]),
7420 byte_swap_32 (salt
.salt_buf
[1]),
7421 byte_swap_32 (salt
.salt_buf
[2]),
7422 byte_swap_32 (salt
.salt_buf
[3]),
7423 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7424 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7425 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7426 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7427 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7428 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7429 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7430 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7432 else if (hash_mode
== 9720)
7434 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7436 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7438 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7440 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7441 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7442 byte_swap_32 (salt
.salt_buf
[0]),
7443 byte_swap_32 (salt
.salt_buf
[1]),
7444 byte_swap_32 (salt
.salt_buf
[2]),
7445 byte_swap_32 (salt
.salt_buf
[3]),
7446 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7447 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7448 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7449 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7450 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7451 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7452 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7453 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7460 else if (hash_mode
== 9800)
7462 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7464 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7466 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7467 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7472 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7473 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7474 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7475 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7476 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7477 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7478 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7479 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7480 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7482 else if (hash_mode
== 9810)
7484 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7486 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7488 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7489 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7494 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7495 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7496 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7497 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7498 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7499 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7500 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7501 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7502 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7504 else if (hash_mode
== 9820)
7506 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7508 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7510 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7512 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
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]),
7533 else if (hash_mode
== 10000)
7537 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7539 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7541 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7545 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7546 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7547 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7548 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7549 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7550 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7551 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7552 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7553 digest_buf
[8] = 0; // needed for base64_encode ()
7555 char tmp_buf
[64] = { 0 };
7557 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7561 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7563 else if (hash_mode
== 10100)
7565 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7570 byte_swap_32 (salt
.salt_buf
[0]),
7571 byte_swap_32 (salt
.salt_buf
[1]),
7572 byte_swap_32 (salt
.salt_buf
[2]),
7573 byte_swap_32 (salt
.salt_buf
[3]));
7575 else if (hash_mode
== 10200)
7577 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7579 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7583 char challenge
[100] = { 0 };
7585 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7589 char tmp_buf
[100] = { 0 };
7591 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7592 (char *) cram_md5
->user
,
7598 char response
[100] = { 0 };
7600 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7602 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7604 else if (hash_mode
== 10300)
7606 char tmp_buf
[100] = { 0 };
7608 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7609 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7611 uint tmp_len
= 20 + salt
.salt_len
;
7615 char base64_encoded
[100] = { 0 };
7617 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7619 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7621 else if (hash_mode
== 10400)
7623 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7625 pdf_t
*pdf
= &pdfs
[salt_pos
];
7627 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",
7635 byte_swap_32 (pdf
->id_buf
[0]),
7636 byte_swap_32 (pdf
->id_buf
[1]),
7637 byte_swap_32 (pdf
->id_buf
[2]),
7638 byte_swap_32 (pdf
->id_buf
[3]),
7640 byte_swap_32 (pdf
->u_buf
[0]),
7641 byte_swap_32 (pdf
->u_buf
[1]),
7642 byte_swap_32 (pdf
->u_buf
[2]),
7643 byte_swap_32 (pdf
->u_buf
[3]),
7644 byte_swap_32 (pdf
->u_buf
[4]),
7645 byte_swap_32 (pdf
->u_buf
[5]),
7646 byte_swap_32 (pdf
->u_buf
[6]),
7647 byte_swap_32 (pdf
->u_buf
[7]),
7649 byte_swap_32 (pdf
->o_buf
[0]),
7650 byte_swap_32 (pdf
->o_buf
[1]),
7651 byte_swap_32 (pdf
->o_buf
[2]),
7652 byte_swap_32 (pdf
->o_buf
[3]),
7653 byte_swap_32 (pdf
->o_buf
[4]),
7654 byte_swap_32 (pdf
->o_buf
[5]),
7655 byte_swap_32 (pdf
->o_buf
[6]),
7656 byte_swap_32 (pdf
->o_buf
[7])
7659 else if (hash_mode
== 10410)
7661 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7663 pdf_t
*pdf
= &pdfs
[salt_pos
];
7665 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",
7673 byte_swap_32 (pdf
->id_buf
[0]),
7674 byte_swap_32 (pdf
->id_buf
[1]),
7675 byte_swap_32 (pdf
->id_buf
[2]),
7676 byte_swap_32 (pdf
->id_buf
[3]),
7678 byte_swap_32 (pdf
->u_buf
[0]),
7679 byte_swap_32 (pdf
->u_buf
[1]),
7680 byte_swap_32 (pdf
->u_buf
[2]),
7681 byte_swap_32 (pdf
->u_buf
[3]),
7682 byte_swap_32 (pdf
->u_buf
[4]),
7683 byte_swap_32 (pdf
->u_buf
[5]),
7684 byte_swap_32 (pdf
->u_buf
[6]),
7685 byte_swap_32 (pdf
->u_buf
[7]),
7687 byte_swap_32 (pdf
->o_buf
[0]),
7688 byte_swap_32 (pdf
->o_buf
[1]),
7689 byte_swap_32 (pdf
->o_buf
[2]),
7690 byte_swap_32 (pdf
->o_buf
[3]),
7691 byte_swap_32 (pdf
->o_buf
[4]),
7692 byte_swap_32 (pdf
->o_buf
[5]),
7693 byte_swap_32 (pdf
->o_buf
[6]),
7694 byte_swap_32 (pdf
->o_buf
[7])
7697 else if (hash_mode
== 10420)
7699 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7701 pdf_t
*pdf
= &pdfs
[salt_pos
];
7703 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7705 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",
7713 byte_swap_32 (pdf
->id_buf
[0]),
7714 byte_swap_32 (pdf
->id_buf
[1]),
7715 byte_swap_32 (pdf
->id_buf
[2]),
7716 byte_swap_32 (pdf
->id_buf
[3]),
7718 byte_swap_32 (pdf
->u_buf
[0]),
7719 byte_swap_32 (pdf
->u_buf
[1]),
7720 byte_swap_32 (pdf
->u_buf
[2]),
7721 byte_swap_32 (pdf
->u_buf
[3]),
7722 byte_swap_32 (pdf
->u_buf
[4]),
7723 byte_swap_32 (pdf
->u_buf
[5]),
7724 byte_swap_32 (pdf
->u_buf
[6]),
7725 byte_swap_32 (pdf
->u_buf
[7]),
7727 byte_swap_32 (pdf
->o_buf
[0]),
7728 byte_swap_32 (pdf
->o_buf
[1]),
7729 byte_swap_32 (pdf
->o_buf
[2]),
7730 byte_swap_32 (pdf
->o_buf
[3]),
7731 byte_swap_32 (pdf
->o_buf
[4]),
7732 byte_swap_32 (pdf
->o_buf
[5]),
7733 byte_swap_32 (pdf
->o_buf
[6]),
7734 byte_swap_32 (pdf
->o_buf
[7]),
7742 else if (hash_mode
== 10500)
7744 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7746 pdf_t
*pdf
= &pdfs
[salt_pos
];
7748 if (pdf
->id_len
== 32)
7750 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",
7758 byte_swap_32 (pdf
->id_buf
[0]),
7759 byte_swap_32 (pdf
->id_buf
[1]),
7760 byte_swap_32 (pdf
->id_buf
[2]),
7761 byte_swap_32 (pdf
->id_buf
[3]),
7762 byte_swap_32 (pdf
->id_buf
[4]),
7763 byte_swap_32 (pdf
->id_buf
[5]),
7764 byte_swap_32 (pdf
->id_buf
[6]),
7765 byte_swap_32 (pdf
->id_buf
[7]),
7767 byte_swap_32 (pdf
->u_buf
[0]),
7768 byte_swap_32 (pdf
->u_buf
[1]),
7769 byte_swap_32 (pdf
->u_buf
[2]),
7770 byte_swap_32 (pdf
->u_buf
[3]),
7771 byte_swap_32 (pdf
->u_buf
[4]),
7772 byte_swap_32 (pdf
->u_buf
[5]),
7773 byte_swap_32 (pdf
->u_buf
[6]),
7774 byte_swap_32 (pdf
->u_buf
[7]),
7776 byte_swap_32 (pdf
->o_buf
[0]),
7777 byte_swap_32 (pdf
->o_buf
[1]),
7778 byte_swap_32 (pdf
->o_buf
[2]),
7779 byte_swap_32 (pdf
->o_buf
[3]),
7780 byte_swap_32 (pdf
->o_buf
[4]),
7781 byte_swap_32 (pdf
->o_buf
[5]),
7782 byte_swap_32 (pdf
->o_buf
[6]),
7783 byte_swap_32 (pdf
->o_buf
[7])
7788 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",
7796 byte_swap_32 (pdf
->id_buf
[0]),
7797 byte_swap_32 (pdf
->id_buf
[1]),
7798 byte_swap_32 (pdf
->id_buf
[2]),
7799 byte_swap_32 (pdf
->id_buf
[3]),
7801 byte_swap_32 (pdf
->u_buf
[0]),
7802 byte_swap_32 (pdf
->u_buf
[1]),
7803 byte_swap_32 (pdf
->u_buf
[2]),
7804 byte_swap_32 (pdf
->u_buf
[3]),
7805 byte_swap_32 (pdf
->u_buf
[4]),
7806 byte_swap_32 (pdf
->u_buf
[5]),
7807 byte_swap_32 (pdf
->u_buf
[6]),
7808 byte_swap_32 (pdf
->u_buf
[7]),
7810 byte_swap_32 (pdf
->o_buf
[0]),
7811 byte_swap_32 (pdf
->o_buf
[1]),
7812 byte_swap_32 (pdf
->o_buf
[2]),
7813 byte_swap_32 (pdf
->o_buf
[3]),
7814 byte_swap_32 (pdf
->o_buf
[4]),
7815 byte_swap_32 (pdf
->o_buf
[5]),
7816 byte_swap_32 (pdf
->o_buf
[6]),
7817 byte_swap_32 (pdf
->o_buf
[7])
7821 else if (hash_mode
== 10600)
7823 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7825 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7826 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7828 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7830 else if (hash_mode
== 10700)
7832 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7834 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7835 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7837 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7839 else if (hash_mode
== 10900)
7841 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7843 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7844 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7846 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7848 else if (hash_mode
== 11100)
7850 u32 salt_challenge
= salt
.salt_buf
[0];
7852 salt_challenge
= byte_swap_32 (salt_challenge
);
7854 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7856 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7857 SIGNATURE_POSTGRESQL_AUTH
,
7865 else if (hash_mode
== 11200)
7867 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7868 SIGNATURE_MYSQL_AUTH
,
7869 (unsigned char *) salt
.salt_buf
,
7876 else if (hash_mode
== 11300)
7878 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7880 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7882 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7883 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7884 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7886 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7887 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7888 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7890 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7892 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7894 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7897 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7899 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7901 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7904 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7906 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
7908 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7911 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
7912 SIGNATURE_BITCOIN_WALLET
,
7916 (unsigned char *) salt
.salt_buf
,
7924 free (cry_master_buf
);
7926 free (public_key_buf
);
7928 else if (hash_mode
== 11400)
7930 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7932 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7933 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7935 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7937 else if (hash_mode
== 11600)
7939 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
7941 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
7943 const uint data_len
= seven_zip
->data_len
;
7945 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
7947 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
7949 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
7951 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
7954 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
7955 SIGNATURE_SEVEN_ZIP
,
7959 (char *) seven_zip
->salt_buf
,
7961 seven_zip
->iv_buf
[0],
7962 seven_zip
->iv_buf
[1],
7963 seven_zip
->iv_buf
[2],
7964 seven_zip
->iv_buf
[3],
7966 seven_zip
->data_len
,
7967 seven_zip
->unpack_size
,
7972 else if (hash_mode
== 11700)
7974 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
7984 else if (hash_mode
== 11800)
7986 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8004 else if (hash_mode
== 11900)
8006 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8008 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8009 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8011 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8013 else if (hash_mode
== 12000)
8015 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8017 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8018 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8020 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8022 else if (hash_mode
== 12100)
8024 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8026 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8027 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8029 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8031 else if (hash_mode
== 12200)
8033 uint
*ptr_digest
= digest_buf
;
8034 uint
*ptr_salt
= salt
.salt_buf
;
8036 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8043 else if (hash_mode
== 12300)
8045 uint
*ptr_digest
= digest_buf
;
8046 uint
*ptr_salt
= salt
.salt_buf
;
8048 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",
8049 ptr_digest
[ 0], ptr_digest
[ 1],
8050 ptr_digest
[ 2], ptr_digest
[ 3],
8051 ptr_digest
[ 4], ptr_digest
[ 5],
8052 ptr_digest
[ 6], ptr_digest
[ 7],
8053 ptr_digest
[ 8], ptr_digest
[ 9],
8054 ptr_digest
[10], ptr_digest
[11],
8055 ptr_digest
[12], ptr_digest
[13],
8056 ptr_digest
[14], ptr_digest
[15],
8062 else if (hash_mode
== 12400)
8064 // encode iteration count
8066 char salt_iter
[5] = { 0 };
8068 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8069 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8070 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8071 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8076 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8077 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8078 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8079 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8084 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8086 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8087 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8089 memcpy (tmp_buf
, digest_buf
, 8);
8091 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8095 // fill the resulting buffer
8097 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8099 else if (hash_mode
== 12500)
8101 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8103 byte_swap_32 (salt
.salt_buf
[0]),
8104 byte_swap_32 (salt
.salt_buf
[1]),
8110 else if (hash_mode
== 12600)
8112 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8113 digest_buf
[0] + salt
.salt_buf_pc
[0],
8114 digest_buf
[1] + salt
.salt_buf_pc
[1],
8115 digest_buf
[2] + salt
.salt_buf_pc
[2],
8116 digest_buf
[3] + salt
.salt_buf_pc
[3],
8117 digest_buf
[4] + salt
.salt_buf_pc
[4],
8118 digest_buf
[5] + salt
.salt_buf_pc
[5],
8119 digest_buf
[6] + salt
.salt_buf_pc
[6],
8120 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8122 else if (hash_mode
== 12700)
8124 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8126 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8127 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8129 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8131 else if (hash_mode
== 12800)
8133 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8135 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",
8148 byte_swap_32 (digest_buf
[0]),
8149 byte_swap_32 (digest_buf
[1]),
8150 byte_swap_32 (digest_buf
[2]),
8151 byte_swap_32 (digest_buf
[3]),
8152 byte_swap_32 (digest_buf
[4]),
8153 byte_swap_32 (digest_buf
[5]),
8154 byte_swap_32 (digest_buf
[6]),
8155 byte_swap_32 (digest_buf
[7])
8158 else if (hash_mode
== 12900)
8160 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",
8169 byte_swap_32 (digest_buf
[0]),
8170 byte_swap_32 (digest_buf
[1]),
8171 byte_swap_32 (digest_buf
[2]),
8172 byte_swap_32 (digest_buf
[3]),
8173 byte_swap_32 (digest_buf
[4]),
8174 byte_swap_32 (digest_buf
[5]),
8175 byte_swap_32 (digest_buf
[6]),
8176 byte_swap_32 (digest_buf
[7]),
8183 else if (hash_mode
== 13000)
8185 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8187 rar5_t
*rar5
= &rar5s
[salt_pos
];
8189 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8199 byte_swap_32 (digest_buf
[0]),
8200 byte_swap_32 (digest_buf
[1])
8205 if (hash_type
== HASH_TYPE_MD4
)
8207 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8213 else if (hash_type
== HASH_TYPE_MD5
)
8215 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8221 else if (hash_type
== HASH_TYPE_SHA1
)
8223 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8230 else if (hash_type
== HASH_TYPE_SHA256
)
8232 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8242 else if (hash_type
== HASH_TYPE_SHA384
)
8244 uint
*ptr
= digest_buf
;
8246 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8254 else if (hash_type
== HASH_TYPE_SHA512
)
8256 uint
*ptr
= digest_buf
;
8258 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8268 else if (hash_type
== HASH_TYPE_LM
)
8270 snprintf (out_buf
, len
-1, "%08x%08x",
8274 else if (hash_type
== HASH_TYPE_ORACLEH
)
8276 snprintf (out_buf
, len
-1, "%08X%08X",
8280 else if (hash_type
== HASH_TYPE_BCRYPT
)
8282 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8283 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8285 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8287 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8289 else if (hash_type
== HASH_TYPE_KECCAK
)
8291 uint
*ptr
= digest_buf
;
8293 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",
8321 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8323 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8325 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8332 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8334 digest_buf
[ 0] = digest_buf
[ 0];
8335 digest_buf
[ 1] = digest_buf
[ 1];
8336 digest_buf
[ 2] = digest_buf
[ 2];
8337 digest_buf
[ 3] = digest_buf
[ 3];
8338 digest_buf
[ 4] = digest_buf
[ 4];
8339 digest_buf
[ 5] = digest_buf
[ 5];
8340 digest_buf
[ 6] = digest_buf
[ 6];
8341 digest_buf
[ 7] = digest_buf
[ 7];
8342 digest_buf
[ 8] = digest_buf
[ 8];
8343 digest_buf
[ 9] = digest_buf
[ 9];
8344 digest_buf
[10] = digest_buf
[10];
8345 digest_buf
[11] = digest_buf
[11];
8346 digest_buf
[12] = digest_buf
[12];
8347 digest_buf
[13] = digest_buf
[13];
8348 digest_buf
[14] = digest_buf
[14];
8349 digest_buf
[15] = digest_buf
[15];
8351 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8369 else if (hash_type
== HASH_TYPE_GOST
)
8371 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8381 else if (hash_type
== HASH_TYPE_MYSQL
)
8383 snprintf (out_buf
, len
-1, "%08x%08x",
8387 else if (hash_type
== HASH_TYPE_LOTUS5
)
8389 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8395 else if (hash_type
== HASH_TYPE_LOTUS6
)
8397 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8398 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8399 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8400 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8402 char buf
[16] = { 0 };
8404 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8405 memcpy (buf
+ 5, digest_buf
, 9);
8409 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8411 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8414 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8416 else if (hash_type
== HASH_TYPE_LOTUS8
)
8418 char buf
[52] = { 0 };
8422 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8428 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8432 buf
[26] = salt
.salt_buf_pc
[0];
8433 buf
[27] = salt
.salt_buf_pc
[1];
8437 memcpy (buf
+ 28, digest_buf
, 8);
8439 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8443 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8445 else if (hash_type
== HASH_TYPE_CRC32
)
8447 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8451 if (salt_type
== SALT_TYPE_INTERN
)
8453 size_t pos
= strlen (out_buf
);
8455 out_buf
[pos
] = data
.separator
;
8457 char *ptr
= (char *) salt
.salt_buf
;
8459 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8461 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8465 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8467 memset (hccap
, 0, sizeof (hccap_t
));
8469 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8471 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8473 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8474 wpa_t
*wpa
= &wpas
[salt_pos
];
8476 hccap
->keyver
= wpa
->keyver
;
8478 hccap
->eapol_size
= wpa
->eapol_size
;
8480 if (wpa
->keyver
!= 1)
8482 uint eapol_tmp
[64] = { 0 };
8484 for (uint i
= 0; i
< 64; i
++)
8486 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8489 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8493 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8496 uint pke_tmp
[25] = { 0 };
8498 for (int i
= 5; i
< 25; i
++)
8500 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8503 char *pke_ptr
= (char *) pke_tmp
;
8505 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8506 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8507 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8508 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8510 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8512 uint dgst_size
= data
.dgst_size
;
8514 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8516 if (wpa
->keyver
!= 1)
8518 uint digest_tmp
[4] = { 0 };
8520 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8521 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8522 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8523 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8525 memcpy (hccap
->keymic
, digest_tmp
, 16);
8529 memcpy (hccap
->keymic
, digest_ptr
, 16);
8533 void SuspendThreads ()
8535 if (data
.devices_status
== STATUS_RUNNING
)
8537 hc_timer_set (&data
.timer_paused
);
8539 data
.devices_status
= STATUS_PAUSED
;
8541 log_info ("Paused");
8545 void ResumeThreads ()
8547 if (data
.devices_status
== STATUS_PAUSED
)
8551 hc_timer_get (data
.timer_paused
, ms_paused
);
8553 data
.ms_paused
+= ms_paused
;
8555 data
.devices_status
= STATUS_RUNNING
;
8557 log_info ("Resumed");
8563 if (data
.devices_status
!= STATUS_RUNNING
) return;
8565 data
.devices_status
= STATUS_BYPASS
;
8567 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8570 void stop_at_checkpoint ()
8572 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8574 if (data
.devices_status
!= STATUS_RUNNING
) return;
8577 // this feature only makes sense if --restore-disable was not specified
8579 if (data
.restore_disable
== 1)
8581 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8586 // check if monitoring of Restore Point updates should be enabled or disabled
8588 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8590 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8592 // save the current restore point value
8594 data
.checkpoint_cur_words
= get_lowest_words_done ();
8596 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8600 data
.devices_status
= STATUS_RUNNING
;
8602 // reset the global value for checkpoint checks
8604 data
.checkpoint_cur_words
= 0;
8606 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8612 if (data
.devices_status
== STATUS_INIT
) return;
8613 if (data
.devices_status
== STATUS_STARTING
) return;
8615 data
.devices_status
= STATUS_ABORTED
;
8620 if (data
.devices_status
== STATUS_INIT
) return;
8621 if (data
.devices_status
== STATUS_STARTING
) return;
8623 data
.devices_status
= STATUS_QUIT
;
8626 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8628 FILE *fp
= fopen (kernel_file
, "rb");
8634 memset (&st
, 0, sizeof (st
));
8636 stat (kernel_file
, &st
);
8638 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8640 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8642 if (num_read
!= (size_t) st
.st_size
)
8644 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8651 buf
[st
.st_size
] = 0;
8653 for (int i
= 0; i
< num_devices
; i
++)
8655 kernel_lengths
[i
] = (size_t) st
.st_size
;
8657 kernel_sources
[i
] = buf
;
8662 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8670 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8672 if (binary_size
> 0)
8674 FILE *fp
= fopen (dst
, "wb");
8677 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8688 restore_data_t
*init_restore (int argc
, char **argv
)
8690 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8692 if (data
.restore_disable
== 0)
8694 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8698 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8702 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8711 char pidbin
[BUFSIZ
] = { 0 };
8713 int pidbin_len
= -1;
8716 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8718 FILE *fd
= fopen (pidbin
, "rb");
8722 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8724 pidbin
[pidbin_len
] = 0;
8728 char *argv0_r
= strrchr (argv
[0], '/');
8730 char *pidbin_r
= strrchr (pidbin
, '/');
8732 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8734 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8736 if (strcmp (argv0_r
, pidbin_r
) == 0)
8738 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8745 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8747 char pidbin2
[BUFSIZ
] = { 0 };
8749 int pidbin2_len
= -1;
8751 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8752 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8754 pidbin
[pidbin_len
] = 0;
8755 pidbin2
[pidbin2_len
] = 0;
8759 if (strcmp (pidbin
, pidbin2
) == 0)
8761 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8769 if (rd
->version_bin
< RESTORE_MIN
)
8771 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8778 memset (rd
, 0, sizeof (restore_data_t
));
8780 rd
->version_bin
= VERSION_BIN
;
8783 rd
->pid
= getpid ();
8785 rd
->pid
= GetCurrentProcessId ();
8788 if (getcwd (rd
->cwd
, 255) == NULL
)
8801 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8803 FILE *fp
= fopen (eff_restore_file
, "rb");
8807 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8812 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8814 log_error ("ERROR: cannot read %s", eff_restore_file
);
8819 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8821 for (uint i
= 0; i
< rd
->argc
; i
++)
8823 char buf
[BUFSIZ
] = { 0 };
8825 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8827 log_error ("ERROR: cannot read %s", eff_restore_file
);
8832 size_t len
= strlen (buf
);
8834 if (len
) buf
[len
- 1] = 0;
8836 rd
->argv
[i
] = mystrdup (buf
);
8841 char new_cwd
[1024] = { 0 };
8843 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8847 log_error ("Restore file is corrupted");
8850 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8852 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8854 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8859 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8862 if (chdir (rd
->cwd
))
8864 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8870 u64
get_lowest_words_done ()
8874 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8876 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8878 if (device_param
->skipped
) continue;
8880 const u64 words_done
= device_param
->words_done
;
8882 if (words_done
< words_cur
) words_cur
= words_done
;
8885 // It's possible that a device's workload isn't finished right after a restore-case.
8886 // In that case, this function would return 0 and overwrite the real restore point
8887 // There's also data.words_cur which is set to rd->words_cur but it changes while
8888 // the attack is running therefore we should stick to rd->words_cur.
8889 // Note that -s influences rd->words_cur we should keep a close look on that.
8891 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
8896 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
8898 u64 words_cur
= get_lowest_words_done ();
8900 rd
->words_cur
= words_cur
;
8902 FILE *fp
= fopen (new_restore_file
, "wb");
8906 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
8911 if (setvbuf (fp
, NULL
, _IONBF
, 0))
8913 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
8918 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
8920 for (uint i
= 0; i
< rd
->argc
; i
++)
8922 fprintf (fp
, "%s", rd
->argv
[i
]);
8928 fsync (fileno (fp
));
8933 void cycle_restore ()
8935 const char *eff_restore_file
= data
.eff_restore_file
;
8936 const char *new_restore_file
= data
.new_restore_file
;
8938 restore_data_t
*rd
= data
.rd
;
8940 write_restore (new_restore_file
, rd
);
8944 memset (&st
, 0, sizeof(st
));
8946 if (stat (eff_restore_file
, &st
) == 0)
8948 if (unlink (eff_restore_file
))
8950 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
8954 if (rename (new_restore_file
, eff_restore_file
))
8956 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
8960 void check_checkpoint ()
8962 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
8964 u64 words_cur
= get_lowest_words_done ();
8966 if (words_cur
!= data
.checkpoint_cur_words
)
8977 uint
set_kernel_accel_osx (uint hash_mode
)
8981 case 1800: return GET_ACCEL_OSX (1800);
8982 case 2500: return GET_ACCEL_OSX (2500);
8983 case 5000: return GET_ACCEL_OSX (5000);
8984 case 6100: return GET_ACCEL_OSX (6100);
8985 case 6211: return GET_ACCEL_OSX (6211);
8986 case 6231: return GET_ACCEL_OSX (6231);
8987 case 6241: return GET_ACCEL_OSX (6241);
8988 case 6800: return GET_ACCEL_OSX (6800);
8989 case 7100: return GET_ACCEL_OSX (7100);
8990 case 7200: return GET_ACCEL_OSX (7200);
8991 case 7900: return GET_ACCEL_OSX (7900);
8992 case 8200: return GET_ACCEL_OSX (8200);
8993 case 8700: return GET_ACCEL_OSX (8700);
8994 case 9100: return GET_ACCEL_OSX (9100);
8995 case 9200: return GET_ACCEL_OSX (9200);
8996 case 9300: return GET_ACCEL_OSX (9300);
8997 case 9400: return GET_ACCEL_OSX (9400);
8998 case 9500: return GET_ACCEL_OSX (9500);
8999 case 9600: return GET_ACCEL_OSX (9600);
9000 case 10000: return GET_ACCEL_OSX (10000);
9001 case 10500: return GET_ACCEL_OSX (10500);
9002 case 11300: return GET_ACCEL_OSX (11300);
9003 case 11600: return GET_ACCEL_OSX (11600);
9004 case 11700: return GET_ACCEL_OSX (11700);
9005 case 11800: return GET_ACCEL_OSX (11800);
9006 case 12200: return GET_ACCEL_OSX (12200);
9007 case 12400: return GET_ACCEL_OSX (12400);
9008 case 12500: return GET_ACCEL_OSX (12500);
9009 case 13000: return GET_ACCEL_OSX (13000);
9015 uint
set_kernel_accel (uint hash_mode
, bool isGpu
)
9020 accel
= set_kernel_accel_osx (hash_mode
);
9026 uint
set_kernel_accel (uint hash_mode
)
9033 case 0: return GET_ACCEL (0);
9034 case 10: return GET_ACCEL (10);
9035 case 11: return GET_ACCEL (11);
9036 case 12: return GET_ACCEL (12);
9037 case 20: return GET_ACCEL (20);
9038 case 21: return GET_ACCEL (21);
9039 case 22: return GET_ACCEL (22);
9040 case 23: return GET_ACCEL (23);
9041 case 30: return GET_ACCEL (30);
9042 case 40: return GET_ACCEL (40);
9043 case 50: return GET_ACCEL (50);
9044 case 60: return GET_ACCEL (60);
9045 case 100: return GET_ACCEL (100);
9046 case 101: return GET_ACCEL (101);
9047 case 110: return GET_ACCEL (110);
9048 case 111: return GET_ACCEL (111);
9049 case 112: return GET_ACCEL (112);
9050 case 120: return GET_ACCEL (120);
9051 case 121: return GET_ACCEL (121);
9052 case 122: return GET_ACCEL (122);
9053 case 124: return GET_ACCEL (124);
9054 case 130: return GET_ACCEL (130);
9055 case 131: return GET_ACCEL (131);
9056 case 132: return GET_ACCEL (132);
9057 case 133: return GET_ACCEL (133);
9058 case 140: return GET_ACCEL (140);
9059 case 141: return GET_ACCEL (141);
9060 case 150: return GET_ACCEL (150);
9061 case 160: return GET_ACCEL (160);
9062 case 190: return GET_ACCEL (190);
9063 case 200: return GET_ACCEL (200);
9064 case 300: return GET_ACCEL (300);
9065 case 400: return GET_ACCEL (400);
9066 case 500: return GET_ACCEL (500);
9067 case 501: return GET_ACCEL (501);
9068 case 900: return GET_ACCEL (900);
9069 case 910: return GET_ACCEL (910);
9070 case 1000: return GET_ACCEL (1000);
9071 case 1100: return GET_ACCEL (1100);
9072 case 1400: return GET_ACCEL (1400);
9073 case 1410: return GET_ACCEL (1410);
9074 case 1420: return GET_ACCEL (1420);
9075 case 1421: return GET_ACCEL (1421);
9076 case 1430: return GET_ACCEL (1430);
9077 case 1440: return GET_ACCEL (1440);
9078 case 1441: return GET_ACCEL (1441);
9079 case 1450: return GET_ACCEL (1450);
9080 case 1460: return GET_ACCEL (1460);
9081 case 1500: return GET_ACCEL (1500);
9082 case 1600: return GET_ACCEL (1600);
9083 case 1700: return GET_ACCEL (1700);
9084 case 1710: return GET_ACCEL (1710);
9085 case 1711: return GET_ACCEL (1711);
9086 case 1720: return GET_ACCEL (1720);
9087 case 1722: return GET_ACCEL (1722);
9088 case 1730: return GET_ACCEL (1730);
9089 case 1731: return GET_ACCEL (1731);
9090 case 1740: return GET_ACCEL (1740);
9091 case 1750: return GET_ACCEL (1750);
9092 case 1760: return GET_ACCEL (1760);
9093 case 1800: return GET_ACCEL (1800);
9094 case 2100: return GET_ACCEL (2100);
9095 case 2400: return GET_ACCEL (2400);
9096 case 2410: return GET_ACCEL (2410);
9097 case 2500: return GET_ACCEL (2500);
9098 case 2600: return GET_ACCEL (2600);
9099 case 2611: return GET_ACCEL (2611);
9100 case 2612: return GET_ACCEL (2612);
9101 case 2711: return GET_ACCEL (2711);
9102 case 2811: return GET_ACCEL (2811);
9103 case 3000: return GET_ACCEL (3000);
9104 case 3100: return GET_ACCEL (3100);
9105 case 3200: return GET_ACCEL (3200);
9106 case 3710: return GET_ACCEL (3710);
9107 case 3711: return GET_ACCEL (3711);
9108 case 3800: return GET_ACCEL (3800);
9109 case 4300: return GET_ACCEL (4300);
9110 case 4400: return GET_ACCEL (4400);
9111 case 4500: return GET_ACCEL (4500);
9112 case 4700: return GET_ACCEL (4700);
9113 case 4800: return GET_ACCEL (4800);
9114 case 4900: return GET_ACCEL (4900);
9115 case 5000: return GET_ACCEL (5000);
9116 case 5100: return GET_ACCEL (5100);
9117 case 5200: return GET_ACCEL (5200);
9118 case 5300: return GET_ACCEL (5300);
9119 case 5400: return GET_ACCEL (5400);
9120 case 5500: return GET_ACCEL (5500);
9121 case 5600: return GET_ACCEL (5600);
9122 case 5700: return GET_ACCEL (5700);
9123 case 5800: return GET_ACCEL (5800);
9124 case 6000: return GET_ACCEL (6000);
9125 case 6100: return GET_ACCEL (6100);
9126 case 6211: return GET_ACCEL (6211);
9127 case 6212: return GET_ACCEL (6212);
9128 case 6213: return GET_ACCEL (6213);
9129 case 6221: return GET_ACCEL (6221);
9130 case 6222: return GET_ACCEL (6222);
9131 case 6223: return GET_ACCEL (6223);
9132 case 6231: return GET_ACCEL (6231);
9133 case 6232: return GET_ACCEL (6232);
9134 case 6233: return GET_ACCEL (6233);
9135 case 6241: return GET_ACCEL (6241);
9136 case 6242: return GET_ACCEL (6242);
9137 case 6243: return GET_ACCEL (6243);
9138 case 6300: return GET_ACCEL (6300);
9139 case 6400: return GET_ACCEL (6400);
9140 case 6500: return GET_ACCEL (6500);
9141 case 6600: return GET_ACCEL (6600);
9142 case 6700: return GET_ACCEL (6700);
9143 case 6800: return GET_ACCEL (6800);
9144 case 6900: return GET_ACCEL (6900);
9145 case 7100: return GET_ACCEL (7100);
9146 case 7200: return GET_ACCEL (7200);
9147 case 7300: return GET_ACCEL (7300);
9148 case 7400: return GET_ACCEL (7400);
9149 case 7500: return GET_ACCEL (7500);
9150 case 7600: return GET_ACCEL (7600);
9151 case 7700: return GET_ACCEL (7700);
9152 case 7800: return GET_ACCEL (7800);
9153 case 7900: return GET_ACCEL (7900);
9154 case 8000: return GET_ACCEL (8000);
9155 case 8100: return GET_ACCEL (8100);
9156 case 8200: return GET_ACCEL (8200);
9157 case 8300: return GET_ACCEL (8300);
9158 case 8400: return GET_ACCEL (8400);
9159 case 8500: return GET_ACCEL (8500);
9160 case 8600: return GET_ACCEL (8600);
9161 case 8700: return GET_ACCEL (8700);
9162 case 8800: return GET_ACCEL (8800);
9163 case 8900: return GET_ACCEL (8900);
9164 case 9000: return GET_ACCEL (9000);
9165 case 9100: return GET_ACCEL (9100);
9166 case 9200: return GET_ACCEL (9200);
9167 case 9300: return GET_ACCEL (9300);
9168 case 9400: return GET_ACCEL (9400);
9169 case 9500: return GET_ACCEL (9500);
9170 case 9600: return GET_ACCEL (9600);
9171 case 9700: return GET_ACCEL (9700);
9172 case 9710: return GET_ACCEL (9710);
9173 case 9720: return GET_ACCEL (9720);
9174 case 9800: return GET_ACCEL (9800);
9175 case 9810: return GET_ACCEL (9810);
9176 case 9820: return GET_ACCEL (9820);
9177 case 9900: return GET_ACCEL (9900);
9178 case 10000: return GET_ACCEL (10000);
9179 case 10100: return GET_ACCEL (10100);
9180 case 10200: return GET_ACCEL (10200);
9181 case 10300: return GET_ACCEL (10300);
9182 case 10400: return GET_ACCEL (10400);
9183 case 10410: return GET_ACCEL (10410);
9184 case 10420: return GET_ACCEL (10420);
9185 case 10500: return GET_ACCEL (10500);
9186 case 10600: return GET_ACCEL (10600);
9187 case 10700: return GET_ACCEL (10700);
9188 case 10800: return GET_ACCEL (10800);
9189 case 10900: return GET_ACCEL (10900);
9190 case 11000: return GET_ACCEL (11000);
9191 case 11100: return GET_ACCEL (11100);
9192 case 11200: return GET_ACCEL (11200);
9193 case 11300: return GET_ACCEL (11300);
9194 case 11400: return GET_ACCEL (11400);
9195 case 11500: return GET_ACCEL (11500);
9196 case 11600: return GET_ACCEL (11600);
9197 case 11700: return GET_ACCEL (11700);
9198 case 11800: return GET_ACCEL (11800);
9199 case 11900: return GET_ACCEL (11900);
9200 case 12000: return GET_ACCEL (12000);
9201 case 12100: return GET_ACCEL (12100);
9202 case 12200: return GET_ACCEL (12200);
9203 case 12300: return GET_ACCEL (12300);
9204 case 12400: return GET_ACCEL (12400);
9205 case 12500: return GET_ACCEL (12500);
9206 case 12600: return GET_ACCEL (12600);
9207 case 12700: return GET_ACCEL (12700);
9208 case 12800: return GET_ACCEL (12800);
9209 case 12900: return GET_ACCEL (12900);
9210 case 13000: return GET_ACCEL (13000);
9217 uint
set_kernel_loops_osx (uint hash_mode
)
9221 case 0: return GET_LOOPS_OSX (0);
9222 case 10: return GET_LOOPS_OSX (10);
9223 case 11: return GET_LOOPS_OSX (11);
9224 case 12: return GET_LOOPS_OSX (12);
9225 case 20: return GET_LOOPS_OSX (20);
9226 case 21: return GET_LOOPS_OSX (21);
9227 case 22: return GET_LOOPS_OSX (22);
9228 case 23: return GET_LOOPS_OSX (23);
9229 case 30: return GET_LOOPS_OSX (30);
9230 case 40: return GET_LOOPS_OSX (40);
9231 case 50: return GET_LOOPS_OSX (50);
9232 case 60: return GET_LOOPS_OSX (60);
9233 case 100: return GET_LOOPS_OSX (100);
9234 case 101: return GET_LOOPS_OSX (101);
9235 case 110: return GET_LOOPS_OSX (110);
9236 case 111: return GET_LOOPS_OSX (111);
9237 case 112: return GET_LOOPS_OSX (112);
9238 case 120: return GET_LOOPS_OSX (120);
9239 case 121: return GET_LOOPS_OSX (121);
9240 case 122: return GET_LOOPS_OSX (122);
9241 case 124: return GET_LOOPS_OSX (124);
9242 case 130: return GET_LOOPS_OSX (130);
9243 case 131: return GET_LOOPS_OSX (131);
9244 case 132: return GET_LOOPS_OSX (132);
9245 case 133: return GET_LOOPS_OSX (133);
9246 case 140: return GET_LOOPS_OSX (140);
9247 case 141: return GET_LOOPS_OSX (141);
9248 case 150: return GET_LOOPS_OSX (150);
9249 case 160: return GET_LOOPS_OSX (160);
9250 case 190: return GET_LOOPS_OSX (190);
9251 case 200: return GET_LOOPS_OSX (200);
9252 case 300: return GET_LOOPS_OSX (300);
9253 case 900: return GET_LOOPS_OSX (900);
9254 case 1000: return GET_LOOPS_OSX (1000);
9255 case 1100: return GET_LOOPS_OSX (1100);
9256 case 1400: return GET_LOOPS_OSX (1400);
9257 case 1410: return GET_LOOPS_OSX (1410);
9258 case 1420: return GET_LOOPS_OSX (1420);
9259 case 1421: return GET_LOOPS_OSX (1421);
9260 case 1430: return GET_LOOPS_OSX (1430);
9261 case 1440: return GET_LOOPS_OSX (1440);
9262 case 1441: return GET_LOOPS_OSX (1441);
9263 case 1450: return GET_LOOPS_OSX (1450);
9264 case 1460: return GET_LOOPS_OSX (1460);
9265 case 1700: return GET_LOOPS_OSX (1700);
9266 case 1710: return GET_LOOPS_OSX (1710);
9267 case 1711: return GET_LOOPS_OSX (1711);
9268 case 1720: return GET_LOOPS_OSX (1720);
9269 case 1722: return GET_LOOPS_OSX (1722);
9270 case 1730: return GET_LOOPS_OSX (1730);
9271 case 1731: return GET_LOOPS_OSX (1731);
9272 case 1740: return GET_LOOPS_OSX (1740);
9273 case 1750: return GET_LOOPS_OSX (1750);
9274 case 1760: return GET_LOOPS_OSX (1760);
9275 case 2400: return GET_LOOPS_OSX (2400);
9276 case 2410: return GET_LOOPS_OSX (2410);
9277 case 2600: return GET_LOOPS_OSX (2600);
9278 case 2611: return GET_LOOPS_OSX (2611);
9279 case 2612: return GET_LOOPS_OSX (2612);
9280 case 2711: return GET_LOOPS_OSX (2711);
9281 case 2811: return GET_LOOPS_OSX (2811);
9282 case 3100: return GET_LOOPS_OSX (3100);
9283 case 3200: return GET_LOOPS_OSX (3200);
9284 case 3710: return GET_LOOPS_OSX (3710);
9285 case 3711: return GET_LOOPS_OSX (3711);
9286 case 3800: return GET_LOOPS_OSX (3800);
9287 case 4300: return GET_LOOPS_OSX (4300);
9288 case 4400: return GET_LOOPS_OSX (4400);
9289 case 4500: return GET_LOOPS_OSX (4500);
9290 case 4700: return GET_LOOPS_OSX (4700);
9291 case 4800: return GET_LOOPS_OSX (4800);
9292 case 4900: return GET_LOOPS_OSX (4900);
9293 case 5000: return GET_LOOPS_OSX (5000);
9294 case 5100: return GET_LOOPS_OSX (5100);
9295 case 5300: return GET_LOOPS_OSX (5300);
9296 case 5400: return GET_LOOPS_OSX (5400);
9297 case 5500: return GET_LOOPS_OSX (5500);
9298 case 5600: return GET_LOOPS_OSX (5600);
9299 case 5700: return GET_LOOPS_OSX (5700);
9300 case 6000: return GET_LOOPS_OSX (6000);
9301 case 6100: return GET_LOOPS_OSX (6100);
9302 case 6231: return GET_LOOPS_OSX (6231);
9303 case 6232: return GET_LOOPS_OSX (6232);
9304 case 6233: return GET_LOOPS_OSX (6233);
9305 case 6900: return GET_LOOPS_OSX (6900);
9306 case 7300: return GET_LOOPS_OSX (7300);
9307 case 7500: return GET_LOOPS_OSX (7500);
9308 case 7600: return GET_LOOPS_OSX (7600);
9309 case 7700: return GET_LOOPS_OSX (7700);
9310 case 7800: return GET_LOOPS_OSX (7800);
9311 case 8000: return GET_LOOPS_OSX (8000);
9312 case 8100: return GET_LOOPS_OSX (8100);
9313 case 8200: return GET_LOOPS_OSX (8200);
9314 case 8300: return GET_LOOPS_OSX (8300);
9315 case 8400: return GET_LOOPS_OSX (8400);
9316 case 8500: return GET_LOOPS_OSX (8500);
9317 case 8600: return GET_LOOPS_OSX (8600);
9318 case 8700: return GET_LOOPS_OSX (8700);
9319 case 9700: return GET_LOOPS_OSX (9700);
9320 case 9710: return GET_LOOPS_OSX (9710);
9321 case 9720: return GET_LOOPS_OSX (9720);
9322 case 9800: return GET_LOOPS_OSX (9800);
9323 case 9810: return GET_LOOPS_OSX (9810);
9324 case 9820: return GET_LOOPS_OSX (9820);
9325 case 9900: return GET_LOOPS_OSX (9900);
9326 case 10100: return GET_LOOPS_OSX (10100);
9327 case 10200: return GET_LOOPS_OSX (10200);
9328 case 10400: return GET_LOOPS_OSX (10400);
9329 case 10410: return GET_LOOPS_OSX (10410);
9330 case 10420: return GET_LOOPS_OSX (10420);
9331 case 10600: return GET_LOOPS_OSX (10600);
9332 case 10700: return GET_LOOPS_OSX (10700);
9333 case 10800: return GET_LOOPS_OSX (10800);
9334 case 11000: return GET_LOOPS_OSX (11000);
9335 case 11100: return GET_LOOPS_OSX (11100);
9336 case 11200: return GET_LOOPS_OSX (11200);
9337 case 11300: return GET_LOOPS_OSX (11300);
9338 case 11400: return GET_LOOPS_OSX (11400);
9339 case 11500: return GET_LOOPS_OSX (11500);
9340 case 11700: return GET_LOOPS_OSX (11700);
9341 case 11800: return GET_LOOPS_OSX (11800);
9342 case 12600: return GET_LOOPS_OSX (12600);
9348 uint
set_kernel_loops (uint hash_mode
, bool isGpu
)
9352 loops
= set_kernel_loops_osx (hash_mode
);
9359 uint
set_kernel_loops (uint hash_mode
)
9366 case 0: return GET_LOOPS (0);
9367 case 10: return GET_LOOPS (10);
9368 case 11: return GET_LOOPS (11);
9369 case 12: return GET_LOOPS (12);
9370 case 20: return GET_LOOPS (20);
9371 case 21: return GET_LOOPS (21);
9372 case 22: return GET_LOOPS (22);
9373 case 23: return GET_LOOPS (23);
9374 case 30: return GET_LOOPS (30);
9375 case 40: return GET_LOOPS (40);
9376 case 50: return GET_LOOPS (50);
9377 case 60: return GET_LOOPS (60);
9378 case 100: return GET_LOOPS (100);
9379 case 101: return GET_LOOPS (101);
9380 case 110: return GET_LOOPS (110);
9381 case 111: return GET_LOOPS (111);
9382 case 112: return GET_LOOPS (112);
9383 case 120: return GET_LOOPS (120);
9384 case 121: return GET_LOOPS (121);
9385 case 122: return GET_LOOPS (122);
9386 case 124: return GET_LOOPS (124);
9387 case 130: return GET_LOOPS (130);
9388 case 131: return GET_LOOPS (131);
9389 case 132: return GET_LOOPS (132);
9390 case 133: return GET_LOOPS (133);
9391 case 140: return GET_LOOPS (140);
9392 case 141: return GET_LOOPS (141);
9393 case 150: return GET_LOOPS (150);
9394 case 160: return GET_LOOPS (160);
9395 case 190: return GET_LOOPS (190);
9396 case 200: return GET_LOOPS (200);
9397 case 300: return GET_LOOPS (300);
9398 case 400: return GET_LOOPS (400);
9399 case 500: return GET_LOOPS (500);
9400 case 501: return GET_LOOPS (501);
9401 case 900: return GET_LOOPS (900);
9402 case 910: return GET_LOOPS (910);
9403 case 1000: return GET_LOOPS (1000);
9404 case 1100: return GET_LOOPS (1100);
9405 case 1400: return GET_LOOPS (1400);
9406 case 1410: return GET_LOOPS (1410);
9407 case 1420: return GET_LOOPS (1420);
9408 case 1421: return GET_LOOPS (1421);
9409 case 1430: return GET_LOOPS (1430);
9410 case 1440: return GET_LOOPS (1440);
9411 case 1441: return GET_LOOPS (1441);
9412 case 1450: return GET_LOOPS (1450);
9413 case 1460: return GET_LOOPS (1460);
9414 case 1500: return GET_LOOPS (1500);
9415 case 1600: return GET_LOOPS (1600);
9416 case 1700: return GET_LOOPS (1700);
9417 case 1710: return GET_LOOPS (1710);
9418 case 1711: return GET_LOOPS (1711);
9419 case 1720: return GET_LOOPS (1720);
9420 case 1722: return GET_LOOPS (1722);
9421 case 1730: return GET_LOOPS (1730);
9422 case 1731: return GET_LOOPS (1731);
9423 case 1740: return GET_LOOPS (1740);
9424 case 1750: return GET_LOOPS (1750);
9425 case 1760: return GET_LOOPS (1760);
9426 case 1800: return GET_LOOPS (1800);
9427 case 2100: return GET_LOOPS (2100);
9428 case 2400: return GET_LOOPS (2400);
9429 case 2410: return GET_LOOPS (2410);
9430 case 2500: return GET_LOOPS (2500);
9431 case 2600: return GET_LOOPS (2600);
9432 case 2611: return GET_LOOPS (2611);
9433 case 2612: return GET_LOOPS (2612);
9434 case 2711: return GET_LOOPS (2711);
9435 case 2811: return GET_LOOPS (2811);
9436 case 3000: return GET_LOOPS (3000);
9437 case 3100: return GET_LOOPS (3100);
9438 case 3200: return GET_LOOPS (3200);
9439 case 3710: return GET_LOOPS (3710);
9440 case 3711: return GET_LOOPS (3711);
9441 case 3800: return GET_LOOPS (3800);
9442 case 4300: return GET_LOOPS (4300);
9443 case 4400: return GET_LOOPS (4400);
9444 case 4500: return GET_LOOPS (4500);
9445 case 4700: return GET_LOOPS (4700);
9446 case 4800: return GET_LOOPS (4800);
9447 case 4900: return GET_LOOPS (4900);
9448 case 5000: return GET_LOOPS (5000);
9449 case 5100: return GET_LOOPS (5100);
9450 case 5200: return GET_LOOPS (5200);
9451 case 5300: return GET_LOOPS (5300);
9452 case 5400: return GET_LOOPS (5400);
9453 case 5500: return GET_LOOPS (5500);
9454 case 5600: return GET_LOOPS (5600);
9455 case 5700: return GET_LOOPS (5700);
9456 case 5800: return GET_LOOPS (5800);
9457 case 6000: return GET_LOOPS (6000);
9458 case 6100: return GET_LOOPS (6100);
9459 case 6211: return GET_LOOPS (6211);
9460 case 6212: return GET_LOOPS (6212);
9461 case 6213: return GET_LOOPS (6213);
9462 case 6221: return GET_LOOPS (6221);
9463 case 6222: return GET_LOOPS (6222);
9464 case 6223: return GET_LOOPS (6223);
9465 case 6231: return GET_LOOPS (6231);
9466 case 6232: return GET_LOOPS (6232);
9467 case 6233: return GET_LOOPS (6233);
9468 case 6241: return GET_LOOPS (6241);
9469 case 6242: return GET_LOOPS (6242);
9470 case 6243: return GET_LOOPS (6243);
9471 case 6300: return GET_LOOPS (6300);
9472 case 6400: return GET_LOOPS (6400);
9473 case 6500: return GET_LOOPS (6500);
9474 case 6600: return GET_LOOPS (6600);
9475 case 6700: return GET_LOOPS (6700);
9476 case 6800: return GET_LOOPS (6800);
9477 case 6900: return GET_LOOPS (6900);
9478 case 7100: return GET_LOOPS (7100);
9479 case 7200: return GET_LOOPS (7200);
9480 case 7300: return GET_LOOPS (7300);
9481 case 7400: return GET_LOOPS (7400);
9482 case 7500: return GET_LOOPS (7500);
9483 case 7600: return GET_LOOPS (7600);
9484 case 7700: return GET_LOOPS (7700);
9485 case 7800: return GET_LOOPS (7800);
9486 case 7900: return GET_LOOPS (7900);
9487 case 8000: return GET_LOOPS (8000);
9488 case 8100: return GET_LOOPS (8100);
9489 case 8200: return GET_LOOPS (8200);
9490 case 8300: return GET_LOOPS (8300);
9491 case 8400: return GET_LOOPS (8400);
9492 case 8500: return GET_LOOPS (8500);
9493 case 8600: return GET_LOOPS (8600);
9494 case 8700: return GET_LOOPS (8700);
9495 case 8800: return GET_LOOPS (8800);
9496 case 8900: return GET_LOOPS (8900);
9497 case 9000: return GET_LOOPS (9000);
9498 case 9100: return GET_LOOPS (9100);
9499 case 9200: return GET_LOOPS (9200);
9500 case 9300: return GET_LOOPS (9300);
9501 case 9400: return GET_LOOPS (9400);
9502 case 9500: return GET_LOOPS (9500);
9503 case 9600: return GET_LOOPS (9600);
9504 case 9700: return GET_LOOPS (9700);
9505 case 9710: return GET_LOOPS (9710);
9506 case 9720: return GET_LOOPS (9720);
9507 case 9800: return GET_LOOPS (9800);
9508 case 9810: return GET_LOOPS (9810);
9509 case 9820: return GET_LOOPS (9820);
9510 case 9900: return GET_LOOPS (9900);
9511 case 10000: return GET_LOOPS (10000);
9512 case 10100: return GET_LOOPS (10100);
9513 case 10200: return GET_LOOPS (10200);
9514 case 10300: return GET_LOOPS (10300);
9515 case 10400: return GET_LOOPS (10400);
9516 case 10410: return GET_LOOPS (10410);
9517 case 10420: return GET_LOOPS (10420);
9518 case 10500: return GET_LOOPS (10500);
9519 case 10600: return GET_LOOPS (10600);
9520 case 10700: return GET_LOOPS (10700);
9521 case 10800: return GET_LOOPS (10800);
9522 case 10900: return GET_LOOPS (10900);
9523 case 11000: return GET_LOOPS (11000);
9524 case 11100: return GET_LOOPS (11100);
9525 case 11200: return GET_LOOPS (11200);
9526 case 11300: return GET_LOOPS (11300);
9527 case 11400: return GET_LOOPS (11400);
9528 case 11500: return GET_LOOPS (11500);
9529 case 11600: return GET_LOOPS (11600);
9530 case 11700: return GET_LOOPS (11700);
9531 case 11800: return GET_LOOPS (11800);
9532 case 11900: return GET_LOOPS (11900);
9533 case 12000: return GET_LOOPS (12000);
9534 case 12100: return GET_LOOPS (12100);
9535 case 12200: return GET_LOOPS (12200);
9536 case 12300: return GET_LOOPS (12300);
9537 case 12400: return GET_LOOPS (12400);
9538 case 12500: return GET_LOOPS (12500);
9539 case 12600: return GET_LOOPS (12600);
9540 case 12700: return GET_LOOPS (12700);
9541 case 12800: return GET_LOOPS (12800);
9542 case 12900: return GET_LOOPS (12900);
9543 case 13000: return GET_LOOPS (13000);
9553 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9555 u8 tmp
[256] = { 0 };
9557 if (salt_len
> sizeof (tmp
))
9562 memcpy (tmp
, in
, salt_len
);
9564 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9566 if ((salt_len
% 2) == 0)
9568 u32 new_salt_len
= salt_len
/ 2;
9570 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9575 tmp
[i
] = hex_convert (p1
) << 0;
9576 tmp
[i
] |= hex_convert (p0
) << 4;
9579 salt_len
= new_salt_len
;
9586 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9588 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9591 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9593 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9597 u32
*tmp_uint
= (u32
*) tmp
;
9599 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9600 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9601 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9602 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9603 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9604 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9605 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9606 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9607 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9608 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9610 salt_len
= salt_len
* 2;
9618 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9620 lowercase (tmp
, salt_len
);
9623 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9625 uppercase (tmp
, salt_len
);
9630 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9635 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9640 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9642 u32
*tmp_uint
= (uint
*) tmp
;
9648 for (u32 i
= 0; i
< max
; i
++)
9650 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9653 // Important: we may need to increase the length of memcpy since
9654 // we don't want to "loose" some swapped bytes (could happen if
9655 // they do not perfectly fit in the 4-byte blocks)
9656 // Memcpy does always copy the bytes in the BE order, but since
9657 // we swapped them, some important bytes could be in positions
9658 // we normally skip with the original len
9660 if (len
% 4) len
+= 4 - (len
% 4);
9663 memcpy (out
, tmp
, len
);
9668 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9670 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9672 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9674 u32
*digest
= (u32
*) hash_buf
->digest
;
9676 salt_t
*salt
= hash_buf
->salt
;
9678 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9680 char *iter_pos
= input_buf
+ 4;
9682 salt
->salt_iter
= 1 << atoi (iter_pos
);
9684 char *salt_pos
= strchr (iter_pos
, '$');
9686 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9692 salt
->salt_len
= salt_len
;
9694 u8 tmp_buf
[100] = { 0 };
9696 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9698 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9700 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9702 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9703 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9704 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9705 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9707 char *hash_pos
= salt_pos
+ 22;
9709 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9711 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9713 memcpy (digest
, tmp_buf
, 24);
9715 digest
[0] = byte_swap_32 (digest
[0]);
9716 digest
[1] = byte_swap_32 (digest
[1]);
9717 digest
[2] = byte_swap_32 (digest
[2]);
9718 digest
[3] = byte_swap_32 (digest
[3]);
9719 digest
[4] = byte_swap_32 (digest
[4]);
9720 digest
[5] = byte_swap_32 (digest
[5]);
9722 digest
[5] &= ~0xff; // its just 23 not 24 !
9727 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9729 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9731 u32
*digest
= (u32
*) hash_buf
->digest
;
9733 u8 tmp_buf
[100] = { 0 };
9735 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9737 memcpy (digest
, tmp_buf
, 32);
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]);
9745 digest
[6] = byte_swap_32 (digest
[6]);
9746 digest
[7] = byte_swap_32 (digest
[7]);
9748 digest
[0] -= SHA256M_A
;
9749 digest
[1] -= SHA256M_B
;
9750 digest
[2] -= SHA256M_C
;
9751 digest
[3] -= SHA256M_D
;
9752 digest
[4] -= SHA256M_E
;
9753 digest
[5] -= SHA256M_F
;
9754 digest
[6] -= SHA256M_G
;
9755 digest
[7] -= SHA256M_H
;
9760 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9762 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9764 u32
*digest
= (u32
*) hash_buf
->digest
;
9766 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9767 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9769 digest
[0] = byte_swap_32 (digest
[0]);
9770 digest
[1] = byte_swap_32 (digest
[1]);
9774 IP (digest
[0], digest
[1], tt
);
9776 digest
[0] = digest
[0];
9777 digest
[1] = digest
[1];
9784 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9786 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9788 u32
*digest
= (u32
*) hash_buf
->digest
;
9790 salt_t
*salt
= hash_buf
->salt
;
9792 char *hash_pos
= input_buf
+ 8;
9794 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9795 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9796 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9797 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9798 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9800 digest
[0] -= SHA1M_A
;
9801 digest
[1] -= SHA1M_B
;
9802 digest
[2] -= SHA1M_C
;
9803 digest
[3] -= SHA1M_D
;
9804 digest
[4] -= SHA1M_E
;
9808 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9810 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9812 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9814 salt
->salt_len
= salt_len
;
9819 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9821 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9823 u64
*digest
= (u64
*) hash_buf
->digest
;
9825 salt_t
*salt
= hash_buf
->salt
;
9827 char *hash_pos
= input_buf
+ 8;
9829 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9830 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9831 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9832 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9833 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9834 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9835 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9836 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9838 digest
[0] -= SHA512M_A
;
9839 digest
[1] -= SHA512M_B
;
9840 digest
[2] -= SHA512M_C
;
9841 digest
[3] -= SHA512M_D
;
9842 digest
[4] -= SHA512M_E
;
9843 digest
[5] -= SHA512M_F
;
9844 digest
[6] -= SHA512M_G
;
9845 digest
[7] -= SHA512M_H
;
9849 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9851 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9853 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9855 salt
->salt_len
= salt_len
;
9860 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9862 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9864 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9868 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9871 u32
*digest
= (u32
*) hash_buf
->digest
;
9873 salt_t
*salt
= hash_buf
->salt
;
9875 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9876 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9877 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9878 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9880 digest
[0] = byte_swap_32 (digest
[0]);
9881 digest
[1] = byte_swap_32 (digest
[1]);
9882 digest
[2] = byte_swap_32 (digest
[2]);
9883 digest
[3] = byte_swap_32 (digest
[3]);
9885 digest
[0] -= MD5M_A
;
9886 digest
[1] -= MD5M_B
;
9887 digest
[2] -= MD5M_C
;
9888 digest
[3] -= MD5M_D
;
9890 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9892 uint salt_len
= input_len
- 32 - 1;
9894 char *salt_buf
= input_buf
+ 32 + 1;
9896 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9898 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9900 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9902 salt
->salt_len
= salt_len
;
9907 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9909 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9911 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9915 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9920 char clean_input_buf
[32] = { 0 };
9922 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9923 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9925 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9929 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9935 clean_input_buf
[k
] = input_buf
[i
];
9943 u32
*digest
= (u32
*) hash_buf
->digest
;
9945 salt_t
*salt
= hash_buf
->salt
;
9947 u32 a
, b
, c
, d
, e
, f
;
9949 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9950 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9951 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9952 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9953 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9954 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9956 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9957 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9959 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9960 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9961 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9962 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9963 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9964 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9966 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9967 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9969 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9970 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9971 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9972 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9973 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9974 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9976 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9977 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9979 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9980 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9981 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9982 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9983 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9984 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9986 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9987 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9989 digest
[0] = byte_swap_32 (digest
[0]);
9990 digest
[1] = byte_swap_32 (digest
[1]);
9991 digest
[2] = byte_swap_32 (digest
[2]);
9992 digest
[3] = byte_swap_32 (digest
[3]);
9994 digest
[0] -= MD5M_A
;
9995 digest
[1] -= MD5M_B
;
9996 digest
[2] -= MD5M_C
;
9997 digest
[3] -= MD5M_D
;
9999 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10001 uint salt_len
= input_len
- 30 - 1;
10003 char *salt_buf
= input_buf
+ 30 + 1;
10005 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10007 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10009 // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
10010 if (salt_len
> 10) return (PARSER_SALT_LENGTH
);
10012 salt
->salt_len
= salt_len
;
10014 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10016 salt
->salt_len
+= 22;
10018 return (PARSER_OK
);
10021 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10023 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10025 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10029 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10032 u32
*digest
= (u32
*) hash_buf
->digest
;
10034 salt_t
*salt
= hash_buf
->salt
;
10036 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10037 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10038 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10039 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10040 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10042 digest
[0] -= SHA1M_A
;
10043 digest
[1] -= SHA1M_B
;
10044 digest
[2] -= SHA1M_C
;
10045 digest
[3] -= SHA1M_D
;
10046 digest
[4] -= SHA1M_E
;
10048 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10050 uint salt_len
= input_len
- 40 - 1;
10052 char *salt_buf
= input_buf
+ 40 + 1;
10054 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10056 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10058 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10060 salt
->salt_len
= salt_len
;
10062 return (PARSER_OK
);
10065 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10067 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10069 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10073 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10076 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10078 char *iter_pos
= input_buf
+ 6;
10080 salt_t
*salt
= hash_buf
->salt
;
10082 uint iter
= atoi (iter_pos
);
10086 iter
= ROUNDS_DCC2
;
10089 salt
->salt_iter
= iter
- 1;
10091 char *salt_pos
= strchr (iter_pos
, '#');
10093 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10097 char *digest_pos
= strchr (salt_pos
, '#');
10099 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10103 uint salt_len
= digest_pos
- salt_pos
- 1;
10105 u32
*digest
= (u32
*) hash_buf
->digest
;
10107 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10108 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10109 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10110 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10112 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10114 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10116 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10118 salt
->salt_len
= salt_len
;
10120 return (PARSER_OK
);
10123 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10125 u32
*digest
= (u32
*) hash_buf
->digest
;
10127 salt_t
*salt
= hash_buf
->salt
;
10129 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10133 memcpy (&in
, input_buf
, input_len
);
10135 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10137 memcpy (digest
, in
.keymic
, 16);
10140 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10141 The phrase "Pairwise key expansion"
10142 Access Point Address (referred to as Authenticator Address AA)
10143 Supplicant Address (referred to as Supplicant Address SA)
10144 Access Point Nonce (referred to as Authenticator Anonce)
10145 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10148 uint salt_len
= strlen (in
.essid
);
10150 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10152 salt
->salt_len
= salt_len
;
10154 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10156 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10158 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10160 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10162 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10163 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10167 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10168 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10171 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10173 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10174 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10178 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10179 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10182 for (int i
= 0; i
< 25; i
++)
10184 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10187 wpa
->keyver
= in
.keyver
;
10189 if (wpa
->keyver
> 255)
10191 log_info ("ATTENTION!");
10192 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10193 log_info (" This could be due to a recent aircrack-ng bug.");
10194 log_info (" The key version was automatically reset to a reasonable value.");
10197 wpa
->keyver
&= 0xff;
10200 wpa
->eapol_size
= in
.eapol_size
;
10202 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10204 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10206 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10208 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10210 if (wpa
->keyver
== 1)
10216 digest
[0] = byte_swap_32 (digest
[0]);
10217 digest
[1] = byte_swap_32 (digest
[1]);
10218 digest
[2] = byte_swap_32 (digest
[2]);
10219 digest
[3] = byte_swap_32 (digest
[3]);
10221 for (int i
= 0; i
< 64; i
++)
10223 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10227 salt
->salt_buf
[10] = digest
[1];
10228 salt
->salt_buf
[11] = digest
[2];
10230 return (PARSER_OK
);
10233 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10235 u32
*digest
= (u32
*) hash_buf
->digest
;
10237 salt_t
*salt
= hash_buf
->salt
;
10239 if (input_len
== 0)
10241 log_error ("Password Safe v2 container not specified");
10246 FILE *fp
= fopen (input_buf
, "rb");
10250 log_error ("%s: %s", input_buf
, strerror (errno
));
10257 memset (&buf
, 0, sizeof (psafe2_hdr
));
10259 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10263 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10265 salt
->salt_buf
[0] = buf
.random
[0];
10266 salt
->salt_buf
[1] = buf
.random
[1];
10268 salt
->salt_len
= 8;
10269 salt
->salt_iter
= 1000;
10271 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10272 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10273 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10274 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10275 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10277 return (PARSER_OK
);
10280 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10282 u32
*digest
= (u32
*) hash_buf
->digest
;
10284 salt_t
*salt
= hash_buf
->salt
;
10286 if (input_len
== 0)
10288 log_error (".psafe3 not specified");
10293 FILE *fp
= fopen (input_buf
, "rb");
10297 log_error ("%s: %s", input_buf
, strerror (errno
));
10304 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10308 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10310 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10312 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10314 salt
->salt_iter
= in
.iterations
+ 1;
10316 salt
->salt_buf
[0] = in
.salt_buf
[0];
10317 salt
->salt_buf
[1] = in
.salt_buf
[1];
10318 salt
->salt_buf
[2] = in
.salt_buf
[2];
10319 salt
->salt_buf
[3] = in
.salt_buf
[3];
10320 salt
->salt_buf
[4] = in
.salt_buf
[4];
10321 salt
->salt_buf
[5] = in
.salt_buf
[5];
10322 salt
->salt_buf
[6] = in
.salt_buf
[6];
10323 salt
->salt_buf
[7] = in
.salt_buf
[7];
10325 salt
->salt_len
= 32;
10327 digest
[0] = in
.hash_buf
[0];
10328 digest
[1] = in
.hash_buf
[1];
10329 digest
[2] = in
.hash_buf
[2];
10330 digest
[3] = in
.hash_buf
[3];
10331 digest
[4] = in
.hash_buf
[4];
10332 digest
[5] = in
.hash_buf
[5];
10333 digest
[6] = in
.hash_buf
[6];
10334 digest
[7] = in
.hash_buf
[7];
10336 digest
[0] = byte_swap_32 (digest
[0]);
10337 digest
[1] = byte_swap_32 (digest
[1]);
10338 digest
[2] = byte_swap_32 (digest
[2]);
10339 digest
[3] = byte_swap_32 (digest
[3]);
10340 digest
[4] = byte_swap_32 (digest
[4]);
10341 digest
[5] = byte_swap_32 (digest
[5]);
10342 digest
[6] = byte_swap_32 (digest
[6]);
10343 digest
[7] = byte_swap_32 (digest
[7]);
10345 return (PARSER_OK
);
10348 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10350 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10352 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10354 u32
*digest
= (u32
*) hash_buf
->digest
;
10356 salt_t
*salt
= hash_buf
->salt
;
10358 char *iter_pos
= input_buf
+ 3;
10360 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10362 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10364 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10366 salt
->salt_iter
= salt_iter
;
10368 char *salt_pos
= iter_pos
+ 1;
10372 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10374 salt
->salt_len
= salt_len
;
10376 char *hash_pos
= salt_pos
+ salt_len
;
10378 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10380 return (PARSER_OK
);
10383 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10385 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10387 u32
*digest
= (u32
*) hash_buf
->digest
;
10389 salt_t
*salt
= hash_buf
->salt
;
10391 char *salt_pos
= input_buf
+ 3;
10393 uint iterations_len
= 0;
10395 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10399 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10401 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10402 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10406 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10410 iterations_len
+= 8;
10414 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10417 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10419 char *hash_pos
= strchr (salt_pos
, '$');
10421 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10423 uint salt_len
= hash_pos
- salt_pos
;
10425 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10427 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10429 salt
->salt_len
= salt_len
;
10433 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10435 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10437 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10439 return (PARSER_OK
);
10442 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10444 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10446 u32
*digest
= (u32
*) hash_buf
->digest
;
10448 salt_t
*salt
= hash_buf
->salt
;
10450 char *salt_pos
= input_buf
+ 6;
10452 uint iterations_len
= 0;
10454 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10458 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10460 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10461 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10465 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10469 iterations_len
+= 8;
10473 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10476 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10478 char *hash_pos
= strchr (salt_pos
, '$');
10480 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10482 uint salt_len
= hash_pos
- salt_pos
;
10484 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10486 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10488 salt
->salt_len
= salt_len
;
10492 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10494 return (PARSER_OK
);
10497 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10499 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10501 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10503 u32
*digest
= (u32
*) hash_buf
->digest
;
10505 salt_t
*salt
= hash_buf
->salt
;
10507 char *salt_pos
= input_buf
+ 14;
10509 char *hash_pos
= strchr (salt_pos
, '*');
10511 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10515 uint salt_len
= hash_pos
- salt_pos
- 1;
10517 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10519 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10521 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10523 salt
->salt_len
= salt_len
;
10525 u8 tmp_buf
[100] = { 0 };
10527 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10529 memcpy (digest
, tmp_buf
, 20);
10531 digest
[0] = byte_swap_32 (digest
[0]);
10532 digest
[1] = byte_swap_32 (digest
[1]);
10533 digest
[2] = byte_swap_32 (digest
[2]);
10534 digest
[3] = byte_swap_32 (digest
[3]);
10535 digest
[4] = byte_swap_32 (digest
[4]);
10537 digest
[0] -= SHA1M_A
;
10538 digest
[1] -= SHA1M_B
;
10539 digest
[2] -= SHA1M_C
;
10540 digest
[3] -= SHA1M_D
;
10541 digest
[4] -= SHA1M_E
;
10543 return (PARSER_OK
);
10546 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10548 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10550 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10552 if (c12
& 3) return (PARSER_HASH_VALUE
);
10554 u32
*digest
= (u32
*) hash_buf
->digest
;
10556 salt_t
*salt
= hash_buf
->salt
;
10558 // for ascii_digest
10559 salt
->salt_sign
[0] = input_buf
[0];
10560 salt
->salt_sign
[1] = input_buf
[1];
10562 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10563 | itoa64_to_int (input_buf
[1]) << 6;
10565 salt
->salt_len
= 2;
10567 u8 tmp_buf
[100] = { 0 };
10569 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10571 memcpy (digest
, tmp_buf
, 8);
10575 IP (digest
[0], digest
[1], tt
);
10580 return (PARSER_OK
);
10583 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10585 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10587 u32
*digest
= (u32
*) hash_buf
->digest
;
10589 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10590 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10591 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10592 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10594 digest
[0] = byte_swap_32 (digest
[0]);
10595 digest
[1] = byte_swap_32 (digest
[1]);
10596 digest
[2] = byte_swap_32 (digest
[2]);
10597 digest
[3] = byte_swap_32 (digest
[3]);
10599 digest
[0] -= MD4M_A
;
10600 digest
[1] -= MD4M_B
;
10601 digest
[2] -= MD4M_C
;
10602 digest
[3] -= MD4M_D
;
10604 return (PARSER_OK
);
10607 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10609 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10611 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10615 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10618 u32
*digest
= (u32
*) hash_buf
->digest
;
10620 salt_t
*salt
= hash_buf
->salt
;
10622 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10623 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10624 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10625 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10627 digest
[0] = byte_swap_32 (digest
[0]);
10628 digest
[1] = byte_swap_32 (digest
[1]);
10629 digest
[2] = byte_swap_32 (digest
[2]);
10630 digest
[3] = byte_swap_32 (digest
[3]);
10632 digest
[0] -= MD4M_A
;
10633 digest
[1] -= MD4M_B
;
10634 digest
[2] -= MD4M_C
;
10635 digest
[3] -= MD4M_D
;
10637 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10639 uint salt_len
= input_len
- 32 - 1;
10641 char *salt_buf
= input_buf
+ 32 + 1;
10643 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10645 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10647 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10649 salt
->salt_len
= salt_len
;
10651 return (PARSER_OK
);
10654 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10656 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10658 u32
*digest
= (u32
*) hash_buf
->digest
;
10660 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10661 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10662 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10663 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10665 digest
[0] = byte_swap_32 (digest
[0]);
10666 digest
[1] = byte_swap_32 (digest
[1]);
10667 digest
[2] = byte_swap_32 (digest
[2]);
10668 digest
[3] = byte_swap_32 (digest
[3]);
10670 digest
[0] -= MD5M_A
;
10671 digest
[1] -= MD5M_B
;
10672 digest
[2] -= MD5M_C
;
10673 digest
[3] -= MD5M_D
;
10675 return (PARSER_OK
);
10678 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10680 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) 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]);
10689 digest
[0] = byte_swap_32 (digest
[0]);
10690 digest
[1] = byte_swap_32 (digest
[1]);
10692 return (PARSER_OK
);
10695 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10697 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10699 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10703 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10706 u32
*digest
= (u32
*) hash_buf
->digest
;
10708 salt_t
*salt
= hash_buf
->salt
;
10710 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10711 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10712 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10713 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10715 digest
[0] = byte_swap_32 (digest
[0]);
10716 digest
[1] = byte_swap_32 (digest
[1]);
10717 digest
[2] = byte_swap_32 (digest
[2]);
10718 digest
[3] = byte_swap_32 (digest
[3]);
10720 digest
[0] -= MD5M_A
;
10721 digest
[1] -= MD5M_B
;
10722 digest
[2] -= MD5M_C
;
10723 digest
[3] -= MD5M_D
;
10725 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10727 uint salt_len
= input_len
- 32 - 1;
10729 char *salt_buf
= input_buf
+ 32 + 1;
10731 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10733 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10735 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10737 salt
->salt_len
= salt_len
;
10739 return (PARSER_OK
);
10742 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10744 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10746 u32
*digest
= (u32
*) hash_buf
->digest
;
10748 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10749 | itoa64_to_int (input_buf
[ 1]) << 6
10750 | itoa64_to_int (input_buf
[ 2]) << 12
10751 | itoa64_to_int (input_buf
[ 3]) << 18;
10752 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10753 | itoa64_to_int (input_buf
[ 5]) << 6
10754 | itoa64_to_int (input_buf
[ 6]) << 12
10755 | itoa64_to_int (input_buf
[ 7]) << 18;
10756 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10757 | itoa64_to_int (input_buf
[ 9]) << 6
10758 | itoa64_to_int (input_buf
[10]) << 12
10759 | itoa64_to_int (input_buf
[11]) << 18;
10760 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10761 | itoa64_to_int (input_buf
[13]) << 6
10762 | itoa64_to_int (input_buf
[14]) << 12
10763 | itoa64_to_int (input_buf
[15]) << 18;
10765 digest
[0] -= MD5M_A
;
10766 digest
[1] -= MD5M_B
;
10767 digest
[2] -= MD5M_C
;
10768 digest
[3] -= MD5M_D
;
10770 digest
[0] &= 0x00ffffff;
10771 digest
[1] &= 0x00ffffff;
10772 digest
[2] &= 0x00ffffff;
10773 digest
[3] &= 0x00ffffff;
10775 return (PARSER_OK
);
10778 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10780 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10782 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10786 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10789 u32
*digest
= (u32
*) hash_buf
->digest
;
10791 salt_t
*salt
= hash_buf
->salt
;
10793 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10794 | itoa64_to_int (input_buf
[ 1]) << 6
10795 | itoa64_to_int (input_buf
[ 2]) << 12
10796 | itoa64_to_int (input_buf
[ 3]) << 18;
10797 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10798 | itoa64_to_int (input_buf
[ 5]) << 6
10799 | itoa64_to_int (input_buf
[ 6]) << 12
10800 | itoa64_to_int (input_buf
[ 7]) << 18;
10801 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10802 | itoa64_to_int (input_buf
[ 9]) << 6
10803 | itoa64_to_int (input_buf
[10]) << 12
10804 | itoa64_to_int (input_buf
[11]) << 18;
10805 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10806 | itoa64_to_int (input_buf
[13]) << 6
10807 | itoa64_to_int (input_buf
[14]) << 12
10808 | itoa64_to_int (input_buf
[15]) << 18;
10810 digest
[0] -= MD5M_A
;
10811 digest
[1] -= MD5M_B
;
10812 digest
[2] -= MD5M_C
;
10813 digest
[3] -= MD5M_D
;
10815 digest
[0] &= 0x00ffffff;
10816 digest
[1] &= 0x00ffffff;
10817 digest
[2] &= 0x00ffffff;
10818 digest
[3] &= 0x00ffffff;
10820 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10822 uint salt_len
= input_len
- 16 - 1;
10824 char *salt_buf
= input_buf
+ 16 + 1;
10826 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10828 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10830 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10832 salt
->salt_len
= salt_len
;
10834 return (PARSER_OK
);
10837 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10839 key
[0] = (nthash
[0] >> 0);
10840 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10841 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10842 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10843 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10844 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10845 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10846 key
[7] = (nthash
[6] << 1);
10858 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10860 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10862 u32
*digest
= (u32
*) hash_buf
->digest
;
10864 salt_t
*salt
= hash_buf
->salt
;
10866 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10872 char *user_pos
= input_buf
;
10874 char *unused_pos
= strchr (user_pos
, ':');
10876 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10878 uint user_len
= unused_pos
- user_pos
;
10880 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10884 char *domain_pos
= strchr (unused_pos
, ':');
10886 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10888 uint unused_len
= domain_pos
- unused_pos
;
10890 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10894 char *srvchall_pos
= strchr (domain_pos
, ':');
10896 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10898 uint domain_len
= srvchall_pos
- domain_pos
;
10900 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10904 char *hash_pos
= strchr (srvchall_pos
, ':');
10906 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10908 uint srvchall_len
= hash_pos
- srvchall_pos
;
10910 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10914 char *clichall_pos
= strchr (hash_pos
, ':');
10916 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10918 uint hash_len
= clichall_pos
- hash_pos
;
10920 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10924 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10926 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10929 * store some data for later use
10932 netntlm
->user_len
= user_len
* 2;
10933 netntlm
->domain_len
= domain_len
* 2;
10934 netntlm
->srvchall_len
= srvchall_len
/ 2;
10935 netntlm
->clichall_len
= clichall_len
/ 2;
10937 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10938 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10941 * handle username and domainname
10944 for (uint i
= 0; i
< user_len
; i
++)
10946 *userdomain_ptr
++ = user_pos
[i
];
10947 *userdomain_ptr
++ = 0;
10950 for (uint i
= 0; i
< domain_len
; i
++)
10952 *userdomain_ptr
++ = domain_pos
[i
];
10953 *userdomain_ptr
++ = 0;
10957 * handle server challenge encoding
10960 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10962 const char p0
= srvchall_pos
[i
+ 0];
10963 const char p1
= srvchall_pos
[i
+ 1];
10965 *chall_ptr
++ = hex_convert (p1
) << 0
10966 | hex_convert (p0
) << 4;
10970 * handle client challenge encoding
10973 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10975 const char p0
= clichall_pos
[i
+ 0];
10976 const char p1
= clichall_pos
[i
+ 1];
10978 *chall_ptr
++ = hex_convert (p1
) << 0
10979 | hex_convert (p0
) << 4;
10986 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10988 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10990 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10992 salt
->salt_len
= salt_len
;
10994 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10995 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10996 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10997 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10999 digest
[0] = byte_swap_32 (digest
[0]);
11000 digest
[1] = byte_swap_32 (digest
[1]);
11001 digest
[2] = byte_swap_32 (digest
[2]);
11002 digest
[3] = byte_swap_32 (digest
[3]);
11004 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11006 uint digest_tmp
[2] = { 0 };
11008 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11009 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11011 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11012 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11014 /* special case 2: ESS */
11016 if (srvchall_len
== 48)
11018 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11020 uint w
[16] = { 0 };
11022 w
[ 0] = netntlm
->chall_buf
[6];
11023 w
[ 1] = netntlm
->chall_buf
[7];
11024 w
[ 2] = netntlm
->chall_buf
[0];
11025 w
[ 3] = netntlm
->chall_buf
[1];
11029 uint dgst
[4] = { 0 };
11038 salt
->salt_buf
[0] = dgst
[0];
11039 salt
->salt_buf
[1] = dgst
[1];
11043 /* precompute netntlmv1 exploit start */
11045 for (uint i
= 0; i
< 0x10000; i
++)
11047 uint key_md4
[2] = { i
, 0 };
11048 uint key_des
[2] = { 0, 0 };
11050 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11052 uint Kc
[16] = { 0 };
11053 uint Kd
[16] = { 0 };
11055 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11057 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11059 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11061 if (data3
[0] != digest_tmp
[0]) continue;
11062 if (data3
[1] != digest_tmp
[1]) continue;
11064 salt
->salt_buf
[2] = i
;
11066 salt
->salt_len
= 24;
11071 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11072 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11074 /* precompute netntlmv1 exploit stop */
11078 IP (digest
[0], digest
[1], tt
);
11079 IP (digest
[2], digest
[3], tt
);
11081 digest
[0] = rotr32 (digest
[0], 29);
11082 digest
[1] = rotr32 (digest
[1], 29);
11083 digest
[2] = rotr32 (digest
[2], 29);
11084 digest
[3] = rotr32 (digest
[3], 29);
11086 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11088 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11089 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11091 return (PARSER_OK
);
11094 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11096 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11098 u32
*digest
= (u32
*) hash_buf
->digest
;
11100 salt_t
*salt
= hash_buf
->salt
;
11102 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11108 char *user_pos
= input_buf
;
11110 char *unused_pos
= strchr (user_pos
, ':');
11112 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11114 uint user_len
= unused_pos
- user_pos
;
11116 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11120 char *domain_pos
= strchr (unused_pos
, ':');
11122 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11124 uint unused_len
= domain_pos
- unused_pos
;
11126 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11130 char *srvchall_pos
= strchr (domain_pos
, ':');
11132 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11134 uint domain_len
= srvchall_pos
- domain_pos
;
11136 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11140 char *hash_pos
= strchr (srvchall_pos
, ':');
11142 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11144 uint srvchall_len
= hash_pos
- srvchall_pos
;
11146 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11150 char *clichall_pos
= strchr (hash_pos
, ':');
11152 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11154 uint hash_len
= clichall_pos
- hash_pos
;
11156 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11160 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11162 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11164 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11167 * store some data for later use
11170 netntlm
->user_len
= user_len
* 2;
11171 netntlm
->domain_len
= domain_len
* 2;
11172 netntlm
->srvchall_len
= srvchall_len
/ 2;
11173 netntlm
->clichall_len
= clichall_len
/ 2;
11175 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11176 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11179 * handle username and domainname
11182 for (uint i
= 0; i
< user_len
; i
++)
11184 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11185 *userdomain_ptr
++ = 0;
11188 for (uint i
= 0; i
< domain_len
; i
++)
11190 *userdomain_ptr
++ = domain_pos
[i
];
11191 *userdomain_ptr
++ = 0;
11194 *userdomain_ptr
++ = 0x80;
11197 * handle server challenge encoding
11200 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11202 const char p0
= srvchall_pos
[i
+ 0];
11203 const char p1
= srvchall_pos
[i
+ 1];
11205 *chall_ptr
++ = hex_convert (p1
) << 0
11206 | hex_convert (p0
) << 4;
11210 * handle client challenge encoding
11213 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11215 const char p0
= clichall_pos
[i
+ 0];
11216 const char p1
= clichall_pos
[i
+ 1];
11218 *chall_ptr
++ = hex_convert (p1
) << 0
11219 | hex_convert (p0
) << 4;
11222 *chall_ptr
++ = 0x80;
11225 * handle hash itself
11228 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11229 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11230 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11231 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11233 digest
[0] = byte_swap_32 (digest
[0]);
11234 digest
[1] = byte_swap_32 (digest
[1]);
11235 digest
[2] = byte_swap_32 (digest
[2]);
11236 digest
[3] = byte_swap_32 (digest
[3]);
11239 * reuse challange data as salt_buf, its the buffer that is most likely unique
11242 salt
->salt_buf
[0] = 0;
11243 salt
->salt_buf
[1] = 0;
11244 salt
->salt_buf
[2] = 0;
11245 salt
->salt_buf
[3] = 0;
11246 salt
->salt_buf
[4] = 0;
11247 salt
->salt_buf
[5] = 0;
11248 salt
->salt_buf
[6] = 0;
11249 salt
->salt_buf
[7] = 0;
11253 uptr
= (uint
*) netntlm
->userdomain_buf
;
11255 for (uint i
= 0; i
< 16; i
+= 16)
11257 md5_64 (uptr
, salt
->salt_buf
);
11260 uptr
= (uint
*) netntlm
->chall_buf
;
11262 for (uint i
= 0; i
< 256; i
+= 16)
11264 md5_64 (uptr
, salt
->salt_buf
);
11267 salt
->salt_len
= 16;
11269 return (PARSER_OK
);
11272 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11274 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11276 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11280 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11283 u32
*digest
= (u32
*) hash_buf
->digest
;
11285 salt_t
*salt
= hash_buf
->salt
;
11287 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11288 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11289 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11290 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11292 digest
[0] = byte_swap_32 (digest
[0]);
11293 digest
[1] = byte_swap_32 (digest
[1]);
11294 digest
[2] = byte_swap_32 (digest
[2]);
11295 digest
[3] = byte_swap_32 (digest
[3]);
11297 digest
[0] -= MD5M_A
;
11298 digest
[1] -= MD5M_B
;
11299 digest
[2] -= MD5M_C
;
11300 digest
[3] -= MD5M_D
;
11302 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11304 uint salt_len
= input_len
- 32 - 1;
11306 char *salt_buf
= input_buf
+ 32 + 1;
11308 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11310 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11312 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11314 salt
->salt_len
= salt_len
;
11316 return (PARSER_OK
);
11319 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11321 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11323 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11327 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11330 u32
*digest
= (u32
*) hash_buf
->digest
;
11332 salt_t
*salt
= hash_buf
->salt
;
11334 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11335 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11336 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11337 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11339 digest
[0] = byte_swap_32 (digest
[0]);
11340 digest
[1] = byte_swap_32 (digest
[1]);
11341 digest
[2] = byte_swap_32 (digest
[2]);
11342 digest
[3] = byte_swap_32 (digest
[3]);
11344 digest
[0] -= MD5M_A
;
11345 digest
[1] -= MD5M_B
;
11346 digest
[2] -= MD5M_C
;
11347 digest
[3] -= MD5M_D
;
11349 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11351 uint salt_len
= input_len
- 32 - 1;
11353 char *salt_buf
= input_buf
+ 32 + 1;
11355 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11357 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11359 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11361 salt
->salt_len
= salt_len
;
11363 return (PARSER_OK
);
11366 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11368 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11370 u32
*digest
= (u32
*) hash_buf
->digest
;
11372 salt_t
*salt
= hash_buf
->salt
;
11374 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11375 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11376 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11377 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11379 digest
[0] = byte_swap_32 (digest
[0]);
11380 digest
[1] = byte_swap_32 (digest
[1]);
11381 digest
[2] = byte_swap_32 (digest
[2]);
11382 digest
[3] = byte_swap_32 (digest
[3]);
11384 digest
[0] -= MD5M_A
;
11385 digest
[1] -= MD5M_B
;
11386 digest
[2] -= MD5M_C
;
11387 digest
[3] -= MD5M_D
;
11390 * This is a virtual salt. While the algorithm is basically not salted
11391 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11392 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11395 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11397 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11399 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11401 salt
->salt_len
= salt_len
;
11403 return (PARSER_OK
);
11406 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11408 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11410 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11414 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11417 u32
*digest
= (u32
*) hash_buf
->digest
;
11419 salt_t
*salt
= hash_buf
->salt
;
11421 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11422 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11423 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11424 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11426 digest
[0] = byte_swap_32 (digest
[0]);
11427 digest
[1] = byte_swap_32 (digest
[1]);
11428 digest
[2] = byte_swap_32 (digest
[2]);
11429 digest
[3] = byte_swap_32 (digest
[3]);
11431 digest
[0] -= MD5M_A
;
11432 digest
[1] -= MD5M_B
;
11433 digest
[2] -= MD5M_C
;
11434 digest
[3] -= MD5M_D
;
11436 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11438 uint salt_len
= input_len
- 32 - 1;
11440 char *salt_buf
= input_buf
+ 32 + 1;
11442 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11444 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11446 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11448 salt
->salt_len
= salt_len
;
11450 return (PARSER_OK
);
11453 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11455 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11457 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11461 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11464 u32
*digest
= (u32
*) hash_buf
->digest
;
11466 salt_t
*salt
= hash_buf
->salt
;
11468 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11469 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11470 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11471 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11473 digest
[0] = byte_swap_32 (digest
[0]);
11474 digest
[1] = byte_swap_32 (digest
[1]);
11475 digest
[2] = byte_swap_32 (digest
[2]);
11476 digest
[3] = byte_swap_32 (digest
[3]);
11478 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11480 uint salt_len
= input_len
- 32 - 1;
11482 char *salt_buf
= input_buf
+ 32 + 1;
11484 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11486 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11488 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11490 salt
->salt_len
= salt_len
;
11492 return (PARSER_OK
);
11495 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11497 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11499 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11503 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11506 u32
*digest
= (u32
*) hash_buf
->digest
;
11508 salt_t
*salt
= hash_buf
->salt
;
11510 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11511 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11512 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11513 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11515 digest
[0] = byte_swap_32 (digest
[0]);
11516 digest
[1] = byte_swap_32 (digest
[1]);
11517 digest
[2] = byte_swap_32 (digest
[2]);
11518 digest
[3] = byte_swap_32 (digest
[3]);
11520 digest
[0] -= MD4M_A
;
11521 digest
[1] -= MD4M_B
;
11522 digest
[2] -= MD4M_C
;
11523 digest
[3] -= MD4M_D
;
11525 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11527 uint salt_len
= input_len
- 32 - 1;
11529 char *salt_buf
= input_buf
+ 32 + 1;
11531 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11533 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11535 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11537 salt
->salt_len
= salt_len
;
11539 return (PARSER_OK
);
11542 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11544 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11546 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11550 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11553 u32
*digest
= (u32
*) hash_buf
->digest
;
11555 salt_t
*salt
= hash_buf
->salt
;
11557 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11558 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11559 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11560 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11562 digest
[0] = byte_swap_32 (digest
[0]);
11563 digest
[1] = byte_swap_32 (digest
[1]);
11564 digest
[2] = byte_swap_32 (digest
[2]);
11565 digest
[3] = byte_swap_32 (digest
[3]);
11567 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11569 uint salt_len
= input_len
- 32 - 1;
11571 char *salt_buf
= input_buf
+ 32 + 1;
11573 uint salt_pc_block
[16] = { 0 };
11575 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11577 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11579 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11581 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11583 salt_pc_block
[14] = salt_len
* 8;
11585 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11587 md5_64 (salt_pc_block
, salt_pc_digest
);
11589 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11590 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11591 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11592 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11594 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11596 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11598 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11600 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11601 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11602 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11603 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11605 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11607 return (PARSER_OK
);
11610 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11612 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11614 u32
*digest
= (u32
*) hash_buf
->digest
;
11616 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11617 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11618 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11619 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11620 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11622 digest
[0] -= SHA1M_A
;
11623 digest
[1] -= SHA1M_B
;
11624 digest
[2] -= SHA1M_C
;
11625 digest
[3] -= SHA1M_D
;
11626 digest
[4] -= SHA1M_E
;
11628 return (PARSER_OK
);
11631 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11633 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11635 u32
*digest
= (u32
*) hash_buf
->digest
;
11637 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11638 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11639 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11640 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11641 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11643 return (PARSER_OK
);
11646 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11648 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11650 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11654 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11657 u32
*digest
= (u32
*) hash_buf
->digest
;
11659 salt_t
*salt
= hash_buf
->salt
;
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 digest
[0] -= SHA1M_A
;
11668 digest
[1] -= SHA1M_B
;
11669 digest
[2] -= SHA1M_C
;
11670 digest
[3] -= SHA1M_D
;
11671 digest
[4] -= SHA1M_E
;
11673 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11675 uint salt_len
= input_len
- 40 - 1;
11677 char *salt_buf
= input_buf
+ 40 + 1;
11679 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11681 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11683 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11685 salt
->salt_len
= salt_len
;
11687 return (PARSER_OK
);
11690 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11692 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11694 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11696 u32
*digest
= (u32
*) hash_buf
->digest
;
11698 u8 tmp_buf
[100] = { 0 };
11700 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11702 memcpy (digest
, tmp_buf
, 20);
11704 digest
[0] = byte_swap_32 (digest
[0]);
11705 digest
[1] = byte_swap_32 (digest
[1]);
11706 digest
[2] = byte_swap_32 (digest
[2]);
11707 digest
[3] = byte_swap_32 (digest
[3]);
11708 digest
[4] = byte_swap_32 (digest
[4]);
11710 digest
[0] -= SHA1M_A
;
11711 digest
[1] -= SHA1M_B
;
11712 digest
[2] -= SHA1M_C
;
11713 digest
[3] -= SHA1M_D
;
11714 digest
[4] -= SHA1M_E
;
11716 return (PARSER_OK
);
11719 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11721 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11723 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11725 u32
*digest
= (u32
*) hash_buf
->digest
;
11727 salt_t
*salt
= hash_buf
->salt
;
11729 u8 tmp_buf
[100] = { 0 };
11731 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11733 memcpy (digest
, tmp_buf
, 20);
11735 salt
->salt_len
= tmp_len
- 20;
11737 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11739 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11741 char *ptr
= (char *) salt
->salt_buf
;
11743 ptr
[salt
->salt_len
] = 0x80;
11746 digest
[0] = byte_swap_32 (digest
[0]);
11747 digest
[1] = byte_swap_32 (digest
[1]);
11748 digest
[2] = byte_swap_32 (digest
[2]);
11749 digest
[3] = byte_swap_32 (digest
[3]);
11750 digest
[4] = byte_swap_32 (digest
[4]);
11752 digest
[0] -= SHA1M_A
;
11753 digest
[1] -= SHA1M_B
;
11754 digest
[2] -= SHA1M_C
;
11755 digest
[3] -= SHA1M_D
;
11756 digest
[4] -= SHA1M_E
;
11758 return (PARSER_OK
);
11761 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11763 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11765 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11767 u32
*digest
= (u32
*) hash_buf
->digest
;
11769 salt_t
*salt
= hash_buf
->salt
;
11771 char *salt_buf
= input_buf
+ 6;
11775 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11777 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11779 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11781 salt
->salt_len
= salt_len
;
11783 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11785 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11786 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11787 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11788 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11789 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11791 digest
[0] -= SHA1M_A
;
11792 digest
[1] -= SHA1M_B
;
11793 digest
[2] -= SHA1M_C
;
11794 digest
[3] -= SHA1M_D
;
11795 digest
[4] -= SHA1M_E
;
11797 return (PARSER_OK
);
11800 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11802 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11804 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11806 u32
*digest
= (u32
*) hash_buf
->digest
;
11808 salt_t
*salt
= hash_buf
->salt
;
11810 char *salt_buf
= input_buf
+ 6;
11814 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11816 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11818 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11820 salt
->salt_len
= salt_len
;
11822 char *hash_pos
= input_buf
+ 6 + 8;
11824 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11825 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11826 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11827 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11828 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11830 digest
[0] -= SHA1M_A
;
11831 digest
[1] -= SHA1M_B
;
11832 digest
[2] -= SHA1M_C
;
11833 digest
[3] -= SHA1M_D
;
11834 digest
[4] -= SHA1M_E
;
11836 return (PARSER_OK
);
11839 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11841 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11843 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11845 u64
*digest
= (u64
*) hash_buf
->digest
;
11847 salt_t
*salt
= hash_buf
->salt
;
11849 char *salt_buf
= input_buf
+ 6;
11853 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11855 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11857 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11859 salt
->salt_len
= salt_len
;
11861 char *hash_pos
= input_buf
+ 6 + 8;
11863 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11864 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11865 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11866 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11867 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11868 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11869 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11870 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11872 digest
[0] -= SHA512M_A
;
11873 digest
[1] -= SHA512M_B
;
11874 digest
[2] -= SHA512M_C
;
11875 digest
[3] -= SHA512M_D
;
11876 digest
[4] -= SHA512M_E
;
11877 digest
[5] -= SHA512M_F
;
11878 digest
[6] -= SHA512M_G
;
11879 digest
[7] -= SHA512M_H
;
11881 return (PARSER_OK
);
11884 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11886 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11888 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11892 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11895 u32
*digest
= (u32
*) hash_buf
->digest
;
11897 salt_t
*salt
= hash_buf
->salt
;
11899 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11900 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11904 digest
[0] = byte_swap_32 (digest
[0]);
11905 digest
[1] = byte_swap_32 (digest
[1]);
11907 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11909 uint salt_len
= input_len
- 16 - 1;
11911 char *salt_buf
= input_buf
+ 16 + 1;
11913 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11915 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11917 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11919 salt
->salt_len
= salt_len
;
11921 return (PARSER_OK
);
11924 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11926 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11928 u32
*digest
= (u32
*) hash_buf
->digest
;
11930 salt_t
*salt
= hash_buf
->salt
;
11932 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11933 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11934 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11935 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11936 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11938 digest
[0] -= SHA1M_A
;
11939 digest
[1] -= SHA1M_B
;
11940 digest
[2] -= SHA1M_C
;
11941 digest
[3] -= SHA1M_D
;
11942 digest
[4] -= SHA1M_E
;
11944 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11946 uint salt_len
= input_len
- 40 - 1;
11948 char *salt_buf
= input_buf
+ 40 + 1;
11950 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11952 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11954 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11956 salt
->salt_len
= salt_len
;
11958 return (PARSER_OK
);
11961 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11963 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11965 u32
*digest
= (u32
*) hash_buf
->digest
;
11967 salt_t
*salt
= hash_buf
->salt
;
11969 char *hash_pos
= input_buf
;
11971 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11972 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11973 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
11974 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
11975 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
11976 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
11977 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
11978 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
11979 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
11980 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
11981 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
11982 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
11983 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
11984 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
11985 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
11986 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
11988 char *salt_pos
= input_buf
+ 128;
11990 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
11991 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
11992 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
11993 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
11995 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11996 salt
->salt_len
= 16;
11998 return (PARSER_OK
);
12001 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12003 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12005 u32
*digest
= (u32
*) hash_buf
->digest
;
12007 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12008 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12009 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12010 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12011 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12012 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12013 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12014 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12016 digest
[0] -= SHA256M_A
;
12017 digest
[1] -= SHA256M_B
;
12018 digest
[2] -= SHA256M_C
;
12019 digest
[3] -= SHA256M_D
;
12020 digest
[4] -= SHA256M_E
;
12021 digest
[5] -= SHA256M_F
;
12022 digest
[6] -= SHA256M_G
;
12023 digest
[7] -= SHA256M_H
;
12025 return (PARSER_OK
);
12028 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12030 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12032 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12036 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12039 u32
*digest
= (u32
*) hash_buf
->digest
;
12041 salt_t
*salt
= hash_buf
->salt
;
12043 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12044 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12045 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12046 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12047 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12048 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12049 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12050 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12052 digest
[0] -= SHA256M_A
;
12053 digest
[1] -= SHA256M_B
;
12054 digest
[2] -= SHA256M_C
;
12055 digest
[3] -= SHA256M_D
;
12056 digest
[4] -= SHA256M_E
;
12057 digest
[5] -= SHA256M_F
;
12058 digest
[6] -= SHA256M_G
;
12059 digest
[7] -= SHA256M_H
;
12061 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12063 uint salt_len
= input_len
- 64 - 1;
12065 char *salt_buf
= input_buf
+ 64 + 1;
12067 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12069 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12071 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12073 salt
->salt_len
= salt_len
;
12075 return (PARSER_OK
);
12078 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12080 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12082 u64
*digest
= (u64
*) hash_buf
->digest
;
12084 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12085 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12086 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12087 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12088 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12089 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12093 digest
[0] -= SHA384M_A
;
12094 digest
[1] -= SHA384M_B
;
12095 digest
[2] -= SHA384M_C
;
12096 digest
[3] -= SHA384M_D
;
12097 digest
[4] -= SHA384M_E
;
12098 digest
[5] -= SHA384M_F
;
12102 return (PARSER_OK
);
12105 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12107 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12109 u64
*digest
= (u64
*) hash_buf
->digest
;
12111 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12112 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12113 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12114 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12115 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12116 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12117 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12118 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12120 digest
[0] -= SHA512M_A
;
12121 digest
[1] -= SHA512M_B
;
12122 digest
[2] -= SHA512M_C
;
12123 digest
[3] -= SHA512M_D
;
12124 digest
[4] -= SHA512M_E
;
12125 digest
[5] -= SHA512M_F
;
12126 digest
[6] -= SHA512M_G
;
12127 digest
[7] -= SHA512M_H
;
12129 return (PARSER_OK
);
12132 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12134 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12136 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12140 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12143 u64
*digest
= (u64
*) hash_buf
->digest
;
12145 salt_t
*salt
= hash_buf
->salt
;
12147 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12148 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12149 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12150 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12151 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12152 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12153 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12154 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12156 digest
[0] -= SHA512M_A
;
12157 digest
[1] -= SHA512M_B
;
12158 digest
[2] -= SHA512M_C
;
12159 digest
[3] -= SHA512M_D
;
12160 digest
[4] -= SHA512M_E
;
12161 digest
[5] -= SHA512M_F
;
12162 digest
[6] -= SHA512M_G
;
12163 digest
[7] -= SHA512M_H
;
12165 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12167 uint salt_len
= input_len
- 128 - 1;
12169 char *salt_buf
= input_buf
+ 128 + 1;
12171 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12173 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12175 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12177 salt
->salt_len
= salt_len
;
12179 return (PARSER_OK
);
12182 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12184 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12186 u64
*digest
= (u64
*) hash_buf
->digest
;
12188 salt_t
*salt
= hash_buf
->salt
;
12190 char *salt_pos
= input_buf
+ 3;
12192 uint iterations_len
= 0;
12194 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12198 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12200 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12201 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12205 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12209 iterations_len
+= 8;
12213 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12216 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12218 char *hash_pos
= strchr (salt_pos
, '$');
12220 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12222 uint salt_len
= hash_pos
- salt_pos
;
12224 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12226 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12228 salt
->salt_len
= salt_len
;
12232 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12234 return (PARSER_OK
);
12237 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12239 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12241 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12243 u64
*digest
= (u64
*) hash_buf
->digest
;
12245 salt_t
*salt
= hash_buf
->salt
;
12247 uint keccak_mdlen
= input_len
/ 2;
12249 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12251 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12253 digest
[i
] = byte_swap_64 (digest
[i
]);
12256 salt
->keccak_mdlen
= keccak_mdlen
;
12258 return (PARSER_OK
);
12261 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12263 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12265 u32
*digest
= (u32
*) hash_buf
->digest
;
12267 salt_t
*salt
= hash_buf
->salt
;
12269 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12272 * Parse that strange long line
12277 size_t in_len
[9] = { 0 };
12279 in_off
[0] = strtok (input_buf
, ":");
12281 in_len
[0] = strlen (in_off
[0]);
12285 for (i
= 1; i
< 9; i
++)
12287 in_off
[i
] = strtok (NULL
, ":");
12289 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12291 in_len
[i
] = strlen (in_off
[i
]);
12294 char *ptr
= (char *) ikepsk
->msg_buf
;
12296 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12297 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12298 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12299 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12300 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12301 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12305 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12307 ptr
= (char *) ikepsk
->nr_buf
;
12309 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12310 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12314 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12317 * Store to database
12322 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12323 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12324 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12325 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12327 digest
[0] = byte_swap_32 (digest
[0]);
12328 digest
[1] = byte_swap_32 (digest
[1]);
12329 digest
[2] = byte_swap_32 (digest
[2]);
12330 digest
[3] = byte_swap_32 (digest
[3]);
12332 salt
->salt_len
= 32;
12334 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12335 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12336 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12337 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12338 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12339 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12340 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12341 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12343 return (PARSER_OK
);
12346 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12348 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12350 u32
*digest
= (u32
*) hash_buf
->digest
;
12352 salt_t
*salt
= hash_buf
->salt
;
12354 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12357 * Parse that strange long line
12362 size_t in_len
[9] = { 0 };
12364 in_off
[0] = strtok (input_buf
, ":");
12366 in_len
[0] = strlen (in_off
[0]);
12370 for (i
= 1; i
< 9; i
++)
12372 in_off
[i
] = strtok (NULL
, ":");
12374 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12376 in_len
[i
] = strlen (in_off
[i
]);
12379 char *ptr
= (char *) ikepsk
->msg_buf
;
12381 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12382 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12383 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12384 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12385 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12386 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12390 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12392 ptr
= (char *) ikepsk
->nr_buf
;
12394 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12395 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12399 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12402 * Store to database
12407 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12408 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12409 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12410 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12411 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12413 salt
->salt_len
= 32;
12415 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12416 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12417 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12418 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12419 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12420 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12421 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12422 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12424 return (PARSER_OK
);
12427 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12429 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12431 u32
*digest
= (u32
*) hash_buf
->digest
;
12433 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12434 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12435 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12436 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12437 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12439 digest
[0] = byte_swap_32 (digest
[0]);
12440 digest
[1] = byte_swap_32 (digest
[1]);
12441 digest
[2] = byte_swap_32 (digest
[2]);
12442 digest
[3] = byte_swap_32 (digest
[3]);
12443 digest
[4] = byte_swap_32 (digest
[4]);
12445 return (PARSER_OK
);
12448 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12450 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12452 u32
*digest
= (u32
*) hash_buf
->digest
;
12454 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12455 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12456 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12457 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12458 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12459 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12460 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12461 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12462 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12463 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12464 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12465 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12466 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12467 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12468 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12469 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12471 return (PARSER_OK
);
12474 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12476 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12478 u32
*digest
= (u32
*) hash_buf
->digest
;
12480 salt_t
*salt
= hash_buf
->salt
;
12482 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12483 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12484 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12485 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12486 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12488 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12490 uint salt_len
= input_len
- 40 - 1;
12492 char *salt_buf
= input_buf
+ 40 + 1;
12494 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12496 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12498 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12500 salt
->salt_len
= salt_len
;
12502 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12504 return (PARSER_OK
);
12507 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12509 u32
*digest
= (u32
*) hash_buf
->digest
;
12511 salt_t
*salt
= hash_buf
->salt
;
12513 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12515 if (input_len
== 0)
12517 log_error ("TrueCrypt container not specified");
12522 FILE *fp
= fopen (input_buf
, "rb");
12526 log_error ("%s: %s", input_buf
, strerror (errno
));
12531 char buf
[512] = { 0 };
12533 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12537 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12539 memcpy (tc
->salt_buf
, buf
, 64);
12541 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12543 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12545 salt
->salt_len
= 4;
12547 salt
->salt_iter
= 1000 - 1;
12549 digest
[0] = tc
->data_buf
[0];
12551 return (PARSER_OK
);
12554 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12556 u32
*digest
= (u32
*) hash_buf
->digest
;
12558 salt_t
*salt
= hash_buf
->salt
;
12560 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12562 if (input_len
== 0)
12564 log_error ("TrueCrypt container not specified");
12569 FILE *fp
= fopen (input_buf
, "rb");
12573 log_error ("%s: %s", input_buf
, strerror (errno
));
12578 char buf
[512] = { 0 };
12580 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12584 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12586 memcpy (tc
->salt_buf
, buf
, 64);
12588 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12590 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12592 salt
->salt_len
= 4;
12594 salt
->salt_iter
= 2000 - 1;
12596 digest
[0] = tc
->data_buf
[0];
12598 return (PARSER_OK
);
12601 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12603 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12605 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12607 u32
*digest
= (u32
*) hash_buf
->digest
;
12609 salt_t
*salt
= hash_buf
->salt
;
12611 char *salt_pos
= input_buf
+ 6;
12613 char *hash_pos
= strchr (salt_pos
, '$');
12615 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12617 uint salt_len
= hash_pos
- salt_pos
;
12619 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12621 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12623 salt
->salt_len
= salt_len
;
12625 salt
->salt_iter
= 1000;
12629 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12631 return (PARSER_OK
);
12634 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12636 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12638 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12640 u32
*digest
= (u32
*) hash_buf
->digest
;
12642 salt_t
*salt
= hash_buf
->salt
;
12644 char *iter_pos
= input_buf
+ 7;
12646 char *salt_pos
= strchr (iter_pos
, '$');
12648 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12652 char *hash_pos
= strchr (salt_pos
, '$');
12654 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12656 uint salt_len
= hash_pos
- salt_pos
;
12658 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12660 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12662 salt
->salt_len
= salt_len
;
12664 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12666 salt
->salt_sign
[0] = atoi (salt_iter
);
12668 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12672 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12674 digest
[0] = byte_swap_32 (digest
[0]);
12675 digest
[1] = byte_swap_32 (digest
[1]);
12676 digest
[2] = byte_swap_32 (digest
[2]);
12677 digest
[3] = byte_swap_32 (digest
[3]);
12678 digest
[4] = byte_swap_32 (digest
[4]);
12680 return (PARSER_OK
);
12683 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12685 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12687 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12689 u32
*digest
= (u32
*) hash_buf
->digest
;
12691 salt_t
*salt
= hash_buf
->salt
;
12693 char *iter_pos
= input_buf
+ 9;
12695 char *salt_pos
= strchr (iter_pos
, '$');
12697 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12701 char *hash_pos
= strchr (salt_pos
, '$');
12703 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12705 uint salt_len
= hash_pos
- salt_pos
;
12707 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12709 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12711 salt
->salt_len
= salt_len
;
12713 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12715 salt
->salt_sign
[0] = atoi (salt_iter
);
12717 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12721 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12723 digest
[0] = byte_swap_32 (digest
[0]);
12724 digest
[1] = byte_swap_32 (digest
[1]);
12725 digest
[2] = byte_swap_32 (digest
[2]);
12726 digest
[3] = byte_swap_32 (digest
[3]);
12727 digest
[4] = byte_swap_32 (digest
[4]);
12728 digest
[5] = byte_swap_32 (digest
[5]);
12729 digest
[6] = byte_swap_32 (digest
[6]);
12730 digest
[7] = byte_swap_32 (digest
[7]);
12732 return (PARSER_OK
);
12735 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12737 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12739 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12741 u64
*digest
= (u64
*) hash_buf
->digest
;
12743 salt_t
*salt
= hash_buf
->salt
;
12745 char *iter_pos
= input_buf
+ 9;
12747 char *salt_pos
= strchr (iter_pos
, '$');
12749 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12753 char *hash_pos
= strchr (salt_pos
, '$');
12755 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12757 uint salt_len
= hash_pos
- salt_pos
;
12759 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12761 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12763 salt
->salt_len
= salt_len
;
12765 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12767 salt
->salt_sign
[0] = atoi (salt_iter
);
12769 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12773 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12775 digest
[0] = byte_swap_64 (digest
[0]);
12776 digest
[1] = byte_swap_64 (digest
[1]);
12777 digest
[2] = byte_swap_64 (digest
[2]);
12778 digest
[3] = byte_swap_64 (digest
[3]);
12779 digest
[4] = byte_swap_64 (digest
[4]);
12780 digest
[5] = byte_swap_64 (digest
[5]);
12781 digest
[6] = byte_swap_64 (digest
[6]);
12782 digest
[7] = byte_swap_64 (digest
[7]);
12784 return (PARSER_OK
);
12787 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12789 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12791 u32
*digest
= (u32
*) hash_buf
->digest
;
12793 salt_t
*salt
= hash_buf
->salt
;
12795 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12801 char *iterations_pos
= input_buf
;
12803 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12805 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12807 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12809 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12813 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12815 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12817 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12819 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12821 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12823 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12828 * pbkdf2 iterations
12831 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12834 * handle salt encoding
12837 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12839 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12841 const char p0
= saltbuf_pos
[i
+ 0];
12842 const char p1
= saltbuf_pos
[i
+ 1];
12844 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12845 | hex_convert (p0
) << 4;
12848 salt
->salt_len
= saltbuf_len
/ 2;
12851 * handle cipher encoding
12854 uint
*tmp
= (uint
*) mymalloc (32);
12856 char *cipherbuf_ptr
= (char *) tmp
;
12858 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12860 const char p0
= cipherbuf_pos
[i
+ 0];
12861 const char p1
= cipherbuf_pos
[i
+ 1];
12863 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12864 | hex_convert (p0
) << 4;
12867 // iv is stored at salt_buf 4 (length 16)
12868 // data is stored at salt_buf 8 (length 16)
12870 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12871 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12872 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12873 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12875 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12876 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12877 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12878 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12882 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12884 const char p0
= cipherbuf_pos
[j
+ 0];
12885 const char p1
= cipherbuf_pos
[j
+ 1];
12887 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12888 | hex_convert (p0
) << 4;
12895 digest
[0] = 0x10101010;
12896 digest
[1] = 0x10101010;
12897 digest
[2] = 0x10101010;
12898 digest
[3] = 0x10101010;
12900 return (PARSER_OK
);
12903 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12905 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12907 u32
*digest
= (u32
*) hash_buf
->digest
;
12909 salt_t
*salt
= hash_buf
->salt
;
12911 char *hashbuf_pos
= input_buf
;
12913 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12915 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12917 uint hash_len
= iterations_pos
- hashbuf_pos
;
12919 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12923 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12925 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12927 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12931 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12933 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12935 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12937 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12939 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12941 salt
->salt_len
= salt_len
;
12943 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12945 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
12946 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
12947 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
12948 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
12950 return (PARSER_OK
);
12953 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12955 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12957 u32
*digest
= (u32
*) hash_buf
->digest
;
12959 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12960 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12961 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12962 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12963 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12964 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12965 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12966 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12968 digest
[0] = byte_swap_32 (digest
[0]);
12969 digest
[1] = byte_swap_32 (digest
[1]);
12970 digest
[2] = byte_swap_32 (digest
[2]);
12971 digest
[3] = byte_swap_32 (digest
[3]);
12972 digest
[4] = byte_swap_32 (digest
[4]);
12973 digest
[5] = byte_swap_32 (digest
[5]);
12974 digest
[6] = byte_swap_32 (digest
[6]);
12975 digest
[7] = byte_swap_32 (digest
[7]);
12977 return (PARSER_OK
);
12980 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12982 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12984 u32
*digest
= (u32
*) hash_buf
->digest
;
12986 salt_t
*salt
= hash_buf
->salt
;
12988 char *salt_pos
= input_buf
+ 3;
12990 uint iterations_len
= 0;
12992 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12996 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12998 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12999 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13003 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13007 iterations_len
+= 8;
13011 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13014 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13016 char *hash_pos
= strchr (salt_pos
, '$');
13018 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13020 uint salt_len
= hash_pos
- salt_pos
;
13022 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13024 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13026 salt
->salt_len
= salt_len
;
13030 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13032 return (PARSER_OK
);
13035 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13037 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13039 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13041 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13043 u64
*digest
= (u64
*) hash_buf
->digest
;
13045 salt_t
*salt
= hash_buf
->salt
;
13047 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13049 char *iter_pos
= input_buf
+ 4;
13051 char *salt_pos
= strchr (iter_pos
, '$');
13053 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13057 char *hash_pos
= strchr (salt_pos
, '$');
13059 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13061 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13065 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13066 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13067 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13068 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13069 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13070 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13071 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13072 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13074 uint salt_len
= hash_pos
- salt_pos
- 1;
13076 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13078 salt
->salt_len
= salt_len
/ 2;
13080 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13081 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13082 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13083 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13084 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13085 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13086 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13087 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13089 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13090 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13091 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13092 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13093 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13094 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13095 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13096 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13097 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13098 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13100 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13102 salt
->salt_iter
= atoi (iter_pos
) - 1;
13104 return (PARSER_OK
);
13107 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13109 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13111 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13113 u32
*digest
= (u32
*) hash_buf
->digest
;
13115 salt_t
*salt
= hash_buf
->salt
;
13117 char *salt_pos
= input_buf
+ 14;
13119 char *hash_pos
= strchr (salt_pos
, '*');
13121 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13125 uint salt_len
= hash_pos
- salt_pos
- 1;
13127 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13129 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13131 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13133 salt
->salt_len
= salt_len
;
13135 u8 tmp_buf
[100] = { 0 };
13137 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13139 memcpy (digest
, tmp_buf
, 32);
13141 digest
[0] = byte_swap_32 (digest
[0]);
13142 digest
[1] = byte_swap_32 (digest
[1]);
13143 digest
[2] = byte_swap_32 (digest
[2]);
13144 digest
[3] = byte_swap_32 (digest
[3]);
13145 digest
[4] = byte_swap_32 (digest
[4]);
13146 digest
[5] = byte_swap_32 (digest
[5]);
13147 digest
[6] = byte_swap_32 (digest
[6]);
13148 digest
[7] = byte_swap_32 (digest
[7]);
13150 digest
[0] -= SHA256M_A
;
13151 digest
[1] -= SHA256M_B
;
13152 digest
[2] -= SHA256M_C
;
13153 digest
[3] -= SHA256M_D
;
13154 digest
[4] -= SHA256M_E
;
13155 digest
[5] -= SHA256M_F
;
13156 digest
[6] -= SHA256M_G
;
13157 digest
[7] -= SHA256M_H
;
13159 return (PARSER_OK
);
13162 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13164 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13166 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13168 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13170 u64
*digest
= (u64
*) hash_buf
->digest
;
13172 salt_t
*salt
= hash_buf
->salt
;
13174 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13176 char *iter_pos
= input_buf
+ 19;
13178 char *salt_pos
= strchr (iter_pos
, '.');
13180 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13184 char *hash_pos
= strchr (salt_pos
, '.');
13186 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13188 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13192 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13193 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13194 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13195 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13196 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13197 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13198 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13199 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13201 uint salt_len
= hash_pos
- salt_pos
- 1;
13205 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13209 for (i
= 0; i
< salt_len
; i
++)
13211 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13214 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13215 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13217 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13219 salt
->salt_len
= salt_len
;
13221 salt
->salt_iter
= atoi (iter_pos
) - 1;
13223 return (PARSER_OK
);
13226 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13228 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13230 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13232 u64
*digest
= (u64
*) hash_buf
->digest
;
13234 salt_t
*salt
= hash_buf
->salt
;
13236 u8 tmp_buf
[120] = { 0 };
13238 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13240 memcpy (digest
, tmp_buf
, 64);
13242 digest
[0] = byte_swap_64 (digest
[0]);
13243 digest
[1] = byte_swap_64 (digest
[1]);
13244 digest
[2] = byte_swap_64 (digest
[2]);
13245 digest
[3] = byte_swap_64 (digest
[3]);
13246 digest
[4] = byte_swap_64 (digest
[4]);
13247 digest
[5] = byte_swap_64 (digest
[5]);
13248 digest
[6] = byte_swap_64 (digest
[6]);
13249 digest
[7] = byte_swap_64 (digest
[7]);
13251 digest
[0] -= SHA512M_A
;
13252 digest
[1] -= SHA512M_B
;
13253 digest
[2] -= SHA512M_C
;
13254 digest
[3] -= SHA512M_D
;
13255 digest
[4] -= SHA512M_E
;
13256 digest
[5] -= SHA512M_F
;
13257 digest
[6] -= SHA512M_G
;
13258 digest
[7] -= SHA512M_H
;
13260 salt
->salt_len
= tmp_len
- 64;
13262 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13264 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13266 char *ptr
= (char *) salt
->salt_buf
;
13268 ptr
[salt
->salt_len
] = 0x80;
13271 return (PARSER_OK
);
13274 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13276 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13278 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13282 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13285 u32
*digest
= (u32
*) hash_buf
->digest
;
13287 salt_t
*salt
= hash_buf
->salt
;
13289 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13290 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13291 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13292 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13294 digest
[0] = byte_swap_32 (digest
[0]);
13295 digest
[1] = byte_swap_32 (digest
[1]);
13296 digest
[2] = byte_swap_32 (digest
[2]);
13297 digest
[3] = byte_swap_32 (digest
[3]);
13299 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13301 uint salt_len
= input_len
- 32 - 1;
13303 char *salt_buf
= input_buf
+ 32 + 1;
13305 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13307 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13309 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13311 salt
->salt_len
= salt_len
;
13313 return (PARSER_OK
);
13316 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13318 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13320 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13324 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13327 u32
*digest
= (u32
*) hash_buf
->digest
;
13329 salt_t
*salt
= hash_buf
->salt
;
13331 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13332 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13333 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13334 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13335 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13337 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13339 uint salt_len
= input_len
- 40 - 1;
13341 char *salt_buf
= input_buf
+ 40 + 1;
13343 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13345 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13347 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13349 salt
->salt_len
= salt_len
;
13351 return (PARSER_OK
);
13354 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13356 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13358 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13362 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13365 u32
*digest
= (u32
*) hash_buf
->digest
;
13367 salt_t
*salt
= hash_buf
->salt
;
13369 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13370 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13371 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13372 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13373 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13374 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13375 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13376 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13378 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13380 uint salt_len
= input_len
- 64 - 1;
13382 char *salt_buf
= input_buf
+ 64 + 1;
13384 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13386 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13388 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13390 salt
->salt_len
= salt_len
;
13392 return (PARSER_OK
);
13395 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13397 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13399 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13403 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13406 u64
*digest
= (u64
*) hash_buf
->digest
;
13408 salt_t
*salt
= hash_buf
->salt
;
13410 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13411 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13412 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13413 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13414 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13415 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13416 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13417 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13419 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13421 uint salt_len
= input_len
- 128 - 1;
13423 char *salt_buf
= input_buf
+ 128 + 1;
13425 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13427 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13429 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13431 salt
->salt_len
= salt_len
;
13433 return (PARSER_OK
);
13436 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13438 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13440 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13442 u32
*digest
= (u32
*) hash_buf
->digest
;
13444 salt_t
*salt
= hash_buf
->salt
;
13446 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13452 char *user_pos
= input_buf
+ 10 + 1;
13454 char *realm_pos
= strchr (user_pos
, '$');
13456 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13458 uint user_len
= realm_pos
- user_pos
;
13460 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13464 char *salt_pos
= strchr (realm_pos
, '$');
13466 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13468 uint realm_len
= salt_pos
- realm_pos
;
13470 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13474 char *data_pos
= strchr (salt_pos
, '$');
13476 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13478 uint salt_len
= data_pos
- salt_pos
;
13480 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13484 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13486 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13492 memcpy (krb5pa
->user
, user_pos
, user_len
);
13493 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13494 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13496 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13498 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13500 const char p0
= data_pos
[i
+ 0];
13501 const char p1
= data_pos
[i
+ 1];
13503 *timestamp_ptr
++ = hex_convert (p1
) << 0
13504 | hex_convert (p0
) << 4;
13507 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13509 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13511 const char p0
= data_pos
[i
+ 0];
13512 const char p1
= data_pos
[i
+ 1];
13514 *checksum_ptr
++ = hex_convert (p1
) << 0
13515 | hex_convert (p0
) << 4;
13519 * copy some data to generic buffers to make sorting happy
13522 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13523 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13524 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13525 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13526 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13527 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13528 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13529 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13530 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13532 salt
->salt_len
= 36;
13534 digest
[0] = krb5pa
->checksum
[0];
13535 digest
[1] = krb5pa
->checksum
[1];
13536 digest
[2] = krb5pa
->checksum
[2];
13537 digest
[3] = krb5pa
->checksum
[3];
13539 return (PARSER_OK
);
13542 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13544 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13546 u32
*digest
= (u32
*) hash_buf
->digest
;
13548 salt_t
*salt
= hash_buf
->salt
;
13554 char *salt_pos
= input_buf
;
13556 char *hash_pos
= strchr (salt_pos
, '$');
13558 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13560 uint salt_len
= hash_pos
- salt_pos
;
13562 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13566 uint hash_len
= input_len
- 1 - salt_len
;
13568 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13576 for (uint i
= 0; i
< salt_len
; i
++)
13578 if (salt_pos
[i
] == ' ') continue;
13583 // SAP user names cannot be longer than 12 characters
13584 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13586 // SAP user name cannot start with ! or ?
13587 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13593 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13595 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13597 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13599 salt
->salt_len
= salt_len
;
13601 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13602 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13606 digest
[0] = byte_swap_32 (digest
[0]);
13607 digest
[1] = byte_swap_32 (digest
[1]);
13609 return (PARSER_OK
);
13612 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13614 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13616 u32
*digest
= (u32
*) hash_buf
->digest
;
13618 salt_t
*salt
= hash_buf
->salt
;
13624 char *salt_pos
= input_buf
;
13626 char *hash_pos
= strchr (salt_pos
, '$');
13628 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13630 uint salt_len
= hash_pos
- salt_pos
;
13632 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13636 uint hash_len
= input_len
- 1 - salt_len
;
13638 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13646 for (uint i
= 0; i
< salt_len
; i
++)
13648 if (salt_pos
[i
] == ' ') continue;
13653 // SAP user names cannot be longer than 12 characters
13654 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13655 // so far nobody complained so we stay with this because it helps in optimization
13656 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13658 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13660 // SAP user name cannot start with ! or ?
13661 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13667 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13669 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13671 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13673 salt
->salt_len
= salt_len
;
13675 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13676 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13677 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13678 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13679 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13681 return (PARSER_OK
);
13684 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13686 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13688 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13690 u64
*digest
= (u64
*) hash_buf
->digest
;
13692 salt_t
*salt
= hash_buf
->salt
;
13694 char *iter_pos
= input_buf
+ 3;
13696 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13698 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13700 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13702 salt
->salt_iter
= salt_iter
;
13704 char *salt_pos
= iter_pos
+ 1;
13708 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13710 salt
->salt_len
= salt_len
;
13712 char *hash_pos
= salt_pos
+ salt_len
;
13714 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13718 char *tmp
= (char *) salt
->salt_buf_pc
;
13720 tmp
[0] = hash_pos
[42];
13724 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13725 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13726 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13727 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13733 return (PARSER_OK
);
13736 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13738 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13740 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13742 u32
*digest
= (u32
*) hash_buf
->digest
;
13744 salt_t
*salt
= hash_buf
->salt
;
13746 char *salt_buf
= input_buf
+ 6;
13748 uint salt_len
= 16;
13750 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13752 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13754 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13756 salt
->salt_len
= salt_len
;
13758 char *hash_pos
= input_buf
+ 6 + 16;
13760 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13761 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13762 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13763 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13764 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13765 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13766 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13767 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13769 return (PARSER_OK
);
13772 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13774 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13776 u32
*digest
= (u32
*) hash_buf
->digest
;
13778 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13779 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13783 return (PARSER_OK
);
13786 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13788 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13790 u32
*digest
= (u32
*) hash_buf
->digest
;
13792 salt_t
*salt
= hash_buf
->salt
;
13794 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13796 char *saltbuf_pos
= input_buf
;
13798 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13800 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13802 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13804 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13805 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13807 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13811 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13813 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13815 char *salt_ptr
= (char *) saltbuf_pos
;
13816 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13821 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13823 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13826 rakp_ptr
[j
] = 0x80;
13828 rakp
->salt_len
= j
;
13830 for (i
= 0; i
< 64; i
++)
13832 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13835 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13836 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13837 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13838 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13839 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13840 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13841 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13842 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13844 salt
->salt_len
= 32; // muss min. 32 haben
13846 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13847 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13848 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13849 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13850 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13852 return (PARSER_OK
);
13855 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13857 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13859 u32
*digest
= (u32
*) hash_buf
->digest
;
13861 salt_t
*salt
= hash_buf
->salt
;
13863 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13865 char *salt_pos
= input_buf
+ 1;
13867 memcpy (salt
->salt_buf
, salt_pos
, 8);
13869 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13870 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13872 salt
->salt_len
= 8;
13874 char *hash_pos
= salt_pos
+ 8;
13876 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13877 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13878 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13879 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13880 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13882 digest
[0] -= SHA1M_A
;
13883 digest
[1] -= SHA1M_B
;
13884 digest
[2] -= SHA1M_C
;
13885 digest
[3] -= SHA1M_D
;
13886 digest
[4] -= SHA1M_E
;
13888 return (PARSER_OK
);
13891 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13893 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13895 u32
*digest
= (u32
*) hash_buf
->digest
;
13897 salt_t
*salt
= hash_buf
->salt
;
13899 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13900 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13901 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13902 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13904 digest
[0] = byte_swap_32 (digest
[0]);
13905 digest
[1] = byte_swap_32 (digest
[1]);
13906 digest
[2] = byte_swap_32 (digest
[2]);
13907 digest
[3] = byte_swap_32 (digest
[3]);
13909 digest
[0] -= MD5M_A
;
13910 digest
[1] -= MD5M_B
;
13911 digest
[2] -= MD5M_C
;
13912 digest
[3] -= MD5M_D
;
13914 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13916 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13918 u32
*salt_buf
= salt
->salt_buf
;
13920 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
13921 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
13922 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
13923 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
13925 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13926 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13927 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13928 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13930 salt
->salt_len
= 16 + 1;
13932 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13934 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13936 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
13938 return (PARSER_OK
);
13941 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13943 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13945 u32
*digest
= (u32
*) hash_buf
->digest
;
13947 salt_t
*salt
= hash_buf
->salt
;
13949 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13955 char *hashbuf_pos
= input_buf
;
13957 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13959 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13961 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13963 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13967 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13969 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13971 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13973 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13977 char *databuf_pos
= strchr (iteration_pos
, ':');
13979 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13981 const uint iteration_len
= databuf_pos
- iteration_pos
;
13983 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13984 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13986 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13988 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13989 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13995 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13996 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13997 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13998 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13999 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14000 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14001 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14002 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14006 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14008 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14010 const char p0
= saltbuf_pos
[i
+ 0];
14011 const char p1
= saltbuf_pos
[i
+ 1];
14013 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14014 | hex_convert (p0
) << 4;
14017 salt
->salt_buf
[4] = 0x01000000;
14018 salt
->salt_buf
[5] = 0x80;
14020 salt
->salt_len
= saltbuf_len
/ 2;
14024 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14028 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14030 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14032 const char p0
= databuf_pos
[i
+ 0];
14033 const char p1
= databuf_pos
[i
+ 1];
14035 *databuf_ptr
++ = hex_convert (p1
) << 0
14036 | hex_convert (p0
) << 4;
14039 *databuf_ptr
++ = 0x80;
14041 for (uint i
= 0; i
< 512; i
++)
14043 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14046 cloudkey
->data_len
= databuf_len
/ 2;
14048 return (PARSER_OK
);
14051 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14053 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14055 u32
*digest
= (u32
*) hash_buf
->digest
;
14057 salt_t
*salt
= hash_buf
->salt
;
14063 char *hashbuf_pos
= input_buf
;
14065 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14067 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14069 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14071 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14075 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14077 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14079 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14081 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14083 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14087 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14089 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14091 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14093 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14095 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14099 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14101 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14102 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14104 // ok, the plan for this algorithm is the following:
14105 // we have 2 salts here, the domain-name and a random salt
14106 // while both are used in the initial transformation,
14107 // only the random salt is used in the following iterations
14108 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14109 // and one that includes only the real salt (stored into salt_buf[]).
14110 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14112 u8 tmp_buf
[100] = { 0 };
14114 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14116 memcpy (digest
, tmp_buf
, 20);
14118 digest
[0] = byte_swap_32 (digest
[0]);
14119 digest
[1] = byte_swap_32 (digest
[1]);
14120 digest
[2] = byte_swap_32 (digest
[2]);
14121 digest
[3] = byte_swap_32 (digest
[3]);
14122 digest
[4] = byte_swap_32 (digest
[4]);
14126 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14128 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14130 char *len_ptr
= NULL
;
14132 for (uint i
= 0; i
< domainbuf_len
; i
++)
14134 if (salt_buf_pc_ptr
[i
] == '.')
14136 len_ptr
= &salt_buf_pc_ptr
[i
];
14146 salt
->salt_buf_pc
[7] = domainbuf_len
;
14150 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14152 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14154 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14156 salt
->salt_len
= salt_len
;
14160 salt
->salt_iter
= atoi (iteration_pos
);
14162 return (PARSER_OK
);
14165 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14167 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14169 u32
*digest
= (u32
*) hash_buf
->digest
;
14171 salt_t
*salt
= hash_buf
->salt
;
14173 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14174 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14175 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14176 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14177 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14179 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14181 uint salt_len
= input_len
- 40 - 1;
14183 char *salt_buf
= input_buf
+ 40 + 1;
14185 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14187 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14189 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14191 salt
->salt_len
= salt_len
;
14193 return (PARSER_OK
);
14196 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14198 const u8 ascii_to_ebcdic
[] =
14200 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14201 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14202 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14203 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14204 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14205 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14206 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14207 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14208 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14209 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14210 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14211 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14212 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14213 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14214 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14215 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14218 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14220 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14222 u32
*digest
= (u32
*) hash_buf
->digest
;
14224 salt_t
*salt
= hash_buf
->salt
;
14226 char *salt_pos
= input_buf
+ 6 + 1;
14228 char *digest_pos
= strchr (salt_pos
, '*');
14230 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14232 uint salt_len
= digest_pos
- salt_pos
;
14234 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14236 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14238 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14242 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14243 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14245 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14247 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14249 salt
->salt_len
= salt_len
;
14251 for (uint i
= 0; i
< salt_len
; i
++)
14253 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14255 for (uint i
= salt_len
; i
< 8; i
++)
14257 salt_buf_pc_ptr
[i
] = 0x40;
14262 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14264 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14265 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14267 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14268 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14270 digest
[0] = byte_swap_32 (digest
[0]);
14271 digest
[1] = byte_swap_32 (digest
[1]);
14273 IP (digest
[0], digest
[1], tt
);
14275 digest
[0] = rotr32 (digest
[0], 29);
14276 digest
[1] = rotr32 (digest
[1], 29);
14280 return (PARSER_OK
);
14283 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14285 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14287 u32
*digest
= (u32
*) hash_buf
->digest
;
14289 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14290 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14291 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14292 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14294 digest
[0] = byte_swap_32 (digest
[0]);
14295 digest
[1] = byte_swap_32 (digest
[1]);
14296 digest
[2] = byte_swap_32 (digest
[2]);
14297 digest
[3] = byte_swap_32 (digest
[3]);
14299 return (PARSER_OK
);
14302 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14304 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14306 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14308 u32
*digest
= (u32
*) hash_buf
->digest
;
14310 salt_t
*salt
= hash_buf
->salt
;
14312 u8 tmp_buf
[120] = { 0 };
14314 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14316 tmp_buf
[3] += -4; // dont ask!
14318 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14320 salt
->salt_len
= 5;
14322 memcpy (digest
, tmp_buf
+ 5, 9);
14324 // yes, only 9 byte are needed to crack, but 10 to display
14326 salt
->salt_buf_pc
[7] = input_buf
[20];
14328 return (PARSER_OK
);
14331 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14333 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14335 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14337 u32
*digest
= (u32
*) hash_buf
->digest
;
14339 salt_t
*salt
= hash_buf
->salt
;
14341 u8 tmp_buf
[120] = { 0 };
14343 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14345 tmp_buf
[3] += -4; // dont ask!
14349 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14351 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)
14355 char tmp_iter_buf
[11] = { 0 };
14357 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14359 tmp_iter_buf
[10] = 0;
14361 salt
->salt_iter
= atoi (tmp_iter_buf
);
14363 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14365 return (PARSER_SALT_ITERATION
);
14368 salt
->salt_iter
--; // first round in init
14370 // 2 additional bytes for display only
14372 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14373 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14377 memcpy (digest
, tmp_buf
+ 28, 8);
14379 digest
[0] = byte_swap_32 (digest
[0]);
14380 digest
[1] = byte_swap_32 (digest
[1]);
14384 return (PARSER_OK
);
14387 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14389 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14391 u32
*digest
= (u32
*) hash_buf
->digest
;
14393 salt_t
*salt
= hash_buf
->salt
;
14395 char *salt_buf_pos
= input_buf
;
14397 char *hash_buf_pos
= salt_buf_pos
+ 6;
14399 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14400 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14401 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14402 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14403 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14404 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14405 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14406 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14408 digest
[0] -= SHA256M_A
;
14409 digest
[1] -= SHA256M_B
;
14410 digest
[2] -= SHA256M_C
;
14411 digest
[3] -= SHA256M_D
;
14412 digest
[4] -= SHA256M_E
;
14413 digest
[5] -= SHA256M_F
;
14414 digest
[6] -= SHA256M_G
;
14415 digest
[7] -= SHA256M_H
;
14417 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14419 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14421 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14423 salt
->salt_len
= salt_len
;
14425 return (PARSER_OK
);
14428 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14430 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14432 u32
*digest
= (u32
*) hash_buf
->digest
;
14434 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14436 salt_t
*salt
= hash_buf
->salt
;
14438 char *salt_buf
= input_buf
+ 6;
14440 char *digest_buf
= strchr (salt_buf
, '$');
14442 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14444 uint salt_len
= digest_buf
- salt_buf
;
14446 digest_buf
++; // skip the '$' symbol
14448 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14450 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14452 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14454 salt
->salt_len
= salt_len
;
14456 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14457 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14458 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14459 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14461 digest
[0] = byte_swap_32 (digest
[0]);
14462 digest
[1] = byte_swap_32 (digest
[1]);
14463 digest
[2] = byte_swap_32 (digest
[2]);
14464 digest
[3] = byte_swap_32 (digest
[3]);
14466 digest
[0] -= MD5M_A
;
14467 digest
[1] -= MD5M_B
;
14468 digest
[2] -= MD5M_C
;
14469 digest
[3] -= MD5M_D
;
14471 return (PARSER_OK
);
14474 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14476 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14478 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14480 u32
*digest
= (u32
*) hash_buf
->digest
;
14482 salt_t
*salt
= hash_buf
->salt
;
14484 char *salt_buf
= input_buf
+ 3;
14486 char *digest_buf
= strchr (salt_buf
, '$');
14488 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14490 uint salt_len
= digest_buf
- salt_buf
;
14492 digest_buf
++; // skip the '$' symbol
14494 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14496 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14498 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14500 salt_buf_ptr
[salt_len
] = 0x2d;
14502 salt
->salt_len
= salt_len
+ 1;
14504 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14505 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14506 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14507 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14509 digest
[0] = byte_swap_32 (digest
[0]);
14510 digest
[1] = byte_swap_32 (digest
[1]);
14511 digest
[2] = byte_swap_32 (digest
[2]);
14512 digest
[3] = byte_swap_32 (digest
[3]);
14514 digest
[0] -= MD5M_A
;
14515 digest
[1] -= MD5M_B
;
14516 digest
[2] -= MD5M_C
;
14517 digest
[3] -= MD5M_D
;
14519 return (PARSER_OK
);
14522 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14524 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14526 u32
*digest
= (u32
*) hash_buf
->digest
;
14528 u8 tmp_buf
[100] = { 0 };
14530 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14532 memcpy (digest
, tmp_buf
, 20);
14534 digest
[0] = byte_swap_32 (digest
[0]);
14535 digest
[1] = byte_swap_32 (digest
[1]);
14536 digest
[2] = byte_swap_32 (digest
[2]);
14537 digest
[3] = byte_swap_32 (digest
[3]);
14538 digest
[4] = byte_swap_32 (digest
[4]);
14540 digest
[0] -= SHA1M_A
;
14541 digest
[1] -= SHA1M_B
;
14542 digest
[2] -= SHA1M_C
;
14543 digest
[3] -= SHA1M_D
;
14544 digest
[4] -= SHA1M_E
;
14546 return (PARSER_OK
);
14549 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14551 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14553 u32
*digest
= (u32
*) hash_buf
->digest
;
14555 salt_t
*salt
= hash_buf
->salt
;
14557 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14558 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14559 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14560 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14562 digest
[0] = byte_swap_32 (digest
[0]);
14563 digest
[1] = byte_swap_32 (digest
[1]);
14564 digest
[2] = byte_swap_32 (digest
[2]);
14565 digest
[3] = byte_swap_32 (digest
[3]);
14567 digest
[0] -= MD5M_A
;
14568 digest
[1] -= MD5M_B
;
14569 digest
[2] -= MD5M_C
;
14570 digest
[3] -= MD5M_D
;
14572 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14574 uint salt_len
= input_len
- 32 - 1;
14576 char *salt_buf
= input_buf
+ 32 + 1;
14578 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14580 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14582 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14585 * add static "salt" part
14588 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14592 salt
->salt_len
= salt_len
;
14594 return (PARSER_OK
);
14597 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14599 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14601 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14603 u32
*digest
= (u32
*) hash_buf
->digest
;
14605 salt_t
*salt
= hash_buf
->salt
;
14607 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14613 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14615 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14617 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14619 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14621 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14625 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14627 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14629 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14631 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14635 char *keybuf_pos
= strchr (keylen_pos
, '$');
14637 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14639 uint keylen_len
= keybuf_pos
- keylen_pos
;
14641 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14645 char *databuf_pos
= strchr (keybuf_pos
, '$');
14647 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14649 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14651 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14655 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14657 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14663 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14664 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14665 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14666 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14668 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14669 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14670 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14671 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14673 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14674 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14675 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14676 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14678 salt
->salt_len
= 16;
14679 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14681 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14683 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14686 return (PARSER_OK
);
14689 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14691 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14693 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14695 u32
*digest
= (u32
*) hash_buf
->digest
;
14697 salt_t
*salt
= hash_buf
->salt
;
14703 // first is the N salt parameter
14705 char *N_pos
= input_buf
+ 6;
14707 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14711 salt
->scrypt_N
= atoi (N_pos
);
14715 char *r_pos
= strchr (N_pos
, ':');
14717 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14721 salt
->scrypt_r
= atoi (r_pos
);
14725 char *p_pos
= strchr (r_pos
, ':');
14727 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14731 salt
->scrypt_p
= atoi (p_pos
);
14735 char *saltbuf_pos
= strchr (p_pos
, ':');
14737 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14741 char *hash_pos
= strchr (saltbuf_pos
, ':');
14743 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14749 u8 tmp_buf
[33] = { 0 };
14751 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14753 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14755 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14757 salt
->salt_len
= tmp_len
;
14758 salt
->salt_iter
= 1;
14760 // digest - base64 decode
14762 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14764 tmp_len
= input_len
- (hash_pos
- input_buf
);
14766 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14768 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14770 memcpy (digest
, tmp_buf
, 32);
14772 return (PARSER_OK
);
14775 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14777 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14779 u32
*digest
= (u32
*) hash_buf
->digest
;
14781 salt_t
*salt
= hash_buf
->salt
;
14787 char decrypted
[76] = { 0 }; // iv + hash
14789 juniper_decrypt_hash (input_buf
, decrypted
);
14791 char *md5crypt_hash
= decrypted
+ 12;
14793 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14795 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14797 char *salt_pos
= md5crypt_hash
+ 3;
14799 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14801 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14803 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14807 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14809 return (PARSER_OK
);
14812 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14814 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14816 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14818 u32
*digest
= (u32
*) hash_buf
->digest
;
14820 salt_t
*salt
= hash_buf
->salt
;
14822 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14828 // first is *raw* salt
14830 char *salt_pos
= input_buf
+ 3;
14832 char *hash_pos
= strchr (salt_pos
, '$');
14834 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14836 uint salt_len
= hash_pos
- salt_pos
;
14838 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14842 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14844 memcpy (salt_buf_ptr
, salt_pos
, 14);
14846 salt_buf_ptr
[17] = 0x01;
14847 salt_buf_ptr
[18] = 0x80;
14849 // add some stuff to normal salt to make sorted happy
14851 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14852 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14853 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14854 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14856 salt
->salt_len
= salt_len
;
14857 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14859 // base64 decode hash
14861 u8 tmp_buf
[100] = { 0 };
14863 uint hash_len
= input_len
- 3 - salt_len
- 1;
14865 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14867 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14869 memcpy (digest
, tmp_buf
, 32);
14871 digest
[0] = byte_swap_32 (digest
[0]);
14872 digest
[1] = byte_swap_32 (digest
[1]);
14873 digest
[2] = byte_swap_32 (digest
[2]);
14874 digest
[3] = byte_swap_32 (digest
[3]);
14875 digest
[4] = byte_swap_32 (digest
[4]);
14876 digest
[5] = byte_swap_32 (digest
[5]);
14877 digest
[6] = byte_swap_32 (digest
[6]);
14878 digest
[7] = byte_swap_32 (digest
[7]);
14880 return (PARSER_OK
);
14883 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14885 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14887 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14889 u32
*digest
= (u32
*) hash_buf
->digest
;
14891 salt_t
*salt
= hash_buf
->salt
;
14897 // first is *raw* salt
14899 char *salt_pos
= input_buf
+ 3;
14901 char *hash_pos
= strchr (salt_pos
, '$');
14903 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14905 uint salt_len
= hash_pos
- salt_pos
;
14907 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14909 salt
->salt_len
= salt_len
;
14912 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14914 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14915 salt_buf_ptr
[salt_len
] = 0;
14917 // base64 decode hash
14919 u8 tmp_buf
[100] = { 0 };
14921 uint hash_len
= input_len
- 3 - salt_len
- 1;
14923 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14925 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14927 memcpy (digest
, tmp_buf
, 32);
14930 salt
->scrypt_N
= 16384;
14931 salt
->scrypt_r
= 1;
14932 salt
->scrypt_p
= 1;
14933 salt
->salt_iter
= 1;
14935 return (PARSER_OK
);
14938 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14940 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14942 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14944 u32
*digest
= (u32
*) hash_buf
->digest
;
14946 salt_t
*salt
= hash_buf
->salt
;
14948 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14954 char *version_pos
= input_buf
+ 8 + 1;
14956 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14958 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14960 u32 version_len
= verifierHashSize_pos
- version_pos
;
14962 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14964 verifierHashSize_pos
++;
14966 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14968 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14970 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14972 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14976 char *saltSize_pos
= strchr (keySize_pos
, '*');
14978 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14980 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14982 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14986 char *osalt_pos
= strchr (saltSize_pos
, '*');
14988 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14990 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14992 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14996 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14998 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15000 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15002 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15004 encryptedVerifier_pos
++;
15006 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15008 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15010 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15012 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15014 encryptedVerifierHash_pos
++;
15016 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;
15018 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15020 const uint version
= atoi (version_pos
);
15022 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15024 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15026 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15028 const uint keySize
= atoi (keySize_pos
);
15030 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15032 office2007
->keySize
= keySize
;
15034 const uint saltSize
= atoi (saltSize_pos
);
15036 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15042 salt
->salt_len
= 16;
15043 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15045 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15046 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15047 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15048 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15054 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15055 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15056 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15057 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15059 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15060 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15061 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15062 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15063 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15069 digest
[0] = office2007
->encryptedVerifierHash
[0];
15070 digest
[1] = office2007
->encryptedVerifierHash
[1];
15071 digest
[2] = office2007
->encryptedVerifierHash
[2];
15072 digest
[3] = office2007
->encryptedVerifierHash
[3];
15074 return (PARSER_OK
);
15077 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15079 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15081 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15083 u32
*digest
= (u32
*) hash_buf
->digest
;
15085 salt_t
*salt
= hash_buf
->salt
;
15087 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15093 char *version_pos
= input_buf
+ 8 + 1;
15095 char *spinCount_pos
= strchr (version_pos
, '*');
15097 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15099 u32 version_len
= spinCount_pos
- version_pos
;
15101 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15105 char *keySize_pos
= strchr (spinCount_pos
, '*');
15107 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15109 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15111 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15115 char *saltSize_pos
= strchr (keySize_pos
, '*');
15117 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15119 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15121 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15125 char *osalt_pos
= strchr (saltSize_pos
, '*');
15127 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15129 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15131 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15135 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15137 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15139 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15141 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15143 encryptedVerifier_pos
++;
15145 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15147 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15149 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15151 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15153 encryptedVerifierHash_pos
++;
15155 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;
15157 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15159 const uint version
= atoi (version_pos
);
15161 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15163 const uint spinCount
= atoi (spinCount_pos
);
15165 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15167 const uint keySize
= atoi (keySize_pos
);
15169 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15171 const uint saltSize
= atoi (saltSize_pos
);
15173 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15179 salt
->salt_len
= 16;
15180 salt
->salt_iter
= spinCount
;
15182 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15183 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15184 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15185 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15191 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15192 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15193 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15194 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15196 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15197 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15198 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15199 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15200 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15201 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15202 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15203 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15209 digest
[0] = office2010
->encryptedVerifierHash
[0];
15210 digest
[1] = office2010
->encryptedVerifierHash
[1];
15211 digest
[2] = office2010
->encryptedVerifierHash
[2];
15212 digest
[3] = office2010
->encryptedVerifierHash
[3];
15214 return (PARSER_OK
);
15217 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15219 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15221 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15223 u32
*digest
= (u32
*) hash_buf
->digest
;
15225 salt_t
*salt
= hash_buf
->salt
;
15227 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15233 char *version_pos
= input_buf
+ 8 + 1;
15235 char *spinCount_pos
= strchr (version_pos
, '*');
15237 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15239 u32 version_len
= spinCount_pos
- version_pos
;
15241 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15245 char *keySize_pos
= strchr (spinCount_pos
, '*');
15247 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15249 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15251 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15255 char *saltSize_pos
= strchr (keySize_pos
, '*');
15257 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15259 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15261 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15265 char *osalt_pos
= strchr (saltSize_pos
, '*');
15267 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15269 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15271 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15275 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15277 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15279 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15281 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15283 encryptedVerifier_pos
++;
15285 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15287 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15289 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15291 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15293 encryptedVerifierHash_pos
++;
15295 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;
15297 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15299 const uint version
= atoi (version_pos
);
15301 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15303 const uint spinCount
= atoi (spinCount_pos
);
15305 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15307 const uint keySize
= atoi (keySize_pos
);
15309 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15311 const uint saltSize
= atoi (saltSize_pos
);
15313 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15319 salt
->salt_len
= 16;
15320 salt
->salt_iter
= spinCount
;
15322 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15323 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15324 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15325 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15331 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15332 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15333 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15334 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15336 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15337 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15338 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15339 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15340 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15341 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15342 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15343 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15349 digest
[0] = office2013
->encryptedVerifierHash
[0];
15350 digest
[1] = office2013
->encryptedVerifierHash
[1];
15351 digest
[2] = office2013
->encryptedVerifierHash
[2];
15352 digest
[3] = office2013
->encryptedVerifierHash
[3];
15354 return (PARSER_OK
);
15357 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15359 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15361 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15363 u32
*digest
= (u32
*) hash_buf
->digest
;
15365 salt_t
*salt
= hash_buf
->salt
;
15367 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15373 char *version_pos
= input_buf
+ 11;
15375 char *osalt_pos
= strchr (version_pos
, '*');
15377 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15379 u32 version_len
= osalt_pos
- version_pos
;
15381 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15385 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15387 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15389 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15391 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15393 encryptedVerifier_pos
++;
15395 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15397 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15399 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15401 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15403 encryptedVerifierHash_pos
++;
15405 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15407 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15409 const uint version
= *version_pos
- 0x30;
15411 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15417 oldoffice01
->version
= version
;
15419 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15420 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15421 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15422 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15424 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15425 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15426 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15427 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15429 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15430 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15431 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15432 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15434 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15435 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15436 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15437 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15443 salt
->salt_len
= 16;
15445 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15446 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15447 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15448 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15450 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15451 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15452 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15453 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15455 // this is a workaround as office produces multiple documents with the same salt
15457 salt
->salt_len
+= 32;
15459 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15460 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15461 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15462 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15463 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15464 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15465 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15466 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15472 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15473 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15474 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15475 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15477 return (PARSER_OK
);
15480 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15482 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15485 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15487 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15489 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15491 u32
*digest
= (u32
*) hash_buf
->digest
;
15493 salt_t
*salt
= hash_buf
->salt
;
15495 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15501 char *version_pos
= input_buf
+ 11;
15503 char *osalt_pos
= strchr (version_pos
, '*');
15505 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15507 u32 version_len
= osalt_pos
- version_pos
;
15509 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15513 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15515 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15517 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15519 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15521 encryptedVerifier_pos
++;
15523 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15525 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15527 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15529 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15531 encryptedVerifierHash_pos
++;
15533 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15535 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15537 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15539 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15543 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15545 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15547 const uint version
= *version_pos
- 0x30;
15549 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15555 oldoffice01
->version
= version
;
15557 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15558 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15559 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15560 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15562 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15563 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15564 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15565 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15567 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15568 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15569 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15570 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15572 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15573 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15574 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15575 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15577 oldoffice01
->rc4key
[1] = 0;
15578 oldoffice01
->rc4key
[0] = 0;
15580 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15581 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15582 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15583 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15584 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15585 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15586 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15587 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15588 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15589 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15591 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15592 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15598 salt
->salt_len
= 16;
15600 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15601 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15602 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15603 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15605 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15606 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15607 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15608 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15610 // this is a workaround as office produces multiple documents with the same salt
15612 salt
->salt_len
+= 32;
15614 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15615 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15616 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15617 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15618 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15619 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15620 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15621 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15627 digest
[0] = oldoffice01
->rc4key
[0];
15628 digest
[1] = oldoffice01
->rc4key
[1];
15632 return (PARSER_OK
);
15635 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15637 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15639 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15641 u32
*digest
= (u32
*) hash_buf
->digest
;
15643 salt_t
*salt
= hash_buf
->salt
;
15645 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15651 char *version_pos
= input_buf
+ 11;
15653 char *osalt_pos
= strchr (version_pos
, '*');
15655 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15657 u32 version_len
= osalt_pos
- version_pos
;
15659 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15663 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15665 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15667 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15669 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15671 encryptedVerifier_pos
++;
15673 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15675 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15677 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15679 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15681 encryptedVerifierHash_pos
++;
15683 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15685 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15687 const uint version
= *version_pos
- 0x30;
15689 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15695 oldoffice34
->version
= version
;
15697 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15698 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15699 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15700 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15702 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15703 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15704 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15705 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15707 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15708 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15709 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15710 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15711 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15713 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15714 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15715 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15716 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15717 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15723 salt
->salt_len
= 16;
15725 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15726 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15727 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15728 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15730 // this is a workaround as office produces multiple documents with the same salt
15732 salt
->salt_len
+= 32;
15734 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15735 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15736 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15737 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15738 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15739 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15740 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15741 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15747 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15748 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15749 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15750 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15752 return (PARSER_OK
);
15755 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15757 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15759 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15762 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15764 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15766 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15768 u32
*digest
= (u32
*) hash_buf
->digest
;
15770 salt_t
*salt
= hash_buf
->salt
;
15772 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15778 char *version_pos
= input_buf
+ 11;
15780 char *osalt_pos
= strchr (version_pos
, '*');
15782 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15784 u32 version_len
= osalt_pos
- version_pos
;
15786 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15790 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15792 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15794 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15796 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15798 encryptedVerifier_pos
++;
15800 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15802 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15804 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15806 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15808 encryptedVerifierHash_pos
++;
15810 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15812 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15814 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15816 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15820 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15822 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15824 const uint version
= *version_pos
- 0x30;
15826 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15832 oldoffice34
->version
= version
;
15834 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15835 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15836 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15837 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15839 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15840 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15841 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15842 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15844 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15845 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15846 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15847 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15848 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15850 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15851 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15852 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15853 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15854 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15856 oldoffice34
->rc4key
[1] = 0;
15857 oldoffice34
->rc4key
[0] = 0;
15859 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15860 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15861 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15862 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15863 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15864 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15865 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15866 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15867 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15868 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15870 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15871 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15877 salt
->salt_len
= 16;
15879 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15880 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15881 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15882 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15884 // this is a workaround as office produces multiple documents with the same salt
15886 salt
->salt_len
+= 32;
15888 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15889 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15890 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15891 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15892 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15893 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15894 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15895 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15901 digest
[0] = oldoffice34
->rc4key
[0];
15902 digest
[1] = oldoffice34
->rc4key
[1];
15906 return (PARSER_OK
);
15909 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15911 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15913 u32
*digest
= (u32
*) hash_buf
->digest
;
15915 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15916 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15917 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15918 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15920 digest
[0] = byte_swap_32 (digest
[0]);
15921 digest
[1] = byte_swap_32 (digest
[1]);
15922 digest
[2] = byte_swap_32 (digest
[2]);
15923 digest
[3] = byte_swap_32 (digest
[3]);
15925 return (PARSER_OK
);
15928 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15930 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15932 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15934 u32
*digest
= (u32
*) hash_buf
->digest
;
15936 salt_t
*salt
= hash_buf
->salt
;
15938 char *signature_pos
= input_buf
;
15940 char *salt_pos
= strchr (signature_pos
, '$');
15942 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15944 u32 signature_len
= salt_pos
- signature_pos
;
15946 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15950 char *hash_pos
= strchr (salt_pos
, '$');
15952 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15954 u32 salt_len
= hash_pos
- salt_pos
;
15956 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15960 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15962 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15964 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
15965 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
15966 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
15967 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
15968 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
15970 digest
[0] -= SHA1M_A
;
15971 digest
[1] -= SHA1M_B
;
15972 digest
[2] -= SHA1M_C
;
15973 digest
[3] -= SHA1M_D
;
15974 digest
[4] -= SHA1M_E
;
15976 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15978 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15980 salt
->salt_len
= salt_len
;
15982 return (PARSER_OK
);
15985 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15987 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15989 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15991 u32
*digest
= (u32
*) hash_buf
->digest
;
15993 salt_t
*salt
= hash_buf
->salt
;
15995 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16001 char *iter_pos
= input_buf
+ 14;
16003 const int iter
= atoi (iter_pos
);
16005 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16007 salt
->salt_iter
= iter
- 1;
16009 char *salt_pos
= strchr (iter_pos
, '$');
16011 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16015 char *hash_pos
= strchr (salt_pos
, '$');
16017 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16019 const uint salt_len
= hash_pos
- salt_pos
;
16023 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16025 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16027 salt
->salt_len
= salt_len
;
16029 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16030 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16032 // add some stuff to normal salt to make sorted happy
16034 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16035 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16036 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16037 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16038 salt
->salt_buf
[4] = salt
->salt_iter
;
16040 // base64 decode hash
16042 u8 tmp_buf
[100] = { 0 };
16044 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16046 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16048 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16050 memcpy (digest
, tmp_buf
, 32);
16052 digest
[0] = byte_swap_32 (digest
[0]);
16053 digest
[1] = byte_swap_32 (digest
[1]);
16054 digest
[2] = byte_swap_32 (digest
[2]);
16055 digest
[3] = byte_swap_32 (digest
[3]);
16056 digest
[4] = byte_swap_32 (digest
[4]);
16057 digest
[5] = byte_swap_32 (digest
[5]);
16058 digest
[6] = byte_swap_32 (digest
[6]);
16059 digest
[7] = byte_swap_32 (digest
[7]);
16061 return (PARSER_OK
);
16064 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16066 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16068 u32
*digest
= (u32
*) hash_buf
->digest
;
16070 salt_t
*salt
= hash_buf
->salt
;
16072 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16073 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16077 digest
[0] = byte_swap_32 (digest
[0]);
16078 digest
[1] = byte_swap_32 (digest
[1]);
16080 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16081 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16082 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16084 char iter_c
= input_buf
[17];
16085 char iter_d
= input_buf
[19];
16087 // atm only defaults, let's see if there's more request
16088 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16089 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16091 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16093 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16094 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16095 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16096 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16098 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16099 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16100 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16101 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16103 salt
->salt_len
= 16;
16105 return (PARSER_OK
);
16108 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16110 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16112 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16114 u32
*digest
= (u32
*) hash_buf
->digest
;
16116 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16118 salt_t
*salt
= hash_buf
->salt
;
16120 char *salt_pos
= input_buf
+ 10;
16122 char *hash_pos
= strchr (salt_pos
, '$');
16124 uint salt_len
= hash_pos
- salt_pos
;
16126 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16130 uint hash_len
= input_len
- 10 - salt_len
- 1;
16132 // base64 decode salt
16134 u8 tmp_buf
[100] = { 0 };
16136 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16138 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16140 tmp_buf
[salt_len
] = 0x80;
16142 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16144 salt
->salt_len
= salt_len
;
16146 // base64 decode salt
16148 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16150 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16152 uint user_len
= hash_len
- 32;
16154 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16156 user_len
--; // skip the trailing space
16158 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16159 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16160 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16161 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16163 digest
[0] = byte_swap_32 (digest
[0]);
16164 digest
[1] = byte_swap_32 (digest
[1]);
16165 digest
[2] = byte_swap_32 (digest
[2]);
16166 digest
[3] = byte_swap_32 (digest
[3]);
16168 // store username for host only (output hash if cracked)
16170 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16171 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16173 return (PARSER_OK
);
16176 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16178 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16180 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16182 u32
*digest
= (u32
*) hash_buf
->digest
;
16184 salt_t
*salt
= hash_buf
->salt
;
16186 char *iter_pos
= input_buf
+ 10;
16188 u32 iter
= atoi (iter_pos
);
16192 return (PARSER_SALT_ITERATION
);
16195 iter
--; // first iteration is special
16197 salt
->salt_iter
= iter
;
16199 char *base64_pos
= strchr (iter_pos
, '}');
16201 if (base64_pos
== NULL
)
16203 return (PARSER_SIGNATURE_UNMATCHED
);
16208 // base64 decode salt
16210 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16212 u8 tmp_buf
[100] = { 0 };
16214 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16216 if (decoded_len
< 24)
16218 return (PARSER_SALT_LENGTH
);
16223 uint salt_len
= decoded_len
- 20;
16225 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16226 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16228 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16230 salt
->salt_len
= salt_len
;
16234 u32
*digest_ptr
= (u32
*) tmp_buf
;
16236 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16237 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16238 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16239 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16240 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16242 return (PARSER_OK
);
16245 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16247 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16249 u32
*digest
= (u32
*) hash_buf
->digest
;
16251 salt_t
*salt
= hash_buf
->salt
;
16253 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16254 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16255 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16256 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16257 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16259 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16261 uint salt_len
= input_len
- 40 - 1;
16263 char *salt_buf
= input_buf
+ 40 + 1;
16265 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16267 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16269 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16271 salt
->salt_len
= salt_len
;
16273 return (PARSER_OK
);
16276 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16278 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16280 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16282 u32
*digest
= (u32
*) hash_buf
->digest
;
16284 salt_t
*salt
= hash_buf
->salt
;
16286 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16292 char *V_pos
= input_buf
+ 5;
16294 char *R_pos
= strchr (V_pos
, '*');
16296 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16298 u32 V_len
= R_pos
- V_pos
;
16302 char *bits_pos
= strchr (R_pos
, '*');
16304 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16306 u32 R_len
= bits_pos
- R_pos
;
16310 char *P_pos
= strchr (bits_pos
, '*');
16312 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16314 u32 bits_len
= P_pos
- bits_pos
;
16318 char *enc_md_pos
= strchr (P_pos
, '*');
16320 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16322 u32 P_len
= enc_md_pos
- P_pos
;
16326 char *id_len_pos
= strchr (enc_md_pos
, '*');
16328 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16330 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16334 char *id_buf_pos
= strchr (id_len_pos
, '*');
16336 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16338 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16342 char *u_len_pos
= strchr (id_buf_pos
, '*');
16344 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16346 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16348 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16352 char *u_buf_pos
= strchr (u_len_pos
, '*');
16354 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16356 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16360 char *o_len_pos
= strchr (u_buf_pos
, '*');
16362 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16364 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16366 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16370 char *o_buf_pos
= strchr (o_len_pos
, '*');
16372 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16374 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16378 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;
16380 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16384 const int V
= atoi (V_pos
);
16385 const int R
= atoi (R_pos
);
16386 const int P
= atoi (P_pos
);
16388 if (V
!= 1) return (PARSER_SALT_VALUE
);
16389 if (R
!= 2) return (PARSER_SALT_VALUE
);
16391 const int enc_md
= atoi (enc_md_pos
);
16393 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16395 const int id_len
= atoi (id_len_pos
);
16396 const int u_len
= atoi (u_len_pos
);
16397 const int o_len
= atoi (o_len_pos
);
16399 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16400 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16401 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16403 const int bits
= atoi (bits_pos
);
16405 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16407 // copy data to esalt
16413 pdf
->enc_md
= enc_md
;
16415 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16416 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16417 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16418 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16419 pdf
->id_len
= id_len
;
16421 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16422 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16423 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16424 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16425 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16426 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16427 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16428 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16429 pdf
->u_len
= u_len
;
16431 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16432 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16433 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16434 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16435 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16436 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16437 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16438 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16439 pdf
->o_len
= o_len
;
16441 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16442 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16443 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16444 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16446 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16447 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16448 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16449 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16450 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16451 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16452 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16453 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16455 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16456 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16457 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16458 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16459 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16460 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16461 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16462 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16464 // we use ID for salt, maybe needs to change, we will see...
16466 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16467 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16468 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16469 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16470 salt
->salt_len
= pdf
->id_len
;
16472 digest
[0] = pdf
->u_buf
[0];
16473 digest
[1] = pdf
->u_buf
[1];
16474 digest
[2] = pdf
->u_buf
[2];
16475 digest
[3] = pdf
->u_buf
[3];
16477 return (PARSER_OK
);
16480 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16482 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16485 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16487 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16489 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16491 u32
*digest
= (u32
*) hash_buf
->digest
;
16493 salt_t
*salt
= hash_buf
->salt
;
16495 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16501 char *V_pos
= input_buf
+ 5;
16503 char *R_pos
= strchr (V_pos
, '*');
16505 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16507 u32 V_len
= R_pos
- V_pos
;
16511 char *bits_pos
= strchr (R_pos
, '*');
16513 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16515 u32 R_len
= bits_pos
- R_pos
;
16519 char *P_pos
= strchr (bits_pos
, '*');
16521 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16523 u32 bits_len
= P_pos
- bits_pos
;
16527 char *enc_md_pos
= strchr (P_pos
, '*');
16529 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16531 u32 P_len
= enc_md_pos
- P_pos
;
16535 char *id_len_pos
= strchr (enc_md_pos
, '*');
16537 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16539 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16543 char *id_buf_pos
= strchr (id_len_pos
, '*');
16545 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16547 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16551 char *u_len_pos
= strchr (id_buf_pos
, '*');
16553 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16555 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16557 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16561 char *u_buf_pos
= strchr (u_len_pos
, '*');
16563 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16565 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16569 char *o_len_pos
= strchr (u_buf_pos
, '*');
16571 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16573 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16575 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16579 char *o_buf_pos
= strchr (o_len_pos
, '*');
16581 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16583 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16587 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16589 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16591 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16593 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16597 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;
16599 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16603 const int V
= atoi (V_pos
);
16604 const int R
= atoi (R_pos
);
16605 const int P
= atoi (P_pos
);
16607 if (V
!= 1) return (PARSER_SALT_VALUE
);
16608 if (R
!= 2) return (PARSER_SALT_VALUE
);
16610 const int enc_md
= atoi (enc_md_pos
);
16612 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16614 const int id_len
= atoi (id_len_pos
);
16615 const int u_len
= atoi (u_len_pos
);
16616 const int o_len
= atoi (o_len_pos
);
16618 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16619 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16620 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16622 const int bits
= atoi (bits_pos
);
16624 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16626 // copy data to esalt
16632 pdf
->enc_md
= enc_md
;
16634 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16635 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16636 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16637 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16638 pdf
->id_len
= id_len
;
16640 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16641 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16642 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16643 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16644 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16645 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16646 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16647 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16648 pdf
->u_len
= u_len
;
16650 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16651 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16652 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16653 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16654 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16655 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16656 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16657 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16658 pdf
->o_len
= o_len
;
16660 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16661 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16662 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16663 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16665 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16666 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16667 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16668 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16669 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16670 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16671 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16672 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16674 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16675 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16676 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16677 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16678 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16679 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16680 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16681 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16683 pdf
->rc4key
[1] = 0;
16684 pdf
->rc4key
[0] = 0;
16686 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16687 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16688 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16689 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16690 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16691 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16692 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16693 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16694 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16695 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16697 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16698 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16700 // we use ID for salt, maybe needs to change, we will see...
16702 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16703 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16704 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16705 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16706 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16707 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16708 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16709 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16710 salt
->salt_len
= pdf
->id_len
+ 16;
16712 digest
[0] = pdf
->rc4key
[0];
16713 digest
[1] = pdf
->rc4key
[1];
16717 return (PARSER_OK
);
16720 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16722 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16724 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16726 u32
*digest
= (u32
*) hash_buf
->digest
;
16728 salt_t
*salt
= hash_buf
->salt
;
16730 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16736 char *V_pos
= input_buf
+ 5;
16738 char *R_pos
= strchr (V_pos
, '*');
16740 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16742 u32 V_len
= R_pos
- V_pos
;
16746 char *bits_pos
= strchr (R_pos
, '*');
16748 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16750 u32 R_len
= bits_pos
- R_pos
;
16754 char *P_pos
= strchr (bits_pos
, '*');
16756 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16758 u32 bits_len
= P_pos
- bits_pos
;
16762 char *enc_md_pos
= strchr (P_pos
, '*');
16764 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16766 u32 P_len
= enc_md_pos
- P_pos
;
16770 char *id_len_pos
= strchr (enc_md_pos
, '*');
16772 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16774 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16778 char *id_buf_pos
= strchr (id_len_pos
, '*');
16780 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16782 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16786 char *u_len_pos
= strchr (id_buf_pos
, '*');
16788 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16790 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16792 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16796 char *u_buf_pos
= strchr (u_len_pos
, '*');
16798 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16800 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16804 char *o_len_pos
= strchr (u_buf_pos
, '*');
16806 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16808 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16810 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16814 char *o_buf_pos
= strchr (o_len_pos
, '*');
16816 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16818 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16822 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;
16824 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16828 const int V
= atoi (V_pos
);
16829 const int R
= atoi (R_pos
);
16830 const int P
= atoi (P_pos
);
16834 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16835 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16837 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16839 const int id_len
= atoi (id_len_pos
);
16840 const int u_len
= atoi (u_len_pos
);
16841 const int o_len
= atoi (o_len_pos
);
16843 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16845 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16846 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16848 const int bits
= atoi (bits_pos
);
16850 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16856 enc_md
= atoi (enc_md_pos
);
16859 // copy data to esalt
16865 pdf
->enc_md
= enc_md
;
16867 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16868 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16869 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16870 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16874 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
16875 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
16876 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
16877 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
16880 pdf
->id_len
= id_len
;
16882 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16883 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16884 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16885 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16886 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16887 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16888 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16889 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16890 pdf
->u_len
= u_len
;
16892 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16893 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16894 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16895 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16896 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16897 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16898 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16899 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16900 pdf
->o_len
= o_len
;
16902 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16903 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16904 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16905 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16909 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16910 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16911 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16912 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16915 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16916 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16917 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16918 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16919 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16920 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16921 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16922 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16924 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16925 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16926 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16927 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16928 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16929 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16930 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16931 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16933 // precompute rc4 data for later use
16949 uint salt_pc_block
[32] = { 0 };
16951 char *salt_pc_ptr
= (char *) salt_pc_block
;
16953 memcpy (salt_pc_ptr
, padding
, 32);
16954 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16956 uint salt_pc_digest
[4] = { 0 };
16958 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16960 pdf
->rc4data
[0] = salt_pc_digest
[0];
16961 pdf
->rc4data
[1] = salt_pc_digest
[1];
16963 // we use ID for salt, maybe needs to change, we will see...
16965 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16966 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16967 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16968 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16969 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16970 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16971 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16972 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16973 salt
->salt_len
= pdf
->id_len
+ 16;
16975 salt
->salt_iter
= ROUNDS_PDF14
;
16977 digest
[0] = pdf
->u_buf
[0];
16978 digest
[1] = pdf
->u_buf
[1];
16982 return (PARSER_OK
);
16985 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16987 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16989 if (ret
!= PARSER_OK
)
16994 u32
*digest
= (u32
*) hash_buf
->digest
;
16996 salt_t
*salt
= hash_buf
->salt
;
16998 digest
[0] -= SHA256M_A
;
16999 digest
[1] -= SHA256M_B
;
17000 digest
[2] -= SHA256M_C
;
17001 digest
[3] -= SHA256M_D
;
17002 digest
[4] -= SHA256M_E
;
17003 digest
[5] -= SHA256M_F
;
17004 digest
[6] -= SHA256M_G
;
17005 digest
[7] -= SHA256M_H
;
17007 salt
->salt_buf
[2] = 0x80;
17009 return (PARSER_OK
);
17012 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17014 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17016 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17018 u32
*digest
= (u32
*) hash_buf
->digest
;
17020 salt_t
*salt
= hash_buf
->salt
;
17022 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17028 char *V_pos
= input_buf
+ 5;
17030 char *R_pos
= strchr (V_pos
, '*');
17032 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17034 u32 V_len
= R_pos
- V_pos
;
17038 char *bits_pos
= strchr (R_pos
, '*');
17040 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17042 u32 R_len
= bits_pos
- R_pos
;
17046 char *P_pos
= strchr (bits_pos
, '*');
17048 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17050 u32 bits_len
= P_pos
- bits_pos
;
17054 char *enc_md_pos
= strchr (P_pos
, '*');
17056 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17058 u32 P_len
= enc_md_pos
- P_pos
;
17062 char *id_len_pos
= strchr (enc_md_pos
, '*');
17064 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17066 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17070 char *id_buf_pos
= strchr (id_len_pos
, '*');
17072 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17074 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17078 char *u_len_pos
= strchr (id_buf_pos
, '*');
17080 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17082 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17086 char *u_buf_pos
= strchr (u_len_pos
, '*');
17088 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17090 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17094 char *o_len_pos
= strchr (u_buf_pos
, '*');
17096 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17098 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17102 char *o_buf_pos
= strchr (o_len_pos
, '*');
17104 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17106 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17110 char *last
= strchr (o_buf_pos
, '*');
17112 if (last
== NULL
) last
= input_buf
+ input_len
;
17114 u32 o_buf_len
= last
- o_buf_pos
;
17118 const int V
= atoi (V_pos
);
17119 const int R
= atoi (R_pos
);
17123 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17124 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17126 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17128 const int bits
= atoi (bits_pos
);
17130 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17132 int enc_md
= atoi (enc_md_pos
);
17134 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17136 const uint id_len
= atoi (id_len_pos
);
17137 const uint u_len
= atoi (u_len_pos
);
17138 const uint o_len
= atoi (o_len_pos
);
17140 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17141 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17142 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17143 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17144 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17145 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17146 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17147 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17149 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17150 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17151 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17153 // copy data to esalt
17155 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17157 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17159 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17162 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17163 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17165 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17166 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17168 salt
->salt_len
= 8;
17169 salt
->salt_iter
= ROUNDS_PDF17L8
;
17171 digest
[0] = pdf
->u_buf
[0];
17172 digest
[1] = pdf
->u_buf
[1];
17173 digest
[2] = pdf
->u_buf
[2];
17174 digest
[3] = pdf
->u_buf
[3];
17175 digest
[4] = pdf
->u_buf
[4];
17176 digest
[5] = pdf
->u_buf
[5];
17177 digest
[6] = pdf
->u_buf
[6];
17178 digest
[7] = pdf
->u_buf
[7];
17180 return (PARSER_OK
);
17183 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17185 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17187 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17189 u32
*digest
= (u32
*) hash_buf
->digest
;
17191 salt_t
*salt
= hash_buf
->salt
;
17193 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17201 char *iter_pos
= input_buf
+ 7;
17203 u32 iter
= atoi (iter_pos
);
17205 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17206 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17208 // first is *raw* salt
17210 char *salt_pos
= strchr (iter_pos
, ':');
17212 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17216 char *hash_pos
= strchr (salt_pos
, ':');
17218 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17220 u32 salt_len
= hash_pos
- salt_pos
;
17222 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17226 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17228 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17232 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17234 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17236 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17238 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17239 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17241 salt
->salt_len
= salt_len
;
17242 salt
->salt_iter
= iter
- 1;
17246 u8 tmp_buf
[100] = { 0 };
17248 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17250 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17252 memcpy (digest
, tmp_buf
, 16);
17254 digest
[0] = byte_swap_32 (digest
[0]);
17255 digest
[1] = byte_swap_32 (digest
[1]);
17256 digest
[2] = byte_swap_32 (digest
[2]);
17257 digest
[3] = byte_swap_32 (digest
[3]);
17259 // add some stuff to normal salt to make sorted happy
17261 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17262 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17263 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17264 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17265 salt
->salt_buf
[4] = salt
->salt_iter
;
17267 return (PARSER_OK
);
17270 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17272 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17274 u32
*digest
= (u32
*) hash_buf
->digest
;
17276 salt_t
*salt
= hash_buf
->salt
;
17278 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17279 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17280 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17281 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17283 digest
[0] = byte_swap_32 (digest
[0]);
17284 digest
[1] = byte_swap_32 (digest
[1]);
17285 digest
[2] = byte_swap_32 (digest
[2]);
17286 digest
[3] = byte_swap_32 (digest
[3]);
17288 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17290 uint salt_len
= input_len
- 32 - 1;
17292 char *salt_buf
= input_buf
+ 32 + 1;
17294 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17296 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17298 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17300 salt
->salt_len
= salt_len
;
17302 return (PARSER_OK
);
17305 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17307 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17309 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17311 u32
*digest
= (u32
*) hash_buf
->digest
;
17313 salt_t
*salt
= hash_buf
->salt
;
17315 char *user_pos
= input_buf
+ 10;
17317 char *salt_pos
= strchr (user_pos
, '*');
17319 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17323 char *hash_pos
= strchr (salt_pos
, '*');
17327 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17329 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17331 uint user_len
= salt_pos
- user_pos
- 1;
17333 uint salt_len
= hash_pos
- salt_pos
- 1;
17335 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17341 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17342 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17343 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17344 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17346 digest
[0] = byte_swap_32 (digest
[0]);
17347 digest
[1] = byte_swap_32 (digest
[1]);
17348 digest
[2] = byte_swap_32 (digest
[2]);
17349 digest
[3] = byte_swap_32 (digest
[3]);
17351 digest
[0] -= MD5M_A
;
17352 digest
[1] -= MD5M_B
;
17353 digest
[2] -= MD5M_C
;
17354 digest
[3] -= MD5M_D
;
17360 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17362 // first 4 bytes are the "challenge"
17364 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17365 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17366 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17367 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17369 // append the user name
17371 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17373 salt
->salt_len
= 4 + user_len
;
17375 return (PARSER_OK
);
17378 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17380 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17382 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17384 u32
*digest
= (u32
*) hash_buf
->digest
;
17386 salt_t
*salt
= hash_buf
->salt
;
17388 char *salt_pos
= input_buf
+ 9;
17390 char *hash_pos
= strchr (salt_pos
, '*');
17392 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17396 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17398 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17400 uint salt_len
= hash_pos
- salt_pos
- 1;
17402 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17408 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17409 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17410 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17411 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17412 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17418 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17420 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17422 salt
->salt_len
= salt_len
;
17424 return (PARSER_OK
);
17427 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17429 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17431 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17433 u32
*digest
= (u32
*) hash_buf
->digest
;
17435 salt_t
*salt
= hash_buf
->salt
;
17437 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17443 char *cry_master_len_pos
= input_buf
+ 9;
17445 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17447 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17449 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17451 cry_master_buf_pos
++;
17453 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17455 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17457 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17459 cry_salt_len_pos
++;
17461 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17463 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17465 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17467 cry_salt_buf_pos
++;
17469 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17471 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17473 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17477 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17479 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17481 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17485 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17487 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17489 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17493 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17495 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17497 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17499 public_key_len_pos
++;
17501 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17503 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17505 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17507 public_key_buf_pos
++;
17509 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;
17511 const uint cry_master_len
= atoi (cry_master_len_pos
);
17512 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17513 const uint ckey_len
= atoi (ckey_len_pos
);
17514 const uint public_key_len
= atoi (public_key_len_pos
);
17516 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17517 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17518 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17519 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17521 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17523 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17525 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17528 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17530 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17532 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17535 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17537 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17539 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17542 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17543 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17544 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17547 * store digest (should be unique enought, hopefully)
17550 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17551 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17552 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17553 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17559 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17561 const uint cry_rounds
= atoi (cry_rounds_pos
);
17563 salt
->salt_iter
= cry_rounds
- 1;
17565 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17567 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17569 salt
->salt_len
= salt_len
;
17571 return (PARSER_OK
);
17574 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17576 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17578 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17580 u32
*digest
= (u32
*) hash_buf
->digest
;
17582 salt_t
*salt
= hash_buf
->salt
;
17584 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17586 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17588 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17590 memcpy (temp_input_buf
, input_buf
, input_len
);
17594 char *URI_server_pos
= temp_input_buf
+ 6;
17596 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17598 if (URI_client_pos
== NULL
)
17600 myfree (temp_input_buf
);
17602 return (PARSER_SEPARATOR_UNMATCHED
);
17605 URI_client_pos
[0] = 0;
17608 uint URI_server_len
= strlen (URI_server_pos
);
17610 if (URI_server_len
> 512)
17612 myfree (temp_input_buf
);
17614 return (PARSER_SALT_LENGTH
);
17619 char *user_pos
= strchr (URI_client_pos
, '*');
17621 if (user_pos
== NULL
)
17623 myfree (temp_input_buf
);
17625 return (PARSER_SEPARATOR_UNMATCHED
);
17631 uint URI_client_len
= strlen (URI_client_pos
);
17633 if (URI_client_len
> 512)
17635 myfree (temp_input_buf
);
17637 return (PARSER_SALT_LENGTH
);
17642 char *realm_pos
= strchr (user_pos
, '*');
17644 if (realm_pos
== NULL
)
17646 myfree (temp_input_buf
);
17648 return (PARSER_SEPARATOR_UNMATCHED
);
17654 uint user_len
= strlen (user_pos
);
17656 if (user_len
> 116)
17658 myfree (temp_input_buf
);
17660 return (PARSER_SALT_LENGTH
);
17665 char *method_pos
= strchr (realm_pos
, '*');
17667 if (method_pos
== NULL
)
17669 myfree (temp_input_buf
);
17671 return (PARSER_SEPARATOR_UNMATCHED
);
17677 uint realm_len
= strlen (realm_pos
);
17679 if (realm_len
> 116)
17681 myfree (temp_input_buf
);
17683 return (PARSER_SALT_LENGTH
);
17688 char *URI_prefix_pos
= strchr (method_pos
, '*');
17690 if (URI_prefix_pos
== NULL
)
17692 myfree (temp_input_buf
);
17694 return (PARSER_SEPARATOR_UNMATCHED
);
17697 URI_prefix_pos
[0] = 0;
17700 uint method_len
= strlen (method_pos
);
17702 if (method_len
> 246)
17704 myfree (temp_input_buf
);
17706 return (PARSER_SALT_LENGTH
);
17711 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17713 if (URI_resource_pos
== NULL
)
17715 myfree (temp_input_buf
);
17717 return (PARSER_SEPARATOR_UNMATCHED
);
17720 URI_resource_pos
[0] = 0;
17721 URI_resource_pos
++;
17723 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17725 if (URI_prefix_len
> 245)
17727 myfree (temp_input_buf
);
17729 return (PARSER_SALT_LENGTH
);
17734 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17736 if (URI_suffix_pos
== NULL
)
17738 myfree (temp_input_buf
);
17740 return (PARSER_SEPARATOR_UNMATCHED
);
17743 URI_suffix_pos
[0] = 0;
17746 uint URI_resource_len
= strlen (URI_resource_pos
);
17748 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17750 myfree (temp_input_buf
);
17752 return (PARSER_SALT_LENGTH
);
17757 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17759 if (nonce_pos
== NULL
)
17761 myfree (temp_input_buf
);
17763 return (PARSER_SEPARATOR_UNMATCHED
);
17769 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17771 if (URI_suffix_len
> 245)
17773 myfree (temp_input_buf
);
17775 return (PARSER_SALT_LENGTH
);
17780 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17782 if (nonce_client_pos
== NULL
)
17784 myfree (temp_input_buf
);
17786 return (PARSER_SEPARATOR_UNMATCHED
);
17789 nonce_client_pos
[0] = 0;
17790 nonce_client_pos
++;
17792 uint nonce_len
= strlen (nonce_pos
);
17794 if (nonce_len
< 1 || nonce_len
> 50)
17796 myfree (temp_input_buf
);
17798 return (PARSER_SALT_LENGTH
);
17803 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17805 if (nonce_count_pos
== NULL
)
17807 myfree (temp_input_buf
);
17809 return (PARSER_SEPARATOR_UNMATCHED
);
17812 nonce_count_pos
[0] = 0;
17815 uint nonce_client_len
= strlen (nonce_client_pos
);
17817 if (nonce_client_len
> 50)
17819 myfree (temp_input_buf
);
17821 return (PARSER_SALT_LENGTH
);
17826 char *qop_pos
= strchr (nonce_count_pos
, '*');
17828 if (qop_pos
== NULL
)
17830 myfree (temp_input_buf
);
17832 return (PARSER_SEPARATOR_UNMATCHED
);
17838 uint nonce_count_len
= strlen (nonce_count_pos
);
17840 if (nonce_count_len
> 50)
17842 myfree (temp_input_buf
);
17844 return (PARSER_SALT_LENGTH
);
17849 char *directive_pos
= strchr (qop_pos
, '*');
17851 if (directive_pos
== NULL
)
17853 myfree (temp_input_buf
);
17855 return (PARSER_SEPARATOR_UNMATCHED
);
17858 directive_pos
[0] = 0;
17861 uint qop_len
= strlen (qop_pos
);
17865 myfree (temp_input_buf
);
17867 return (PARSER_SALT_LENGTH
);
17872 char *digest_pos
= strchr (directive_pos
, '*');
17874 if (digest_pos
== NULL
)
17876 myfree (temp_input_buf
);
17878 return (PARSER_SEPARATOR_UNMATCHED
);
17884 uint directive_len
= strlen (directive_pos
);
17886 if (directive_len
!= 3)
17888 myfree (temp_input_buf
);
17890 return (PARSER_SALT_LENGTH
);
17893 if (memcmp (directive_pos
, "MD5", 3))
17895 log_info ("ERROR: only the MD5 directive is currently supported\n");
17897 myfree (temp_input_buf
);
17899 return (PARSER_SIP_AUTH_DIRECTIVE
);
17903 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17908 uint md5_max_len
= 4 * 64;
17910 uint md5_remaining_len
= md5_max_len
;
17912 uint tmp_md5_buf
[64] = { 0 };
17914 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17916 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17918 md5_len
+= method_len
+ 1;
17919 tmp_md5_ptr
+= method_len
+ 1;
17921 if (URI_prefix_len
> 0)
17923 md5_remaining_len
= md5_max_len
- md5_len
;
17925 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17927 md5_len
+= URI_prefix_len
+ 1;
17928 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17931 md5_remaining_len
= md5_max_len
- md5_len
;
17933 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17935 md5_len
+= URI_resource_len
;
17936 tmp_md5_ptr
+= URI_resource_len
;
17938 if (URI_suffix_len
> 0)
17940 md5_remaining_len
= md5_max_len
- md5_len
;
17942 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17944 md5_len
+= 1 + URI_suffix_len
;
17947 uint tmp_digest
[4] = { 0 };
17949 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17951 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17952 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17953 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17954 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17960 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17962 uint esalt_len
= 0;
17964 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17966 // there are 2 possibilities for the esalt:
17968 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17970 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17972 if (esalt_len
> max_esalt_len
)
17974 myfree (temp_input_buf
);
17976 return (PARSER_SALT_LENGTH
);
17979 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17991 esalt_len
= 1 + nonce_len
+ 1 + 32;
17993 if (esalt_len
> max_esalt_len
)
17995 myfree (temp_input_buf
);
17997 return (PARSER_SALT_LENGTH
);
18000 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18008 // add 0x80 to esalt
18010 esalt_buf_ptr
[esalt_len
] = 0x80;
18012 sip
->esalt_len
= esalt_len
;
18018 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18020 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18022 uint max_salt_len
= 119;
18024 if (salt_len
> max_salt_len
)
18026 myfree (temp_input_buf
);
18028 return (PARSER_SALT_LENGTH
);
18031 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18033 sip
->salt_len
= salt_len
;
18036 * fake salt (for sorting)
18039 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18043 uint fake_salt_len
= salt_len
;
18045 if (fake_salt_len
> max_salt_len
)
18047 fake_salt_len
= max_salt_len
;
18050 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18052 salt
->salt_len
= fake_salt_len
;
18058 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18059 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18060 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18061 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18063 digest
[0] = byte_swap_32 (digest
[0]);
18064 digest
[1] = byte_swap_32 (digest
[1]);
18065 digest
[2] = byte_swap_32 (digest
[2]);
18066 digest
[3] = byte_swap_32 (digest
[3]);
18068 myfree (temp_input_buf
);
18070 return (PARSER_OK
);
18073 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18075 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18077 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18079 u32
*digest
= (u32
*) hash_buf
->digest
;
18081 salt_t
*salt
= hash_buf
->salt
;
18085 char *digest_pos
= input_buf
;
18087 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18094 char *salt_buf
= input_buf
+ 8 + 1;
18098 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18100 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18102 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18104 salt
->salt_len
= salt_len
;
18106 return (PARSER_OK
);
18109 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18111 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18113 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18115 u32
*digest
= (u32
*) hash_buf
->digest
;
18117 salt_t
*salt
= hash_buf
->salt
;
18119 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18125 char *p_buf_pos
= input_buf
+ 4;
18127 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18129 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18131 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18133 NumCyclesPower_pos
++;
18135 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18137 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18139 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18143 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18145 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18147 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18151 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18153 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18155 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18159 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18161 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18163 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18167 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18169 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18171 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18175 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18177 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18179 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18183 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18185 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18187 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18191 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18193 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18195 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18199 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;
18201 const uint iter
= atoi (NumCyclesPower_pos
);
18202 const uint crc
= atoi (crc_buf_pos
);
18203 const uint p_buf
= atoi (p_buf_pos
);
18204 const uint salt_len
= atoi (salt_len_pos
);
18205 const uint iv_len
= atoi (iv_len_pos
);
18206 const uint unpack_size
= atoi (unpack_size_pos
);
18207 const uint data_len
= atoi (data_len_pos
);
18213 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18214 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18216 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18218 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18220 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18226 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18227 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18228 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18229 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18231 seven_zip
->iv_len
= iv_len
;
18233 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18235 seven_zip
->salt_len
= 0;
18237 seven_zip
->crc
= crc
;
18239 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18241 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18243 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18246 seven_zip
->data_len
= data_len
;
18248 seven_zip
->unpack_size
= unpack_size
;
18252 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18253 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18254 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18255 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18257 salt
->salt_len
= 16;
18259 salt
->salt_sign
[0] = iter
;
18261 salt
->salt_iter
= 1 << iter
;
18272 return (PARSER_OK
);
18275 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18277 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18279 u32
*digest
= (u32
*) hash_buf
->digest
;
18281 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18282 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18283 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18284 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18285 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18286 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18287 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18288 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18290 digest
[0] = byte_swap_32 (digest
[0]);
18291 digest
[1] = byte_swap_32 (digest
[1]);
18292 digest
[2] = byte_swap_32 (digest
[2]);
18293 digest
[3] = byte_swap_32 (digest
[3]);
18294 digest
[4] = byte_swap_32 (digest
[4]);
18295 digest
[5] = byte_swap_32 (digest
[5]);
18296 digest
[6] = byte_swap_32 (digest
[6]);
18297 digest
[7] = byte_swap_32 (digest
[7]);
18299 return (PARSER_OK
);
18302 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18304 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18306 u32
*digest
= (u32
*) hash_buf
->digest
;
18308 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18309 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18310 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18311 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18312 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18313 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18314 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18315 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18316 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18317 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18318 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18319 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18320 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18321 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18322 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18323 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18325 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18326 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18327 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18328 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18329 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18330 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18331 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18332 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18333 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18334 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18335 digest
[10] = byte_swap_32 (digest
[10]);
18336 digest
[11] = byte_swap_32 (digest
[11]);
18337 digest
[12] = byte_swap_32 (digest
[12]);
18338 digest
[13] = byte_swap_32 (digest
[13]);
18339 digest
[14] = byte_swap_32 (digest
[14]);
18340 digest
[15] = byte_swap_32 (digest
[15]);
18342 return (PARSER_OK
);
18345 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18347 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18349 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18351 u32
*digest
= (u32
*) hash_buf
->digest
;
18353 salt_t
*salt
= hash_buf
->salt
;
18355 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18363 char *iter_pos
= input_buf
+ 4;
18365 u32 iter
= atoi (iter_pos
);
18367 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18368 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18370 // first is *raw* salt
18372 char *salt_pos
= strchr (iter_pos
, ':');
18374 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18378 char *hash_pos
= strchr (salt_pos
, ':');
18380 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18382 u32 salt_len
= hash_pos
- salt_pos
;
18384 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18388 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18390 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18394 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18396 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18398 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18400 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18401 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18403 salt
->salt_len
= salt_len
;
18404 salt
->salt_iter
= iter
- 1;
18408 u8 tmp_buf
[100] = { 0 };
18410 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18412 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18414 memcpy (digest
, tmp_buf
, 16);
18416 // add some stuff to normal salt to make sorted happy
18418 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18419 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18420 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18421 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18422 salt
->salt_buf
[4] = salt
->salt_iter
;
18424 return (PARSER_OK
);
18427 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18429 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18431 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18433 u32
*digest
= (u32
*) hash_buf
->digest
;
18435 salt_t
*salt
= hash_buf
->salt
;
18437 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18445 char *iter_pos
= input_buf
+ 5;
18447 u32 iter
= atoi (iter_pos
);
18449 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18450 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18452 // first is *raw* salt
18454 char *salt_pos
= strchr (iter_pos
, ':');
18456 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18460 char *hash_pos
= strchr (salt_pos
, ':');
18462 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18464 u32 salt_len
= hash_pos
- salt_pos
;
18466 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18470 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18472 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18476 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18478 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18480 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18482 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18483 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18485 salt
->salt_len
= salt_len
;
18486 salt
->salt_iter
= iter
- 1;
18490 u8 tmp_buf
[100] = { 0 };
18492 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18494 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18496 memcpy (digest
, tmp_buf
, 16);
18498 digest
[0] = byte_swap_32 (digest
[0]);
18499 digest
[1] = byte_swap_32 (digest
[1]);
18500 digest
[2] = byte_swap_32 (digest
[2]);
18501 digest
[3] = byte_swap_32 (digest
[3]);
18503 // add some stuff to normal salt to make sorted happy
18505 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18506 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18507 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18508 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18509 salt
->salt_buf
[4] = salt
->salt_iter
;
18511 return (PARSER_OK
);
18514 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18516 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18518 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18520 u64
*digest
= (u64
*) hash_buf
->digest
;
18522 salt_t
*salt
= hash_buf
->salt
;
18524 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18532 char *iter_pos
= input_buf
+ 7;
18534 u32 iter
= atoi (iter_pos
);
18536 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18537 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18539 // first is *raw* salt
18541 char *salt_pos
= strchr (iter_pos
, ':');
18543 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18547 char *hash_pos
= strchr (salt_pos
, ':');
18549 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18551 u32 salt_len
= hash_pos
- salt_pos
;
18553 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18557 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18559 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18563 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18565 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18567 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18569 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18570 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18572 salt
->salt_len
= salt_len
;
18573 salt
->salt_iter
= iter
- 1;
18577 u8 tmp_buf
[100] = { 0 };
18579 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18581 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18583 memcpy (digest
, tmp_buf
, 64);
18585 digest
[0] = byte_swap_64 (digest
[0]);
18586 digest
[1] = byte_swap_64 (digest
[1]);
18587 digest
[2] = byte_swap_64 (digest
[2]);
18588 digest
[3] = byte_swap_64 (digest
[3]);
18589 digest
[4] = byte_swap_64 (digest
[4]);
18590 digest
[5] = byte_swap_64 (digest
[5]);
18591 digest
[6] = byte_swap_64 (digest
[6]);
18592 digest
[7] = byte_swap_64 (digest
[7]);
18594 // add some stuff to normal salt to make sorted happy
18596 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18597 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18598 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18599 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18600 salt
->salt_buf
[4] = salt
->salt_iter
;
18602 return (PARSER_OK
);
18605 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18607 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18609 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18611 uint
*digest
= (uint
*) hash_buf
->digest
;
18613 salt_t
*salt
= hash_buf
->salt
;
18619 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18621 char *hash_pos
= strchr (salt_pos
, '$');
18623 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18625 u32 salt_len
= hash_pos
- salt_pos
;
18627 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18631 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18633 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18637 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18638 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18656 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18657 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18659 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18660 salt
->salt_len
= 8;
18662 return (PARSER_OK
);
18665 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18667 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18669 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18671 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18673 if (c19
& 3) return (PARSER_HASH_VALUE
);
18675 salt_t
*salt
= hash_buf
->salt
;
18677 u32
*digest
= (u32
*) hash_buf
->digest
;
18681 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18682 | itoa64_to_int (input_buf
[2]) << 6
18683 | itoa64_to_int (input_buf
[3]) << 12
18684 | itoa64_to_int (input_buf
[4]) << 18;
18688 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18689 | itoa64_to_int (input_buf
[6]) << 6
18690 | itoa64_to_int (input_buf
[7]) << 12
18691 | itoa64_to_int (input_buf
[8]) << 18;
18693 salt
->salt_len
= 4;
18695 u8 tmp_buf
[100] = { 0 };
18697 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18699 memcpy (digest
, tmp_buf
, 8);
18703 IP (digest
[0], digest
[1], tt
);
18705 digest
[0] = rotr32 (digest
[0], 31);
18706 digest
[1] = rotr32 (digest
[1], 31);
18710 return (PARSER_OK
);
18713 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18715 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18717 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18719 u32
*digest
= (u32
*) hash_buf
->digest
;
18721 salt_t
*salt
= hash_buf
->salt
;
18727 char *type_pos
= input_buf
+ 6 + 1;
18729 char *salt_pos
= strchr (type_pos
, '*');
18731 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18733 u32 type_len
= salt_pos
- type_pos
;
18735 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18739 char *crypted_pos
= strchr (salt_pos
, '*');
18741 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18743 u32 salt_len
= crypted_pos
- salt_pos
;
18745 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18749 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18751 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18757 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18758 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18760 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18761 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18763 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18764 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18765 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18766 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18768 salt
->salt_len
= 24;
18769 salt
->salt_iter
= ROUNDS_RAR3
;
18771 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18772 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18774 digest
[0] = 0xc43d7b00;
18775 digest
[1] = 0x40070000;
18779 return (PARSER_OK
);
18782 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18784 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18786 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18788 u32
*digest
= (u32
*) hash_buf
->digest
;
18790 salt_t
*salt
= hash_buf
->salt
;
18792 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18798 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18800 char *param1_pos
= strchr (param0_pos
, '$');
18802 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18804 u32 param0_len
= param1_pos
- param0_pos
;
18808 char *param2_pos
= strchr (param1_pos
, '$');
18810 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18812 u32 param1_len
= param2_pos
- param1_pos
;
18816 char *param3_pos
= strchr (param2_pos
, '$');
18818 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18820 u32 param2_len
= param3_pos
- param2_pos
;
18824 char *param4_pos
= strchr (param3_pos
, '$');
18826 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18828 u32 param3_len
= param4_pos
- param3_pos
;
18832 char *param5_pos
= strchr (param4_pos
, '$');
18834 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18836 u32 param4_len
= param5_pos
- param4_pos
;
18840 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18842 char *salt_buf
= param1_pos
;
18843 char *iv
= param3_pos
;
18844 char *pswcheck
= param5_pos
;
18846 const uint salt_len
= atoi (param0_pos
);
18847 const uint iterations
= atoi (param2_pos
);
18848 const uint pswcheck_len
= atoi (param4_pos
);
18854 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18855 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18856 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18858 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18859 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18860 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18866 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18867 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18868 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18869 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
18871 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
18872 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
18873 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
18874 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
18876 salt
->salt_len
= 16;
18878 salt
->salt_sign
[0] = iterations
;
18880 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18886 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
18887 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
18891 return (PARSER_OK
);
18894 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18896 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18898 u32
*digest
= (u32
*) hash_buf
->digest
;
18900 salt_t
*salt
= hash_buf
->salt
;
18902 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18903 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18904 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18905 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18906 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18907 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18908 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18909 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18911 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18913 uint salt_len
= input_len
- 64 - 1;
18915 char *salt_buf
= input_buf
+ 64 + 1;
18917 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18919 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18921 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18923 salt
->salt_len
= salt_len
;
18926 * we can precompute the first sha256 transform
18929 uint w
[16] = { 0 };
18931 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18932 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18933 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18934 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18935 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18936 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18937 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18938 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18939 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18940 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18941 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18942 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18943 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18944 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18945 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18946 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18948 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
18950 sha256_64 (w
, pc256
);
18952 salt
->salt_buf_pc
[0] = pc256
[0];
18953 salt
->salt_buf_pc
[1] = pc256
[1];
18954 salt
->salt_buf_pc
[2] = pc256
[2];
18955 salt
->salt_buf_pc
[3] = pc256
[3];
18956 salt
->salt_buf_pc
[4] = pc256
[4];
18957 salt
->salt_buf_pc
[5] = pc256
[5];
18958 salt
->salt_buf_pc
[6] = pc256
[6];
18959 salt
->salt_buf_pc
[7] = pc256
[7];
18961 digest
[0] -= pc256
[0];
18962 digest
[1] -= pc256
[1];
18963 digest
[2] -= pc256
[2];
18964 digest
[3] -= pc256
[3];
18965 digest
[4] -= pc256
[4];
18966 digest
[5] -= pc256
[5];
18967 digest
[6] -= pc256
[6];
18968 digest
[7] -= pc256
[7];
18970 return (PARSER_OK
);
18973 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18975 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18977 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18979 u32
*digest
= (u32
*) hash_buf
->digest
;
18981 salt_t
*salt
= hash_buf
->salt
;
18987 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18989 char *data_buf_pos
= strchr (data_len_pos
, '$');
18991 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18993 u32 data_len_len
= data_buf_pos
- data_len_pos
;
18995 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18996 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
19000 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
19002 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
19004 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
19006 u32 data_len
= atoi (data_len_pos
);
19008 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
19014 char *salt_pos
= data_buf_pos
;
19016 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19017 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19018 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
19019 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
19021 // this is actually the CT, which is also the hash later (if matched)
19023 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
19024 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
19025 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
19026 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
19028 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
19030 salt
->salt_iter
= 10 - 1;
19036 digest
[0] = salt
->salt_buf
[4];
19037 digest
[1] = salt
->salt_buf
[5];
19038 digest
[2] = salt
->salt_buf
[6];
19039 digest
[3] = salt
->salt_buf
[7];
19041 return (PARSER_OK
);
19044 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19046 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
19048 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19050 u32
*digest
= (u32
*) hash_buf
->digest
;
19052 salt_t
*salt
= hash_buf
->salt
;
19058 char *salt_pos
= input_buf
+ 11 + 1;
19060 char *iter_pos
= strchr (salt_pos
, ',');
19062 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19064 u32 salt_len
= iter_pos
- salt_pos
;
19066 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
19070 char *hash_pos
= strchr (iter_pos
, ',');
19072 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19074 u32 iter_len
= hash_pos
- iter_pos
;
19076 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
19080 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
19082 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
19088 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19089 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19090 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
19091 salt
->salt_buf
[3] = 0x00018000;
19093 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19094 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19095 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
19096 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
19098 salt
->salt_len
= salt_len
/ 2;
19100 salt
->salt_iter
= atoi (iter_pos
) - 1;
19106 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19107 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19108 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19109 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19110 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19111 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19112 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19113 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19115 return (PARSER_OK
);
19118 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19120 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
19122 u32
*digest
= (u32
*) hash_buf
->digest
;
19124 salt_t
*salt
= hash_buf
->salt
;
19130 char *hash_pos
= input_buf
+ 64;
19131 char *salt1_pos
= input_buf
+ 128;
19132 char *salt2_pos
= input_buf
;
19138 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
19139 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
19140 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
19141 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
19143 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
19144 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
19145 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
19146 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
19148 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
19149 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
19150 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
19151 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
19153 salt
->salt_len
= 48;
19155 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
19161 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19162 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19163 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19164 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19165 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19166 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19167 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19168 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19170 return (PARSER_OK
);
19174 * parallel running threads
19179 BOOL WINAPI
sigHandler_default (DWORD sig
)
19183 case CTRL_CLOSE_EVENT
:
19186 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
19187 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
19188 * function otherwise it is too late (e.g. after returning from this function)
19193 SetConsoleCtrlHandler (NULL
, TRUE
);
19200 case CTRL_LOGOFF_EVENT
:
19201 case CTRL_SHUTDOWN_EVENT
:
19205 SetConsoleCtrlHandler (NULL
, TRUE
);
19213 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19217 case CTRL_CLOSE_EVENT
:
19221 SetConsoleCtrlHandler (NULL
, TRUE
);
19228 case CTRL_LOGOFF_EVENT
:
19229 case CTRL_SHUTDOWN_EVENT
:
19233 SetConsoleCtrlHandler (NULL
, TRUE
);
19241 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19243 if (callback
== NULL
)
19245 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19249 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19255 void sigHandler_default (int sig
)
19259 signal (sig
, NULL
);
19262 void sigHandler_benchmark (int sig
)
19266 signal (sig
, NULL
);
19269 void hc_signal (void (callback
) (int))
19271 if (callback
== NULL
) callback
= SIG_DFL
;
19273 signal (SIGINT
, callback
);
19274 signal (SIGTERM
, callback
);
19275 signal (SIGABRT
, callback
);
19280 void status_display ();
19282 void *thread_keypress (void *p
)
19284 int benchmark
= *((int *) p
);
19286 uint quiet
= data
.quiet
;
19290 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19292 int ch
= tty_getchar();
19294 if (ch
== -1) break;
19296 if (ch
== 0) continue;
19302 hc_thread_mutex_lock (mux_display
);
19317 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19318 if (quiet
== 0) fflush (stdout
);
19330 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19331 if (quiet
== 0) fflush (stdout
);
19343 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19344 if (quiet
== 0) fflush (stdout
);
19356 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19357 if (quiet
== 0) fflush (stdout
);
19365 if (benchmark
== 1) break;
19367 stop_at_checkpoint ();
19371 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19372 if (quiet
== 0) fflush (stdout
);
19380 if (benchmark
== 1)
19392 hc_thread_mutex_unlock (mux_display
);
19404 bool class_num (const u8 c
)
19406 return ((c
>= '0') && (c
<= '9'));
19409 bool class_lower (const u8 c
)
19411 return ((c
>= 'a') && (c
<= 'z'));
19414 bool class_upper (const u8 c
)
19416 return ((c
>= 'A') && (c
<= 'Z'));
19419 bool class_alpha (const u8 c
)
19421 return (class_lower (c
) || class_upper (c
));
19424 int conv_ctoi (const u8 c
)
19430 else if (class_upper (c
))
19432 return c
- 'A' + 10;
19438 int conv_itoc (const u8 c
)
19446 return c
+ 'A' - 10;
19456 #define INCR_POS if (++rule_pos == rule_len) return (-1)
19457 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
19458 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
19459 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
19460 #define MAX_KERNEL_RULES 255
19461 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
19462 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19463 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19465 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
19466 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
19467 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19468 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19470 int cpu_rule_to_kernel_rule (char rule_buf
[BUFSIZ
], uint rule_len
, kernel_rule_t
*rule
)
19475 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19477 switch (rule_buf
[rule_pos
])
19483 case RULE_OP_MANGLE_NOOP
:
19484 SET_NAME (rule
, rule_buf
[rule_pos
]);
19487 case RULE_OP_MANGLE_LREST
:
19488 SET_NAME (rule
, rule_buf
[rule_pos
]);
19491 case RULE_OP_MANGLE_UREST
:
19492 SET_NAME (rule
, rule_buf
[rule_pos
]);
19495 case RULE_OP_MANGLE_LREST_UFIRST
:
19496 SET_NAME (rule
, rule_buf
[rule_pos
]);
19499 case RULE_OP_MANGLE_UREST_LFIRST
:
19500 SET_NAME (rule
, rule_buf
[rule_pos
]);
19503 case RULE_OP_MANGLE_TREST
:
19504 SET_NAME (rule
, rule_buf
[rule_pos
]);
19507 case RULE_OP_MANGLE_TOGGLE_AT
:
19508 SET_NAME (rule
, rule_buf
[rule_pos
]);
19509 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19512 case RULE_OP_MANGLE_REVERSE
:
19513 SET_NAME (rule
, rule_buf
[rule_pos
]);
19516 case RULE_OP_MANGLE_DUPEWORD
:
19517 SET_NAME (rule
, rule_buf
[rule_pos
]);
19520 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19521 SET_NAME (rule
, rule_buf
[rule_pos
]);
19522 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19525 case RULE_OP_MANGLE_REFLECT
:
19526 SET_NAME (rule
, rule_buf
[rule_pos
]);
19529 case RULE_OP_MANGLE_ROTATE_LEFT
:
19530 SET_NAME (rule
, rule_buf
[rule_pos
]);
19533 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19534 SET_NAME (rule
, rule_buf
[rule_pos
]);
19537 case RULE_OP_MANGLE_APPEND
:
19538 SET_NAME (rule
, rule_buf
[rule_pos
]);
19539 SET_P0 (rule
, rule_buf
[rule_pos
]);
19542 case RULE_OP_MANGLE_PREPEND
:
19543 SET_NAME (rule
, rule_buf
[rule_pos
]);
19544 SET_P0 (rule
, rule_buf
[rule_pos
]);
19547 case RULE_OP_MANGLE_DELETE_FIRST
:
19548 SET_NAME (rule
, rule_buf
[rule_pos
]);
19551 case RULE_OP_MANGLE_DELETE_LAST
:
19552 SET_NAME (rule
, rule_buf
[rule_pos
]);
19555 case RULE_OP_MANGLE_DELETE_AT
:
19556 SET_NAME (rule
, rule_buf
[rule_pos
]);
19557 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19560 case RULE_OP_MANGLE_EXTRACT
:
19561 SET_NAME (rule
, rule_buf
[rule_pos
]);
19562 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19563 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19566 case RULE_OP_MANGLE_OMIT
:
19567 SET_NAME (rule
, rule_buf
[rule_pos
]);
19568 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19569 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19572 case RULE_OP_MANGLE_INSERT
:
19573 SET_NAME (rule
, rule_buf
[rule_pos
]);
19574 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19575 SET_P1 (rule
, rule_buf
[rule_pos
]);
19578 case RULE_OP_MANGLE_OVERSTRIKE
:
19579 SET_NAME (rule
, rule_buf
[rule_pos
]);
19580 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19581 SET_P1 (rule
, rule_buf
[rule_pos
]);
19584 case RULE_OP_MANGLE_TRUNCATE_AT
:
19585 SET_NAME (rule
, rule_buf
[rule_pos
]);
19586 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19589 case RULE_OP_MANGLE_REPLACE
:
19590 SET_NAME (rule
, rule_buf
[rule_pos
]);
19591 SET_P0 (rule
, rule_buf
[rule_pos
]);
19592 SET_P1 (rule
, rule_buf
[rule_pos
]);
19595 case RULE_OP_MANGLE_PURGECHAR
:
19599 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19603 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19604 SET_NAME (rule
, rule_buf
[rule_pos
]);
19605 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19608 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19609 SET_NAME (rule
, rule_buf
[rule_pos
]);
19610 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19613 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19614 SET_NAME (rule
, rule_buf
[rule_pos
]);
19617 case RULE_OP_MANGLE_SWITCH_FIRST
:
19618 SET_NAME (rule
, rule_buf
[rule_pos
]);
19621 case RULE_OP_MANGLE_SWITCH_LAST
:
19622 SET_NAME (rule
, rule_buf
[rule_pos
]);
19625 case RULE_OP_MANGLE_SWITCH_AT
:
19626 SET_NAME (rule
, rule_buf
[rule_pos
]);
19627 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19628 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19631 case RULE_OP_MANGLE_CHR_SHIFTL
:
19632 SET_NAME (rule
, rule_buf
[rule_pos
]);
19633 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19636 case RULE_OP_MANGLE_CHR_SHIFTR
:
19637 SET_NAME (rule
, rule_buf
[rule_pos
]);
19638 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19641 case RULE_OP_MANGLE_CHR_INCR
:
19642 SET_NAME (rule
, rule_buf
[rule_pos
]);
19643 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19646 case RULE_OP_MANGLE_CHR_DECR
:
19647 SET_NAME (rule
, rule_buf
[rule_pos
]);
19648 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19651 case RULE_OP_MANGLE_REPLACE_NP1
:
19652 SET_NAME (rule
, rule_buf
[rule_pos
]);
19653 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19656 case RULE_OP_MANGLE_REPLACE_NM1
:
19657 SET_NAME (rule
, rule_buf
[rule_pos
]);
19658 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19661 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19662 SET_NAME (rule
, rule_buf
[rule_pos
]);
19663 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19666 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19667 SET_NAME (rule
, rule_buf
[rule_pos
]);
19668 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19671 case RULE_OP_MANGLE_TITLE
:
19672 SET_NAME (rule
, rule_buf
[rule_pos
]);
19681 if (rule_pos
< rule_len
) return (-1);
19686 int kernel_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], kernel_rule_t
*rule
)
19690 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19694 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19698 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19702 case RULE_OP_MANGLE_NOOP
:
19703 rule_buf
[rule_pos
] = rule_cmd
;
19706 case RULE_OP_MANGLE_LREST
:
19707 rule_buf
[rule_pos
] = rule_cmd
;
19710 case RULE_OP_MANGLE_UREST
:
19711 rule_buf
[rule_pos
] = rule_cmd
;
19714 case RULE_OP_MANGLE_LREST_UFIRST
:
19715 rule_buf
[rule_pos
] = rule_cmd
;
19718 case RULE_OP_MANGLE_UREST_LFIRST
:
19719 rule_buf
[rule_pos
] = rule_cmd
;
19722 case RULE_OP_MANGLE_TREST
:
19723 rule_buf
[rule_pos
] = rule_cmd
;
19726 case RULE_OP_MANGLE_TOGGLE_AT
:
19727 rule_buf
[rule_pos
] = rule_cmd
;
19728 GET_P0_CONV (rule
);
19731 case RULE_OP_MANGLE_REVERSE
:
19732 rule_buf
[rule_pos
] = rule_cmd
;
19735 case RULE_OP_MANGLE_DUPEWORD
:
19736 rule_buf
[rule_pos
] = rule_cmd
;
19739 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19740 rule_buf
[rule_pos
] = rule_cmd
;
19741 GET_P0_CONV (rule
);
19744 case RULE_OP_MANGLE_REFLECT
:
19745 rule_buf
[rule_pos
] = rule_cmd
;
19748 case RULE_OP_MANGLE_ROTATE_LEFT
:
19749 rule_buf
[rule_pos
] = rule_cmd
;
19752 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19753 rule_buf
[rule_pos
] = rule_cmd
;
19756 case RULE_OP_MANGLE_APPEND
:
19757 rule_buf
[rule_pos
] = rule_cmd
;
19761 case RULE_OP_MANGLE_PREPEND
:
19762 rule_buf
[rule_pos
] = rule_cmd
;
19766 case RULE_OP_MANGLE_DELETE_FIRST
:
19767 rule_buf
[rule_pos
] = rule_cmd
;
19770 case RULE_OP_MANGLE_DELETE_LAST
:
19771 rule_buf
[rule_pos
] = rule_cmd
;
19774 case RULE_OP_MANGLE_DELETE_AT
:
19775 rule_buf
[rule_pos
] = rule_cmd
;
19776 GET_P0_CONV (rule
);
19779 case RULE_OP_MANGLE_EXTRACT
:
19780 rule_buf
[rule_pos
] = rule_cmd
;
19781 GET_P0_CONV (rule
);
19782 GET_P1_CONV (rule
);
19785 case RULE_OP_MANGLE_OMIT
:
19786 rule_buf
[rule_pos
] = rule_cmd
;
19787 GET_P0_CONV (rule
);
19788 GET_P1_CONV (rule
);
19791 case RULE_OP_MANGLE_INSERT
:
19792 rule_buf
[rule_pos
] = rule_cmd
;
19793 GET_P0_CONV (rule
);
19797 case RULE_OP_MANGLE_OVERSTRIKE
:
19798 rule_buf
[rule_pos
] = rule_cmd
;
19799 GET_P0_CONV (rule
);
19803 case RULE_OP_MANGLE_TRUNCATE_AT
:
19804 rule_buf
[rule_pos
] = rule_cmd
;
19805 GET_P0_CONV (rule
);
19808 case RULE_OP_MANGLE_REPLACE
:
19809 rule_buf
[rule_pos
] = rule_cmd
;
19814 case RULE_OP_MANGLE_PURGECHAR
:
19818 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19822 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19823 rule_buf
[rule_pos
] = rule_cmd
;
19824 GET_P0_CONV (rule
);
19827 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19828 rule_buf
[rule_pos
] = rule_cmd
;
19829 GET_P0_CONV (rule
);
19832 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19833 rule_buf
[rule_pos
] = rule_cmd
;
19836 case RULE_OP_MANGLE_SWITCH_FIRST
:
19837 rule_buf
[rule_pos
] = rule_cmd
;
19840 case RULE_OP_MANGLE_SWITCH_LAST
:
19841 rule_buf
[rule_pos
] = rule_cmd
;
19844 case RULE_OP_MANGLE_SWITCH_AT
:
19845 rule_buf
[rule_pos
] = rule_cmd
;
19846 GET_P0_CONV (rule
);
19847 GET_P1_CONV (rule
);
19850 case RULE_OP_MANGLE_CHR_SHIFTL
:
19851 rule_buf
[rule_pos
] = rule_cmd
;
19852 GET_P0_CONV (rule
);
19855 case RULE_OP_MANGLE_CHR_SHIFTR
:
19856 rule_buf
[rule_pos
] = rule_cmd
;
19857 GET_P0_CONV (rule
);
19860 case RULE_OP_MANGLE_CHR_INCR
:
19861 rule_buf
[rule_pos
] = rule_cmd
;
19862 GET_P0_CONV (rule
);
19865 case RULE_OP_MANGLE_CHR_DECR
:
19866 rule_buf
[rule_pos
] = rule_cmd
;
19867 GET_P0_CONV (rule
);
19870 case RULE_OP_MANGLE_REPLACE_NP1
:
19871 rule_buf
[rule_pos
] = rule_cmd
;
19872 GET_P0_CONV (rule
);
19875 case RULE_OP_MANGLE_REPLACE_NM1
:
19876 rule_buf
[rule_pos
] = rule_cmd
;
19877 GET_P0_CONV (rule
);
19880 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19881 rule_buf
[rule_pos
] = rule_cmd
;
19882 GET_P0_CONV (rule
);
19885 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19886 rule_buf
[rule_pos
] = rule_cmd
;
19887 GET_P0_CONV (rule
);
19890 case RULE_OP_MANGLE_TITLE
:
19891 rule_buf
[rule_pos
] = rule_cmd
;
19895 return rule_pos
- 1;
19913 * CPU rules : this is from hashcat sources, cpu based rules
19916 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19917 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19919 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19920 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19921 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19923 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19924 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19925 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19927 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19931 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19936 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19940 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19945 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19949 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19954 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19959 for (l
= 0; l
< arr_len
; l
++)
19961 r
= arr_len
- 1 - l
;
19965 MANGLE_SWITCH (arr
, l
, r
);
19971 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19973 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19975 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19977 return (arr_len
* 2);
19980 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19982 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19984 int orig_len
= arr_len
;
19988 for (i
= 0; i
< times
; i
++)
19990 memcpy (&arr
[arr_len
], arr
, orig_len
);
19992 arr_len
+= orig_len
;
19998 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
20000 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20002 mangle_double (arr
, arr_len
);
20004 mangle_reverse (arr
+ arr_len
, arr_len
);
20006 return (arr_len
* 2);
20009 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
20014 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
20016 MANGLE_SWITCH (arr
, l
, r
);
20022 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
20027 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
20029 MANGLE_SWITCH (arr
, l
, r
);
20035 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20037 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20041 return (arr_len
+ 1);
20044 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20046 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20050 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20052 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20057 return (arr_len
+ 1);
20060 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20062 if (upos
>= arr_len
) return (arr_len
);
20066 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
20068 arr
[arr_pos
] = arr
[arr_pos
+ 1];
20071 return (arr_len
- 1);
20074 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20076 if (upos
>= arr_len
) return (arr_len
);
20078 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
20082 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
20084 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
20090 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20092 if (upos
>= arr_len
) return (arr_len
);
20094 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
20098 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
20100 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
20103 return (arr_len
- ulen
);
20106 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20108 if (upos
>= arr_len
) return (arr_len
);
20110 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20114 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
20116 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20121 return (arr_len
+ 1);
20124 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
)
20126 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20128 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
20130 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
20132 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
20134 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
20136 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
20138 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
20140 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
20142 return (arr_len
+ arr2_cpy
);
20145 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20147 if (upos
>= arr_len
) return (arr_len
);
20154 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20156 if (upos
>= arr_len
) return (arr_len
);
20158 memset (arr
+ upos
, 0, arr_len
- upos
);
20163 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
20167 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20169 if (arr
[arr_pos
] != oldc
) continue;
20171 arr
[arr_pos
] = newc
;
20177 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20183 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20185 if (arr
[arr_pos
] == c
) continue;
20187 arr
[ret_len
] = arr
[arr_pos
];
20195 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20197 if (ulen
> arr_len
) return (arr_len
);
20199 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20201 char cs
[100] = { 0 };
20203 memcpy (cs
, arr
, ulen
);
20207 for (i
= 0; i
< ulen
; i
++)
20211 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20217 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20219 if (ulen
> arr_len
) return (arr_len
);
20221 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20223 int upos
= arr_len
- ulen
;
20227 for (i
= 0; i
< ulen
; i
++)
20229 char c
= arr
[upos
+ i
];
20231 arr_len
= mangle_append (arr
, arr_len
, c
);
20237 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20239 if ( arr_len
== 0) return (arr_len
);
20240 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20242 char c
= arr
[upos
];
20246 for (i
= 0; i
< ulen
; i
++)
20248 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20254 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20256 if ( arr_len
== 0) return (arr_len
);
20257 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20261 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20263 int new_pos
= arr_pos
* 2;
20265 arr
[new_pos
] = arr
[arr_pos
];
20267 arr
[new_pos
+ 1] = arr
[arr_pos
];
20270 return (arr_len
* 2);
20273 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20275 if (upos
>= arr_len
) return (arr_len
);
20276 if (upos2
>= arr_len
) return (arr_len
);
20278 MANGLE_SWITCH (arr
, upos
, upos2
);
20283 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20285 MANGLE_SWITCH (arr
, upos
, upos2
);
20290 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20292 if (upos
>= arr_len
) return (arr_len
);
20299 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20301 if (upos
>= arr_len
) return (arr_len
);
20308 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20310 if (upos
>= arr_len
) return (arr_len
);
20317 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20319 if (upos
>= arr_len
) return (arr_len
);
20326 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20328 int upper_next
= 1;
20332 for (pos
= 0; pos
< arr_len
; pos
++)
20334 if (arr
[pos
] == ' ')
20345 MANGLE_UPPER_AT (arr
, pos
);
20349 MANGLE_LOWER_AT (arr
, pos
);
20356 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20358 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20364 for (j
= 0; j
< rp_gen_num
; j
++)
20371 switch ((char) get_random_num (0, 9))
20374 r
= get_random_num (0, sizeof (grp_op_nop
));
20375 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20379 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20380 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20381 p1
= get_random_num (0, sizeof (grp_pos
));
20382 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20386 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20387 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20388 p1
= get_random_num (1, 6);
20389 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20393 r
= get_random_num (0, sizeof (grp_op_chr
));
20394 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20395 p1
= get_random_num (0x20, 0x7e);
20396 rule_buf
[rule_pos
++] = (char) p1
;
20400 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20401 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20402 p1
= get_random_num (0x20, 0x7e);
20403 rule_buf
[rule_pos
++] = (char) p1
;
20404 p2
= get_random_num (0x20, 0x7e);
20406 p2
= get_random_num (0x20, 0x7e);
20407 rule_buf
[rule_pos
++] = (char) p2
;
20411 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20412 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20413 p1
= get_random_num (0, sizeof (grp_pos
));
20414 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20415 p2
= get_random_num (0x20, 0x7e);
20416 rule_buf
[rule_pos
++] = (char) p2
;
20420 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20421 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20422 p1
= get_random_num (0, sizeof (grp_pos
));
20423 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20424 p2
= get_random_num (0, sizeof (grp_pos
));
20426 p2
= get_random_num (0, sizeof (grp_pos
));
20427 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20431 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20432 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
20433 p1
= get_random_num (0, sizeof (grp_pos
));
20434 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20435 p2
= get_random_num (1, sizeof (grp_pos
));
20437 p2
= get_random_num (1, sizeof (grp_pos
));
20438 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20442 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
20443 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
20444 p1
= get_random_num (0, sizeof (grp_pos
));
20445 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20446 p2
= get_random_num (1, sizeof (grp_pos
));
20447 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20448 p3
= get_random_num (0, sizeof (grp_pos
));
20449 rule_buf
[rule_pos
++] = grp_pos
[p3
];
20457 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
20459 char mem
[BLOCK_SIZE
] = { 0 };
20461 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
20463 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
20465 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20467 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
20469 int out_len
= in_len
;
20470 int mem_len
= in_len
;
20472 memcpy (out
, in
, out_len
);
20476 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
20481 switch (rule
[rule_pos
])
20486 case RULE_OP_MANGLE_NOOP
:
20489 case RULE_OP_MANGLE_LREST
:
20490 out_len
= mangle_lrest (out
, out_len
);
20493 case RULE_OP_MANGLE_UREST
:
20494 out_len
= mangle_urest (out
, out_len
);
20497 case RULE_OP_MANGLE_LREST_UFIRST
:
20498 out_len
= mangle_lrest (out
, out_len
);
20499 if (out_len
) MANGLE_UPPER_AT (out
, 0);
20502 case RULE_OP_MANGLE_UREST_LFIRST
:
20503 out_len
= mangle_urest (out
, out_len
);
20504 if (out_len
) MANGLE_LOWER_AT (out
, 0);
20507 case RULE_OP_MANGLE_TREST
:
20508 out_len
= mangle_trest (out
, out_len
);
20511 case RULE_OP_MANGLE_TOGGLE_AT
:
20512 NEXT_RULEPOS (rule_pos
);
20513 NEXT_RPTOI (rule
, rule_pos
, upos
);
20514 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
20517 case RULE_OP_MANGLE_REVERSE
:
20518 out_len
= mangle_reverse (out
, out_len
);
20521 case RULE_OP_MANGLE_DUPEWORD
:
20522 out_len
= mangle_double (out
, out_len
);
20525 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20526 NEXT_RULEPOS (rule_pos
);
20527 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20528 out_len
= mangle_double_times (out
, out_len
, ulen
);
20531 case RULE_OP_MANGLE_REFLECT
:
20532 out_len
= mangle_reflect (out
, out_len
);
20535 case RULE_OP_MANGLE_ROTATE_LEFT
:
20536 mangle_rotate_left (out
, out_len
);
20539 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20540 mangle_rotate_right (out
, out_len
);
20543 case RULE_OP_MANGLE_APPEND
:
20544 NEXT_RULEPOS (rule_pos
);
20545 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
20548 case RULE_OP_MANGLE_PREPEND
:
20549 NEXT_RULEPOS (rule_pos
);
20550 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
20553 case RULE_OP_MANGLE_DELETE_FIRST
:
20554 out_len
= mangle_delete_at (out
, out_len
, 0);
20557 case RULE_OP_MANGLE_DELETE_LAST
:
20558 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
20561 case RULE_OP_MANGLE_DELETE_AT
:
20562 NEXT_RULEPOS (rule_pos
);
20563 NEXT_RPTOI (rule
, rule_pos
, upos
);
20564 out_len
= mangle_delete_at (out
, out_len
, upos
);
20567 case RULE_OP_MANGLE_EXTRACT
:
20568 NEXT_RULEPOS (rule_pos
);
20569 NEXT_RPTOI (rule
, rule_pos
, upos
);
20570 NEXT_RULEPOS (rule_pos
);
20571 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20572 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
20575 case RULE_OP_MANGLE_OMIT
:
20576 NEXT_RULEPOS (rule_pos
);
20577 NEXT_RPTOI (rule
, rule_pos
, upos
);
20578 NEXT_RULEPOS (rule_pos
);
20579 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20580 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
20583 case RULE_OP_MANGLE_INSERT
:
20584 NEXT_RULEPOS (rule_pos
);
20585 NEXT_RPTOI (rule
, rule_pos
, upos
);
20586 NEXT_RULEPOS (rule_pos
);
20587 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
20590 case RULE_OP_MANGLE_OVERSTRIKE
:
20591 NEXT_RULEPOS (rule_pos
);
20592 NEXT_RPTOI (rule
, rule_pos
, upos
);
20593 NEXT_RULEPOS (rule_pos
);
20594 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20597 case RULE_OP_MANGLE_TRUNCATE_AT
:
20598 NEXT_RULEPOS (rule_pos
);
20599 NEXT_RPTOI (rule
, rule_pos
, upos
);
20600 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20603 case RULE_OP_MANGLE_REPLACE
:
20604 NEXT_RULEPOS (rule_pos
);
20605 NEXT_RULEPOS (rule_pos
);
20606 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20609 case RULE_OP_MANGLE_PURGECHAR
:
20610 NEXT_RULEPOS (rule_pos
);
20611 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20614 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20618 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20619 NEXT_RULEPOS (rule_pos
);
20620 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20621 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20624 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20625 NEXT_RULEPOS (rule_pos
);
20626 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20627 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20630 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20631 out_len
= mangle_dupechar (out
, out_len
);
20634 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20635 NEXT_RULEPOS (rule_pos
);
20636 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20637 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20640 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20641 NEXT_RULEPOS (rule_pos
);
20642 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20643 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20646 case RULE_OP_MANGLE_SWITCH_FIRST
:
20647 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20650 case RULE_OP_MANGLE_SWITCH_LAST
:
20651 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20654 case RULE_OP_MANGLE_SWITCH_AT
:
20655 NEXT_RULEPOS (rule_pos
);
20656 NEXT_RPTOI (rule
, rule_pos
, upos
);
20657 NEXT_RULEPOS (rule_pos
);
20658 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20659 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20662 case RULE_OP_MANGLE_CHR_SHIFTL
:
20663 NEXT_RULEPOS (rule_pos
);
20664 NEXT_RPTOI (rule
, rule_pos
, upos
);
20665 mangle_chr_shiftl (out
, out_len
, upos
);
20668 case RULE_OP_MANGLE_CHR_SHIFTR
:
20669 NEXT_RULEPOS (rule_pos
);
20670 NEXT_RPTOI (rule
, rule_pos
, upos
);
20671 mangle_chr_shiftr (out
, out_len
, upos
);
20674 case RULE_OP_MANGLE_CHR_INCR
:
20675 NEXT_RULEPOS (rule_pos
);
20676 NEXT_RPTOI (rule
, rule_pos
, upos
);
20677 mangle_chr_incr (out
, out_len
, upos
);
20680 case RULE_OP_MANGLE_CHR_DECR
:
20681 NEXT_RULEPOS (rule_pos
);
20682 NEXT_RPTOI (rule
, rule_pos
, upos
);
20683 mangle_chr_decr (out
, out_len
, upos
);
20686 case RULE_OP_MANGLE_REPLACE_NP1
:
20687 NEXT_RULEPOS (rule_pos
);
20688 NEXT_RPTOI (rule
, rule_pos
, upos
);
20689 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20692 case RULE_OP_MANGLE_REPLACE_NM1
:
20693 NEXT_RULEPOS (rule_pos
);
20694 NEXT_RPTOI (rule
, rule_pos
, upos
);
20695 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20698 case RULE_OP_MANGLE_TITLE
:
20699 out_len
= mangle_title (out
, out_len
);
20702 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20703 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20704 NEXT_RULEPOS (rule_pos
);
20705 NEXT_RPTOI (rule
, rule_pos
, upos
);
20706 NEXT_RULEPOS (rule_pos
);
20707 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20708 NEXT_RULEPOS (rule_pos
);
20709 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20710 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20713 case RULE_OP_MANGLE_APPEND_MEMORY
:
20714 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20715 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20716 memcpy (out
+ out_len
, mem
, mem_len
);
20717 out_len
+= mem_len
;
20720 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20721 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20722 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20723 memcpy (mem
+ mem_len
, out
, out_len
);
20724 out_len
+= mem_len
;
20725 memcpy (out
, mem
, out_len
);
20728 case RULE_OP_MEMORIZE_WORD
:
20729 memcpy (mem
, out
, out_len
);
20733 case RULE_OP_REJECT_LESS
:
20734 NEXT_RULEPOS (rule_pos
);
20735 NEXT_RPTOI (rule
, rule_pos
, upos
);
20736 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20739 case RULE_OP_REJECT_GREATER
:
20740 NEXT_RULEPOS (rule_pos
);
20741 NEXT_RPTOI (rule
, rule_pos
, upos
);
20742 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20745 case RULE_OP_REJECT_CONTAIN
:
20746 NEXT_RULEPOS (rule_pos
);
20747 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20750 case RULE_OP_REJECT_NOT_CONTAIN
:
20751 NEXT_RULEPOS (rule_pos
);
20752 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20755 case RULE_OP_REJECT_EQUAL_FIRST
:
20756 NEXT_RULEPOS (rule_pos
);
20757 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20760 case RULE_OP_REJECT_EQUAL_LAST
:
20761 NEXT_RULEPOS (rule_pos
);
20762 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20765 case RULE_OP_REJECT_EQUAL_AT
:
20766 NEXT_RULEPOS (rule_pos
);
20767 NEXT_RPTOI (rule
, rule_pos
, upos
);
20768 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20769 NEXT_RULEPOS (rule_pos
);
20770 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20773 case RULE_OP_REJECT_CONTAINS
:
20774 NEXT_RULEPOS (rule_pos
);
20775 NEXT_RPTOI (rule
, rule_pos
, upos
);
20776 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20777 NEXT_RULEPOS (rule_pos
);
20778 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20779 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20782 case RULE_OP_REJECT_MEMORY
:
20783 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20787 return (RULE_RC_SYNTAX_ERROR
);
20792 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);