2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
19 #define GET_ACCEL(x) KERNEL_ACCEL_ ## x
20 #define GET_LOOPS(x) KERNEL_LOOPS_ ## x
22 #define GET_LOOPS_OSX(x) KERNEL_LOOPS_OSX_ ## x
23 #define GET_ACCEL_OSX(x) KERNEL_ACCEL_OSX_ ## x
29 u32
rotl32 (const u32 a
, const u32 n
)
31 return ((a
<< n
) | (a
>> (32 - n
)));
34 u32
rotr32 (const u32 a
, const u32 n
)
36 return ((a
>> n
) | (a
<< (32 - n
)));
39 u64
rotl64 (const u64 a
, const u64 n
)
41 return ((a
<< n
) | (a
>> (64 - n
)));
44 u64
rotr64 (const u64 a
, const u64 n
)
46 return ((a
>> n
) | (a
<< (64 - n
)));
49 u32
byte_swap_32 (const u32 n
)
51 return (n
& 0xff000000) >> 24
52 | (n
& 0x00ff0000) >> 8
53 | (n
& 0x0000ff00) << 8
54 | (n
& 0x000000ff) << 24;
57 u64
byte_swap_64 (const u64 n
)
59 return (n
& 0xff00000000000000ULL
) >> 56
60 | (n
& 0x00ff000000000000ULL
) >> 40
61 | (n
& 0x0000ff0000000000ULL
) >> 24
62 | (n
& 0x000000ff00000000ULL
) >> 8
63 | (n
& 0x00000000ff000000ULL
) << 8
64 | (n
& 0x0000000000ff0000ULL
) << 24
65 | (n
& 0x000000000000ff00ULL
) << 40
66 | (n
& 0x00000000000000ffULL
) << 56;
70 * ciphers for use on cpu
77 * hashes for use on cpu
81 #include "cpu-sha256.c"
89 void log_final (FILE *fp
, const char *fmt
, va_list ap
)
95 for (int i
= 0; i
< last_len
; i
++)
103 char s
[4096] = { 0 };
105 int max_len
= (int) sizeof (s
);
107 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
109 if (len
> max_len
) len
= max_len
;
111 fwrite (s
, len
, 1, fp
);
118 void log_out_nn (FILE *fp
, const char *fmt
, ...)
120 if (SUPPRESS_OUTPUT
) return;
126 log_final (fp
, fmt
, ap
);
131 void log_info_nn (const char *fmt
, ...)
133 if (SUPPRESS_OUTPUT
) return;
139 log_final (stdout
, fmt
, ap
);
144 void log_error_nn (const char *fmt
, ...)
146 if (SUPPRESS_OUTPUT
) return;
152 log_final (stderr
, fmt
, ap
);
157 void log_out (FILE *fp
, const char *fmt
, ...)
159 if (SUPPRESS_OUTPUT
) return;
165 log_final (fp
, fmt
, ap
);
174 void log_info (const char *fmt
, ...)
176 if (SUPPRESS_OUTPUT
) return;
182 log_final (stdout
, fmt
, ap
);
186 fputc ('\n', stdout
);
191 void log_error (const char *fmt
, ...)
193 if (SUPPRESS_OUTPUT
) return;
195 fputc ('\n', stderr
);
196 fputc ('\n', stderr
);
202 log_final (stderr
, fmt
, ap
);
206 fputc ('\n', stderr
);
207 fputc ('\n', stderr
);
216 u8
int_to_base32 (const u8 c
)
218 static const u8 tbl
[0x20] =
220 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
221 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
227 u8
base32_to_int (const u8 c
)
229 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
230 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
235 u8
int_to_itoa32 (const u8 c
)
237 static const u8 tbl
[0x20] =
239 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
240 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
246 u8
itoa32_to_int (const u8 c
)
248 if ((c
>= '0') && (c
<= '9')) return c
- '0';
249 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
254 u8
int_to_itoa64 (const u8 c
)
256 static const u8 tbl
[0x40] =
258 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
259 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
260 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
261 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
267 u8
itoa64_to_int (const u8 c
)
269 static const u8 tbl
[0x100] =
271 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
272 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
273 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
274 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
275 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
276 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
277 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
278 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
279 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
280 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
281 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
282 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
283 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
284 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
285 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
286 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
292 u8
int_to_base64 (const u8 c
)
294 static const u8 tbl
[0x40] =
296 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
297 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
298 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
299 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
305 u8
base64_to_int (const u8 c
)
307 static const u8 tbl
[0x100] =
309 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
310 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
311 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
312 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
313 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
314 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
315 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
316 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
317 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
318 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
319 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
320 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
321 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
322 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
323 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
324 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
330 u8
int_to_bf64 (const u8 c
)
332 static const u8 tbl
[0x40] =
334 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
335 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
336 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
337 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
343 u8
bf64_to_int (const u8 c
)
345 static const u8 tbl
[0x100] =
347 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
348 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
349 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
350 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
351 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
352 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
353 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
354 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
355 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
356 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
357 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
358 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
359 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
360 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
361 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
362 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
368 u8
int_to_lotus64 (const u8 c
)
370 if (c
< 10) return '0' + c
;
371 else if (c
< 36) return 'A' + c
- 10;
372 else if (c
< 62) return 'a' + c
- 36;
373 else if (c
== 62) return '+';
374 else if (c
== 63) return '/';
379 u8
lotus64_to_int (const u8 c
)
381 if ((c
>= '0') && (c
<= '9')) return c
- '0';
382 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
383 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
384 else if (c
== '+') return 62;
385 else if (c
== '/') return 63;
391 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
393 const u8
*in_ptr
= in_buf
;
395 u8
*out_ptr
= out_buf
;
397 for (int i
= 0; i
< in_len
; i
+= 8)
399 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
400 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
401 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
402 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
403 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
404 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
405 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
406 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
408 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
409 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
410 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
411 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
412 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
418 for (int i
= 0; i
< in_len
; i
++)
420 if (in_buf
[i
] != '=') continue;
425 int out_len
= (in_len
* 5) / 8;
430 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
432 const u8
*in_ptr
= in_buf
;
434 u8
*out_ptr
= out_buf
;
436 for (int i
= 0; i
< in_len
; i
+= 5)
438 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
439 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
440 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
441 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
442 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
443 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
444 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
445 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
447 out_ptr
[0] = out_val0
& 0x7f;
448 out_ptr
[1] = out_val1
& 0x7f;
449 out_ptr
[2] = out_val2
& 0x7f;
450 out_ptr
[3] = out_val3
& 0x7f;
451 out_ptr
[4] = out_val4
& 0x7f;
452 out_ptr
[5] = out_val5
& 0x7f;
453 out_ptr
[6] = out_val6
& 0x7f;
454 out_ptr
[7] = out_val7
& 0x7f;
460 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
464 out_buf
[out_len
] = '=';
472 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
474 const u8
*in_ptr
= in_buf
;
476 u8
*out_ptr
= out_buf
;
478 for (int i
= 0; i
< in_len
; i
+= 4)
480 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
481 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
482 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
483 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
485 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
486 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
487 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
493 for (int i
= 0; i
< in_len
; i
++)
495 if (in_buf
[i
] != '=') continue;
500 int out_len
= (in_len
* 6) / 8;
505 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
507 const u8
*in_ptr
= in_buf
;
509 u8
*out_ptr
= out_buf
;
511 for (int i
= 0; i
< in_len
; i
+= 3)
513 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
514 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
515 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
516 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
518 out_ptr
[0] = out_val0
& 0x7f;
519 out_ptr
[1] = out_val1
& 0x7f;
520 out_ptr
[2] = out_val2
& 0x7f;
521 out_ptr
[3] = out_val3
& 0x7f;
527 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
531 out_buf
[out_len
] = '=';
539 int is_valid_hex_char (const u8 c
)
541 if ((c
>= '0') && (c
<= '9')) return 1;
542 if ((c
>= 'A') && (c
<= 'F')) return 1;
543 if ((c
>= 'a') && (c
<= 'f')) return 1;
548 u8
hex_convert (const u8 c
)
550 return (c
& 15) + (c
>> 6) * 9;
553 u8
hex_to_u8 (const u8 hex
[2])
557 v
|= (hex_convert (hex
[1]) << 0);
558 v
|= (hex_convert (hex
[0]) << 4);
563 u32
hex_to_u32 (const u8 hex
[8])
567 v
|= ((u32
) hex_convert (hex
[7])) << 0;
568 v
|= ((u32
) hex_convert (hex
[6])) << 4;
569 v
|= ((u32
) hex_convert (hex
[5])) << 8;
570 v
|= ((u32
) hex_convert (hex
[4])) << 12;
571 v
|= ((u32
) hex_convert (hex
[3])) << 16;
572 v
|= ((u32
) hex_convert (hex
[2])) << 20;
573 v
|= ((u32
) hex_convert (hex
[1])) << 24;
574 v
|= ((u32
) hex_convert (hex
[0])) << 28;
579 u64
hex_to_u64 (const u8 hex
[16])
583 v
|= ((u64
) hex_convert (hex
[15]) << 0);
584 v
|= ((u64
) hex_convert (hex
[14]) << 4);
585 v
|= ((u64
) hex_convert (hex
[13]) << 8);
586 v
|= ((u64
) hex_convert (hex
[12]) << 12);
587 v
|= ((u64
) hex_convert (hex
[11]) << 16);
588 v
|= ((u64
) hex_convert (hex
[10]) << 20);
589 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
590 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
591 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
592 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
593 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
594 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
595 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
596 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
597 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
598 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
603 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
605 hex
[0] = v
>> 28 & 15;
606 hex
[1] = v
>> 24 & 15;
607 hex
[2] = v
>> 20 & 15;
608 hex
[3] = v
>> 16 & 15;
609 hex
[4] = v
>> 12 & 15;
610 hex
[5] = v
>> 8 & 15;
611 hex
[6] = v
>> 4 & 15;
612 hex
[7] = v
>> 0 & 15;
616 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
617 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
618 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
619 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
620 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
621 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
622 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
623 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
630 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
634 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
643 for (int i
= 0; i
< 16; i
+= 4)
653 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
660 out
[i
+ 0] = _out
[0];
661 out
[i
+ 1] = _out
[1];
662 out
[i
+ 2] = _out
[2];
663 out
[i
+ 3] = _out
[3];
672 static void juniper_decrypt_hash (char *in
, char *out
)
676 u8 base64_buf
[100] = { 0 };
678 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
682 u32 juniper_iv
[4] = { 0 };
684 memcpy (juniper_iv
, base64_buf
, 12);
686 memcpy (out
, juniper_iv
, 12);
690 u32 juniper_key
[4] = { 0 };
692 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
693 juniper_key
[1] = byte_swap_32 (0x8df91059);
694 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
695 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
699 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
700 u32
*out_ptr
= (u32
*) (out
+ 12);
702 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
705 void phpass_decode (u8 digest
[16], u8 buf
[22])
709 l
= itoa64_to_int (buf
[ 0]) << 0;
710 l
|= itoa64_to_int (buf
[ 1]) << 6;
711 l
|= itoa64_to_int (buf
[ 2]) << 12;
712 l
|= itoa64_to_int (buf
[ 3]) << 18;
714 digest
[ 0] = (l
>> 0) & 0xff;
715 digest
[ 1] = (l
>> 8) & 0xff;
716 digest
[ 2] = (l
>> 16) & 0xff;
718 l
= itoa64_to_int (buf
[ 4]) << 0;
719 l
|= itoa64_to_int (buf
[ 5]) << 6;
720 l
|= itoa64_to_int (buf
[ 6]) << 12;
721 l
|= itoa64_to_int (buf
[ 7]) << 18;
723 digest
[ 3] = (l
>> 0) & 0xff;
724 digest
[ 4] = (l
>> 8) & 0xff;
725 digest
[ 5] = (l
>> 16) & 0xff;
727 l
= itoa64_to_int (buf
[ 8]) << 0;
728 l
|= itoa64_to_int (buf
[ 9]) << 6;
729 l
|= itoa64_to_int (buf
[10]) << 12;
730 l
|= itoa64_to_int (buf
[11]) << 18;
732 digest
[ 6] = (l
>> 0) & 0xff;
733 digest
[ 7] = (l
>> 8) & 0xff;
734 digest
[ 8] = (l
>> 16) & 0xff;
736 l
= itoa64_to_int (buf
[12]) << 0;
737 l
|= itoa64_to_int (buf
[13]) << 6;
738 l
|= itoa64_to_int (buf
[14]) << 12;
739 l
|= itoa64_to_int (buf
[15]) << 18;
741 digest
[ 9] = (l
>> 0) & 0xff;
742 digest
[10] = (l
>> 8) & 0xff;
743 digest
[11] = (l
>> 16) & 0xff;
745 l
= itoa64_to_int (buf
[16]) << 0;
746 l
|= itoa64_to_int (buf
[17]) << 6;
747 l
|= itoa64_to_int (buf
[18]) << 12;
748 l
|= itoa64_to_int (buf
[19]) << 18;
750 digest
[12] = (l
>> 0) & 0xff;
751 digest
[13] = (l
>> 8) & 0xff;
752 digest
[14] = (l
>> 16) & 0xff;
754 l
= itoa64_to_int (buf
[20]) << 0;
755 l
|= itoa64_to_int (buf
[21]) << 6;
757 digest
[15] = (l
>> 0) & 0xff;
760 void phpass_encode (u8 digest
[16], u8 buf
[22])
764 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
766 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
767 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
768 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
769 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
771 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
773 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
774 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
775 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
776 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
778 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
780 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
781 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
782 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
783 buf
[11] = int_to_itoa64 (l
& 0x3f);
785 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
787 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
788 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
789 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
790 buf
[15] = int_to_itoa64 (l
& 0x3f);
792 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
794 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
795 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
796 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
797 buf
[19] = int_to_itoa64 (l
& 0x3f);
799 l
= (digest
[15] << 0);
801 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
802 buf
[21] = int_to_itoa64 (l
& 0x3f);
805 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
809 l
= itoa64_to_int (buf
[ 0]) << 0;
810 l
|= itoa64_to_int (buf
[ 1]) << 6;
811 l
|= itoa64_to_int (buf
[ 2]) << 12;
812 l
|= itoa64_to_int (buf
[ 3]) << 18;
814 digest
[ 0] = (l
>> 16) & 0xff;
815 digest
[ 6] = (l
>> 8) & 0xff;
816 digest
[12] = (l
>> 0) & 0xff;
818 l
= itoa64_to_int (buf
[ 4]) << 0;
819 l
|= itoa64_to_int (buf
[ 5]) << 6;
820 l
|= itoa64_to_int (buf
[ 6]) << 12;
821 l
|= itoa64_to_int (buf
[ 7]) << 18;
823 digest
[ 1] = (l
>> 16) & 0xff;
824 digest
[ 7] = (l
>> 8) & 0xff;
825 digest
[13] = (l
>> 0) & 0xff;
827 l
= itoa64_to_int (buf
[ 8]) << 0;
828 l
|= itoa64_to_int (buf
[ 9]) << 6;
829 l
|= itoa64_to_int (buf
[10]) << 12;
830 l
|= itoa64_to_int (buf
[11]) << 18;
832 digest
[ 2] = (l
>> 16) & 0xff;
833 digest
[ 8] = (l
>> 8) & 0xff;
834 digest
[14] = (l
>> 0) & 0xff;
836 l
= itoa64_to_int (buf
[12]) << 0;
837 l
|= itoa64_to_int (buf
[13]) << 6;
838 l
|= itoa64_to_int (buf
[14]) << 12;
839 l
|= itoa64_to_int (buf
[15]) << 18;
841 digest
[ 3] = (l
>> 16) & 0xff;
842 digest
[ 9] = (l
>> 8) & 0xff;
843 digest
[15] = (l
>> 0) & 0xff;
845 l
= itoa64_to_int (buf
[16]) << 0;
846 l
|= itoa64_to_int (buf
[17]) << 6;
847 l
|= itoa64_to_int (buf
[18]) << 12;
848 l
|= itoa64_to_int (buf
[19]) << 18;
850 digest
[ 4] = (l
>> 16) & 0xff;
851 digest
[10] = (l
>> 8) & 0xff;
852 digest
[ 5] = (l
>> 0) & 0xff;
854 l
= itoa64_to_int (buf
[20]) << 0;
855 l
|= itoa64_to_int (buf
[21]) << 6;
857 digest
[11] = (l
>> 0) & 0xff;
860 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
864 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
866 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
867 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
868 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
869 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
871 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
873 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
874 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
875 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
876 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
880 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
881 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
882 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
883 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
887 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
888 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
889 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
890 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
894 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
895 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
896 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
897 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
899 l
= (digest
[11] << 0);
901 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
902 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
905 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
909 l
= itoa64_to_int (buf
[ 0]) << 0;
910 l
|= itoa64_to_int (buf
[ 1]) << 6;
911 l
|= itoa64_to_int (buf
[ 2]) << 12;
912 l
|= itoa64_to_int (buf
[ 3]) << 18;
914 digest
[ 0] = (l
>> 16) & 0xff;
915 digest
[21] = (l
>> 8) & 0xff;
916 digest
[42] = (l
>> 0) & 0xff;
918 l
= itoa64_to_int (buf
[ 4]) << 0;
919 l
|= itoa64_to_int (buf
[ 5]) << 6;
920 l
|= itoa64_to_int (buf
[ 6]) << 12;
921 l
|= itoa64_to_int (buf
[ 7]) << 18;
923 digest
[22] = (l
>> 16) & 0xff;
924 digest
[43] = (l
>> 8) & 0xff;
925 digest
[ 1] = (l
>> 0) & 0xff;
927 l
= itoa64_to_int (buf
[ 8]) << 0;
928 l
|= itoa64_to_int (buf
[ 9]) << 6;
929 l
|= itoa64_to_int (buf
[10]) << 12;
930 l
|= itoa64_to_int (buf
[11]) << 18;
932 digest
[44] = (l
>> 16) & 0xff;
933 digest
[ 2] = (l
>> 8) & 0xff;
934 digest
[23] = (l
>> 0) & 0xff;
936 l
= itoa64_to_int (buf
[12]) << 0;
937 l
|= itoa64_to_int (buf
[13]) << 6;
938 l
|= itoa64_to_int (buf
[14]) << 12;
939 l
|= itoa64_to_int (buf
[15]) << 18;
941 digest
[ 3] = (l
>> 16) & 0xff;
942 digest
[24] = (l
>> 8) & 0xff;
943 digest
[45] = (l
>> 0) & 0xff;
945 l
= itoa64_to_int (buf
[16]) << 0;
946 l
|= itoa64_to_int (buf
[17]) << 6;
947 l
|= itoa64_to_int (buf
[18]) << 12;
948 l
|= itoa64_to_int (buf
[19]) << 18;
950 digest
[25] = (l
>> 16) & 0xff;
951 digest
[46] = (l
>> 8) & 0xff;
952 digest
[ 4] = (l
>> 0) & 0xff;
954 l
= itoa64_to_int (buf
[20]) << 0;
955 l
|= itoa64_to_int (buf
[21]) << 6;
956 l
|= itoa64_to_int (buf
[22]) << 12;
957 l
|= itoa64_to_int (buf
[23]) << 18;
959 digest
[47] = (l
>> 16) & 0xff;
960 digest
[ 5] = (l
>> 8) & 0xff;
961 digest
[26] = (l
>> 0) & 0xff;
963 l
= itoa64_to_int (buf
[24]) << 0;
964 l
|= itoa64_to_int (buf
[25]) << 6;
965 l
|= itoa64_to_int (buf
[26]) << 12;
966 l
|= itoa64_to_int (buf
[27]) << 18;
968 digest
[ 6] = (l
>> 16) & 0xff;
969 digest
[27] = (l
>> 8) & 0xff;
970 digest
[48] = (l
>> 0) & 0xff;
972 l
= itoa64_to_int (buf
[28]) << 0;
973 l
|= itoa64_to_int (buf
[29]) << 6;
974 l
|= itoa64_to_int (buf
[30]) << 12;
975 l
|= itoa64_to_int (buf
[31]) << 18;
977 digest
[28] = (l
>> 16) & 0xff;
978 digest
[49] = (l
>> 8) & 0xff;
979 digest
[ 7] = (l
>> 0) & 0xff;
981 l
= itoa64_to_int (buf
[32]) << 0;
982 l
|= itoa64_to_int (buf
[33]) << 6;
983 l
|= itoa64_to_int (buf
[34]) << 12;
984 l
|= itoa64_to_int (buf
[35]) << 18;
986 digest
[50] = (l
>> 16) & 0xff;
987 digest
[ 8] = (l
>> 8) & 0xff;
988 digest
[29] = (l
>> 0) & 0xff;
990 l
= itoa64_to_int (buf
[36]) << 0;
991 l
|= itoa64_to_int (buf
[37]) << 6;
992 l
|= itoa64_to_int (buf
[38]) << 12;
993 l
|= itoa64_to_int (buf
[39]) << 18;
995 digest
[ 9] = (l
>> 16) & 0xff;
996 digest
[30] = (l
>> 8) & 0xff;
997 digest
[51] = (l
>> 0) & 0xff;
999 l
= itoa64_to_int (buf
[40]) << 0;
1000 l
|= itoa64_to_int (buf
[41]) << 6;
1001 l
|= itoa64_to_int (buf
[42]) << 12;
1002 l
|= itoa64_to_int (buf
[43]) << 18;
1004 digest
[31] = (l
>> 16) & 0xff;
1005 digest
[52] = (l
>> 8) & 0xff;
1006 digest
[10] = (l
>> 0) & 0xff;
1008 l
= itoa64_to_int (buf
[44]) << 0;
1009 l
|= itoa64_to_int (buf
[45]) << 6;
1010 l
|= itoa64_to_int (buf
[46]) << 12;
1011 l
|= itoa64_to_int (buf
[47]) << 18;
1013 digest
[53] = (l
>> 16) & 0xff;
1014 digest
[11] = (l
>> 8) & 0xff;
1015 digest
[32] = (l
>> 0) & 0xff;
1017 l
= itoa64_to_int (buf
[48]) << 0;
1018 l
|= itoa64_to_int (buf
[49]) << 6;
1019 l
|= itoa64_to_int (buf
[50]) << 12;
1020 l
|= itoa64_to_int (buf
[51]) << 18;
1022 digest
[12] = (l
>> 16) & 0xff;
1023 digest
[33] = (l
>> 8) & 0xff;
1024 digest
[54] = (l
>> 0) & 0xff;
1026 l
= itoa64_to_int (buf
[52]) << 0;
1027 l
|= itoa64_to_int (buf
[53]) << 6;
1028 l
|= itoa64_to_int (buf
[54]) << 12;
1029 l
|= itoa64_to_int (buf
[55]) << 18;
1031 digest
[34] = (l
>> 16) & 0xff;
1032 digest
[55] = (l
>> 8) & 0xff;
1033 digest
[13] = (l
>> 0) & 0xff;
1035 l
= itoa64_to_int (buf
[56]) << 0;
1036 l
|= itoa64_to_int (buf
[57]) << 6;
1037 l
|= itoa64_to_int (buf
[58]) << 12;
1038 l
|= itoa64_to_int (buf
[59]) << 18;
1040 digest
[56] = (l
>> 16) & 0xff;
1041 digest
[14] = (l
>> 8) & 0xff;
1042 digest
[35] = (l
>> 0) & 0xff;
1044 l
= itoa64_to_int (buf
[60]) << 0;
1045 l
|= itoa64_to_int (buf
[61]) << 6;
1046 l
|= itoa64_to_int (buf
[62]) << 12;
1047 l
|= itoa64_to_int (buf
[63]) << 18;
1049 digest
[15] = (l
>> 16) & 0xff;
1050 digest
[36] = (l
>> 8) & 0xff;
1051 digest
[57] = (l
>> 0) & 0xff;
1053 l
= itoa64_to_int (buf
[64]) << 0;
1054 l
|= itoa64_to_int (buf
[65]) << 6;
1055 l
|= itoa64_to_int (buf
[66]) << 12;
1056 l
|= itoa64_to_int (buf
[67]) << 18;
1058 digest
[37] = (l
>> 16) & 0xff;
1059 digest
[58] = (l
>> 8) & 0xff;
1060 digest
[16] = (l
>> 0) & 0xff;
1062 l
= itoa64_to_int (buf
[68]) << 0;
1063 l
|= itoa64_to_int (buf
[69]) << 6;
1064 l
|= itoa64_to_int (buf
[70]) << 12;
1065 l
|= itoa64_to_int (buf
[71]) << 18;
1067 digest
[59] = (l
>> 16) & 0xff;
1068 digest
[17] = (l
>> 8) & 0xff;
1069 digest
[38] = (l
>> 0) & 0xff;
1071 l
= itoa64_to_int (buf
[72]) << 0;
1072 l
|= itoa64_to_int (buf
[73]) << 6;
1073 l
|= itoa64_to_int (buf
[74]) << 12;
1074 l
|= itoa64_to_int (buf
[75]) << 18;
1076 digest
[18] = (l
>> 16) & 0xff;
1077 digest
[39] = (l
>> 8) & 0xff;
1078 digest
[60] = (l
>> 0) & 0xff;
1080 l
= itoa64_to_int (buf
[76]) << 0;
1081 l
|= itoa64_to_int (buf
[77]) << 6;
1082 l
|= itoa64_to_int (buf
[78]) << 12;
1083 l
|= itoa64_to_int (buf
[79]) << 18;
1085 digest
[40] = (l
>> 16) & 0xff;
1086 digest
[61] = (l
>> 8) & 0xff;
1087 digest
[19] = (l
>> 0) & 0xff;
1089 l
= itoa64_to_int (buf
[80]) << 0;
1090 l
|= itoa64_to_int (buf
[81]) << 6;
1091 l
|= itoa64_to_int (buf
[82]) << 12;
1092 l
|= itoa64_to_int (buf
[83]) << 18;
1094 digest
[62] = (l
>> 16) & 0xff;
1095 digest
[20] = (l
>> 8) & 0xff;
1096 digest
[41] = (l
>> 0) & 0xff;
1098 l
= itoa64_to_int (buf
[84]) << 0;
1099 l
|= itoa64_to_int (buf
[85]) << 6;
1101 digest
[63] = (l
>> 0) & 0xff;
1104 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1108 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1110 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1111 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1112 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1113 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1115 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1117 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1118 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1119 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1120 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1124 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1125 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1126 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1127 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1131 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1132 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1133 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1134 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1138 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1139 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1140 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1141 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1145 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1146 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1147 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1148 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1152 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1153 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1154 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1155 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1159 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1160 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1161 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1162 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1166 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1167 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1168 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1169 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1173 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1174 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1175 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1176 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1180 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1181 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1182 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1183 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1187 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1188 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1189 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1190 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1194 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1195 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1196 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1197 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1201 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1202 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1203 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1204 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1208 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1209 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1210 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1211 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1215 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1216 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1217 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1218 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1222 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1223 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1224 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1225 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1229 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1230 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1231 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1232 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1236 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1237 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1238 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1239 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1243 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1244 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1245 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1246 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1250 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1251 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1252 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1253 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1255 l
= 0 | 0 | (digest
[63] << 0);
1257 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1258 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1261 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1265 l
= itoa64_to_int (buf
[ 0]) << 0;
1266 l
|= itoa64_to_int (buf
[ 1]) << 6;
1267 l
|= itoa64_to_int (buf
[ 2]) << 12;
1268 l
|= itoa64_to_int (buf
[ 3]) << 18;
1270 digest
[ 2] = (l
>> 0) & 0xff;
1271 digest
[ 1] = (l
>> 8) & 0xff;
1272 digest
[ 0] = (l
>> 16) & 0xff;
1274 l
= itoa64_to_int (buf
[ 4]) << 0;
1275 l
|= itoa64_to_int (buf
[ 5]) << 6;
1276 l
|= itoa64_to_int (buf
[ 6]) << 12;
1277 l
|= itoa64_to_int (buf
[ 7]) << 18;
1279 digest
[ 5] = (l
>> 0) & 0xff;
1280 digest
[ 4] = (l
>> 8) & 0xff;
1281 digest
[ 3] = (l
>> 16) & 0xff;
1283 l
= itoa64_to_int (buf
[ 8]) << 0;
1284 l
|= itoa64_to_int (buf
[ 9]) << 6;
1285 l
|= itoa64_to_int (buf
[10]) << 12;
1286 l
|= itoa64_to_int (buf
[11]) << 18;
1288 digest
[ 8] = (l
>> 0) & 0xff;
1289 digest
[ 7] = (l
>> 8) & 0xff;
1290 digest
[ 6] = (l
>> 16) & 0xff;
1292 l
= itoa64_to_int (buf
[12]) << 0;
1293 l
|= itoa64_to_int (buf
[13]) << 6;
1294 l
|= itoa64_to_int (buf
[14]) << 12;
1295 l
|= itoa64_to_int (buf
[15]) << 18;
1297 digest
[11] = (l
>> 0) & 0xff;
1298 digest
[10] = (l
>> 8) & 0xff;
1299 digest
[ 9] = (l
>> 16) & 0xff;
1301 l
= itoa64_to_int (buf
[16]) << 0;
1302 l
|= itoa64_to_int (buf
[17]) << 6;
1303 l
|= itoa64_to_int (buf
[18]) << 12;
1304 l
|= itoa64_to_int (buf
[19]) << 18;
1306 digest
[14] = (l
>> 0) & 0xff;
1307 digest
[13] = (l
>> 8) & 0xff;
1308 digest
[12] = (l
>> 16) & 0xff;
1310 l
= itoa64_to_int (buf
[20]) << 0;
1311 l
|= itoa64_to_int (buf
[21]) << 6;
1312 l
|= itoa64_to_int (buf
[22]) << 12;
1313 l
|= itoa64_to_int (buf
[23]) << 18;
1315 digest
[17] = (l
>> 0) & 0xff;
1316 digest
[16] = (l
>> 8) & 0xff;
1317 digest
[15] = (l
>> 16) & 0xff;
1319 l
= itoa64_to_int (buf
[24]) << 0;
1320 l
|= itoa64_to_int (buf
[25]) << 6;
1321 l
|= itoa64_to_int (buf
[26]) << 12;
1323 digest
[19] = (l
>> 8) & 0xff;
1324 digest
[18] = (l
>> 16) & 0xff;
1327 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1331 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1333 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1334 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1335 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1336 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1338 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1340 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1341 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1342 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1343 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1345 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1347 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1348 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1349 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1350 buf
[11] = int_to_itoa64 (l
& 0x3f);
1352 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1354 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1355 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1356 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1357 buf
[15] = int_to_itoa64 (l
& 0x3f);
1359 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1361 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1362 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1363 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1364 buf
[19] = int_to_itoa64 (l
& 0x3f);
1366 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1368 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1369 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1370 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1371 buf
[23] = int_to_itoa64 (l
& 0x3f);
1373 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1375 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1376 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1377 buf
[26] = int_to_itoa64 (l
& 0x3f);
1380 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1384 l
= itoa64_to_int (buf
[ 0]) << 0;
1385 l
|= itoa64_to_int (buf
[ 1]) << 6;
1386 l
|= itoa64_to_int (buf
[ 2]) << 12;
1387 l
|= itoa64_to_int (buf
[ 3]) << 18;
1389 digest
[ 2] = (l
>> 0) & 0xff;
1390 digest
[ 1] = (l
>> 8) & 0xff;
1391 digest
[ 0] = (l
>> 16) & 0xff;
1393 l
= itoa64_to_int (buf
[ 4]) << 0;
1394 l
|= itoa64_to_int (buf
[ 5]) << 6;
1395 l
|= itoa64_to_int (buf
[ 6]) << 12;
1396 l
|= itoa64_to_int (buf
[ 7]) << 18;
1398 digest
[ 5] = (l
>> 0) & 0xff;
1399 digest
[ 4] = (l
>> 8) & 0xff;
1400 digest
[ 3] = (l
>> 16) & 0xff;
1402 l
= itoa64_to_int (buf
[ 8]) << 0;
1403 l
|= itoa64_to_int (buf
[ 9]) << 6;
1404 l
|= itoa64_to_int (buf
[10]) << 12;
1405 l
|= itoa64_to_int (buf
[11]) << 18;
1407 digest
[ 8] = (l
>> 0) & 0xff;
1408 digest
[ 7] = (l
>> 8) & 0xff;
1409 digest
[ 6] = (l
>> 16) & 0xff;
1411 l
= itoa64_to_int (buf
[12]) << 0;
1412 l
|= itoa64_to_int (buf
[13]) << 6;
1413 l
|= itoa64_to_int (buf
[14]) << 12;
1414 l
|= itoa64_to_int (buf
[15]) << 18;
1416 digest
[11] = (l
>> 0) & 0xff;
1417 digest
[10] = (l
>> 8) & 0xff;
1418 digest
[ 9] = (l
>> 16) & 0xff;
1420 l
= itoa64_to_int (buf
[16]) << 0;
1421 l
|= itoa64_to_int (buf
[17]) << 6;
1422 l
|= itoa64_to_int (buf
[18]) << 12;
1423 l
|= itoa64_to_int (buf
[19]) << 18;
1425 digest
[14] = (l
>> 0) & 0xff;
1426 digest
[13] = (l
>> 8) & 0xff;
1427 digest
[12] = (l
>> 16) & 0xff;
1429 l
= itoa64_to_int (buf
[20]) << 0;
1430 l
|= itoa64_to_int (buf
[21]) << 6;
1431 l
|= itoa64_to_int (buf
[22]) << 12;
1432 l
|= itoa64_to_int (buf
[23]) << 18;
1434 digest
[17] = (l
>> 0) & 0xff;
1435 digest
[16] = (l
>> 8) & 0xff;
1436 digest
[15] = (l
>> 16) & 0xff;
1438 l
= itoa64_to_int (buf
[24]) << 0;
1439 l
|= itoa64_to_int (buf
[25]) << 6;
1440 l
|= itoa64_to_int (buf
[26]) << 12;
1441 l
|= itoa64_to_int (buf
[27]) << 18;
1443 digest
[20] = (l
>> 0) & 0xff;
1444 digest
[19] = (l
>> 8) & 0xff;
1445 digest
[18] = (l
>> 16) & 0xff;
1447 l
= itoa64_to_int (buf
[28]) << 0;
1448 l
|= itoa64_to_int (buf
[29]) << 6;
1449 l
|= itoa64_to_int (buf
[30]) << 12;
1450 l
|= itoa64_to_int (buf
[31]) << 18;
1452 digest
[23] = (l
>> 0) & 0xff;
1453 digest
[22] = (l
>> 8) & 0xff;
1454 digest
[21] = (l
>> 16) & 0xff;
1456 l
= itoa64_to_int (buf
[32]) << 0;
1457 l
|= itoa64_to_int (buf
[33]) << 6;
1458 l
|= itoa64_to_int (buf
[34]) << 12;
1459 l
|= itoa64_to_int (buf
[35]) << 18;
1461 digest
[26] = (l
>> 0) & 0xff;
1462 digest
[25] = (l
>> 8) & 0xff;
1463 digest
[24] = (l
>> 16) & 0xff;
1465 l
= itoa64_to_int (buf
[36]) << 0;
1466 l
|= itoa64_to_int (buf
[37]) << 6;
1467 l
|= itoa64_to_int (buf
[38]) << 12;
1468 l
|= itoa64_to_int (buf
[39]) << 18;
1470 digest
[29] = (l
>> 0) & 0xff;
1471 digest
[28] = (l
>> 8) & 0xff;
1472 digest
[27] = (l
>> 16) & 0xff;
1474 l
= itoa64_to_int (buf
[40]) << 0;
1475 l
|= itoa64_to_int (buf
[41]) << 6;
1476 l
|= itoa64_to_int (buf
[42]) << 12;
1478 //digest[32] = (l >> 0) & 0xff;
1479 digest
[31] = (l
>> 8) & 0xff;
1480 digest
[30] = (l
>> 16) & 0xff;
1483 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1487 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1489 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1490 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1491 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1492 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1494 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1496 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1497 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1498 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1499 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1501 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1503 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1504 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1505 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1506 buf
[11] = int_to_itoa64 (l
& 0x3f);
1508 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1510 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1511 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1512 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1513 buf
[15] = int_to_itoa64 (l
& 0x3f);
1515 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1517 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1518 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1519 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1520 buf
[19] = int_to_itoa64 (l
& 0x3f);
1522 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1524 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1525 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1526 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1527 buf
[23] = int_to_itoa64 (l
& 0x3f);
1529 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1531 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1532 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1533 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1534 buf
[27] = int_to_itoa64 (l
& 0x3f);
1536 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1538 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1539 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1540 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1541 buf
[31] = int_to_itoa64 (l
& 0x3f);
1543 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1545 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1546 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1547 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1548 buf
[35] = int_to_itoa64 (l
& 0x3f);
1550 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1552 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1553 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1554 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1555 buf
[39] = int_to_itoa64 (l
& 0x3f);
1557 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1559 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1560 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1561 buf
[42] = int_to_itoa64 (l
& 0x3f);
1564 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1568 l
= itoa64_to_int (buf
[ 0]) << 0;
1569 l
|= itoa64_to_int (buf
[ 1]) << 6;
1570 l
|= itoa64_to_int (buf
[ 2]) << 12;
1571 l
|= itoa64_to_int (buf
[ 3]) << 18;
1573 digest
[ 2] = (l
>> 0) & 0xff;
1574 digest
[ 1] = (l
>> 8) & 0xff;
1575 digest
[ 0] = (l
>> 16) & 0xff;
1577 l
= itoa64_to_int (buf
[ 4]) << 0;
1578 l
|= itoa64_to_int (buf
[ 5]) << 6;
1579 l
|= itoa64_to_int (buf
[ 6]) << 12;
1580 l
|= itoa64_to_int (buf
[ 7]) << 18;
1582 digest
[ 5] = (l
>> 0) & 0xff;
1583 digest
[ 4] = (l
>> 8) & 0xff;
1584 digest
[ 3] = (l
>> 16) & 0xff;
1586 l
= itoa64_to_int (buf
[ 8]) << 0;
1587 l
|= itoa64_to_int (buf
[ 9]) << 6;
1588 l
|= itoa64_to_int (buf
[10]) << 12;
1589 l
|= itoa64_to_int (buf
[11]) << 18;
1591 digest
[ 8] = (l
>> 0) & 0xff;
1592 digest
[ 7] = (l
>> 8) & 0xff;
1593 digest
[ 6] = (l
>> 16) & 0xff;
1595 l
= itoa64_to_int (buf
[12]) << 0;
1596 l
|= itoa64_to_int (buf
[13]) << 6;
1597 l
|= itoa64_to_int (buf
[14]) << 12;
1598 l
|= itoa64_to_int (buf
[15]) << 18;
1600 digest
[11] = (l
>> 0) & 0xff;
1601 digest
[10] = (l
>> 8) & 0xff;
1602 digest
[ 9] = (l
>> 16) & 0xff;
1604 l
= itoa64_to_int (buf
[16]) << 0;
1605 l
|= itoa64_to_int (buf
[17]) << 6;
1606 l
|= itoa64_to_int (buf
[18]) << 12;
1607 l
|= itoa64_to_int (buf
[19]) << 18;
1609 digest
[14] = (l
>> 0) & 0xff;
1610 digest
[13] = (l
>> 8) & 0xff;
1611 digest
[12] = (l
>> 16) & 0xff;
1613 l
= itoa64_to_int (buf
[20]) << 0;
1614 l
|= itoa64_to_int (buf
[21]) << 6;
1615 l
|= itoa64_to_int (buf
[22]) << 12;
1616 l
|= itoa64_to_int (buf
[23]) << 18;
1618 digest
[17] = (l
>> 0) & 0xff;
1619 digest
[16] = (l
>> 8) & 0xff;
1620 digest
[15] = (l
>> 16) & 0xff;
1622 l
= itoa64_to_int (buf
[24]) << 0;
1623 l
|= itoa64_to_int (buf
[25]) << 6;
1624 l
|= itoa64_to_int (buf
[26]) << 12;
1625 l
|= itoa64_to_int (buf
[27]) << 18;
1627 digest
[20] = (l
>> 0) & 0xff;
1628 digest
[19] = (l
>> 8) & 0xff;
1629 digest
[18] = (l
>> 16) & 0xff;
1631 l
= itoa64_to_int (buf
[28]) << 0;
1632 l
|= itoa64_to_int (buf
[29]) << 6;
1633 l
|= itoa64_to_int (buf
[30]) << 12;
1634 l
|= itoa64_to_int (buf
[31]) << 18;
1636 digest
[23] = (l
>> 0) & 0xff;
1637 digest
[22] = (l
>> 8) & 0xff;
1638 digest
[21] = (l
>> 16) & 0xff;
1640 l
= itoa64_to_int (buf
[32]) << 0;
1641 l
|= itoa64_to_int (buf
[33]) << 6;
1642 l
|= itoa64_to_int (buf
[34]) << 12;
1643 l
|= itoa64_to_int (buf
[35]) << 18;
1645 digest
[26] = (l
>> 0) & 0xff;
1646 digest
[25] = (l
>> 8) & 0xff;
1647 digest
[24] = (l
>> 16) & 0xff;
1649 l
= itoa64_to_int (buf
[36]) << 0;
1650 l
|= itoa64_to_int (buf
[37]) << 6;
1651 l
|= itoa64_to_int (buf
[38]) << 12;
1652 l
|= itoa64_to_int (buf
[39]) << 18;
1654 digest
[29] = (l
>> 0) & 0xff;
1655 digest
[28] = (l
>> 8) & 0xff;
1656 digest
[27] = (l
>> 16) & 0xff;
1658 l
= itoa64_to_int (buf
[40]) << 0;
1659 l
|= itoa64_to_int (buf
[41]) << 6;
1660 l
|= itoa64_to_int (buf
[42]) << 12;
1661 l
|= itoa64_to_int (buf
[43]) << 18;
1663 digest
[32] = (l
>> 0) & 0xff;
1664 digest
[31] = (l
>> 8) & 0xff;
1665 digest
[30] = (l
>> 16) & 0xff;
1667 l
= itoa64_to_int (buf
[44]) << 0;
1668 l
|= itoa64_to_int (buf
[45]) << 6;
1669 l
|= itoa64_to_int (buf
[46]) << 12;
1670 l
|= itoa64_to_int (buf
[47]) << 18;
1672 digest
[35] = (l
>> 0) & 0xff;
1673 digest
[34] = (l
>> 8) & 0xff;
1674 digest
[33] = (l
>> 16) & 0xff;
1676 l
= itoa64_to_int (buf
[48]) << 0;
1677 l
|= itoa64_to_int (buf
[49]) << 6;
1678 l
|= itoa64_to_int (buf
[50]) << 12;
1679 l
|= itoa64_to_int (buf
[51]) << 18;
1681 digest
[38] = (l
>> 0) & 0xff;
1682 digest
[37] = (l
>> 8) & 0xff;
1683 digest
[36] = (l
>> 16) & 0xff;
1685 l
= itoa64_to_int (buf
[52]) << 0;
1686 l
|= itoa64_to_int (buf
[53]) << 6;
1687 l
|= itoa64_to_int (buf
[54]) << 12;
1688 l
|= itoa64_to_int (buf
[55]) << 18;
1690 digest
[41] = (l
>> 0) & 0xff;
1691 digest
[40] = (l
>> 8) & 0xff;
1692 digest
[39] = (l
>> 16) & 0xff;
1694 l
= itoa64_to_int (buf
[56]) << 0;
1695 l
|= itoa64_to_int (buf
[57]) << 6;
1696 l
|= itoa64_to_int (buf
[58]) << 12;
1697 l
|= itoa64_to_int (buf
[59]) << 18;
1699 digest
[44] = (l
>> 0) & 0xff;
1700 digest
[43] = (l
>> 8) & 0xff;
1701 digest
[42] = (l
>> 16) & 0xff;
1703 l
= itoa64_to_int (buf
[60]) << 0;
1704 l
|= itoa64_to_int (buf
[61]) << 6;
1705 l
|= itoa64_to_int (buf
[62]) << 12;
1706 l
|= itoa64_to_int (buf
[63]) << 18;
1708 digest
[47] = (l
>> 0) & 0xff;
1709 digest
[46] = (l
>> 8) & 0xff;
1710 digest
[45] = (l
>> 16) & 0xff;
1712 l
= itoa64_to_int (buf
[64]) << 0;
1713 l
|= itoa64_to_int (buf
[65]) << 6;
1714 l
|= itoa64_to_int (buf
[66]) << 12;
1715 l
|= itoa64_to_int (buf
[67]) << 18;
1717 digest
[50] = (l
>> 0) & 0xff;
1718 digest
[49] = (l
>> 8) & 0xff;
1719 digest
[48] = (l
>> 16) & 0xff;
1721 l
= itoa64_to_int (buf
[68]) << 0;
1722 l
|= itoa64_to_int (buf
[69]) << 6;
1723 l
|= itoa64_to_int (buf
[70]) << 12;
1724 l
|= itoa64_to_int (buf
[71]) << 18;
1726 digest
[53] = (l
>> 0) & 0xff;
1727 digest
[52] = (l
>> 8) & 0xff;
1728 digest
[51] = (l
>> 16) & 0xff;
1730 l
= itoa64_to_int (buf
[72]) << 0;
1731 l
|= itoa64_to_int (buf
[73]) << 6;
1732 l
|= itoa64_to_int (buf
[74]) << 12;
1733 l
|= itoa64_to_int (buf
[75]) << 18;
1735 digest
[56] = (l
>> 0) & 0xff;
1736 digest
[55] = (l
>> 8) & 0xff;
1737 digest
[54] = (l
>> 16) & 0xff;
1739 l
= itoa64_to_int (buf
[76]) << 0;
1740 l
|= itoa64_to_int (buf
[77]) << 6;
1741 l
|= itoa64_to_int (buf
[78]) << 12;
1742 l
|= itoa64_to_int (buf
[79]) << 18;
1744 digest
[59] = (l
>> 0) & 0xff;
1745 digest
[58] = (l
>> 8) & 0xff;
1746 digest
[57] = (l
>> 16) & 0xff;
1748 l
= itoa64_to_int (buf
[80]) << 0;
1749 l
|= itoa64_to_int (buf
[81]) << 6;
1750 l
|= itoa64_to_int (buf
[82]) << 12;
1751 l
|= itoa64_to_int (buf
[83]) << 18;
1753 digest
[62] = (l
>> 0) & 0xff;
1754 digest
[61] = (l
>> 8) & 0xff;
1755 digest
[60] = (l
>> 16) & 0xff;
1757 l
= itoa64_to_int (buf
[84]) << 0;
1758 l
|= itoa64_to_int (buf
[85]) << 6;
1760 digest
[63] = (l
>> 16) & 0xff;
1763 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1767 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1769 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1770 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1771 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1772 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1774 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1776 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1777 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1778 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1779 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1781 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1783 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1784 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1785 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1786 buf
[11] = int_to_itoa64 (l
& 0x3f);
1788 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1790 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1791 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1792 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1793 buf
[15] = int_to_itoa64 (l
& 0x3f);
1795 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1797 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1798 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1799 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1800 buf
[19] = int_to_itoa64 (l
& 0x3f);
1802 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1804 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1805 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1806 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1807 buf
[23] = int_to_itoa64 (l
& 0x3f);
1809 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1811 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1812 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1813 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1814 buf
[27] = int_to_itoa64 (l
& 0x3f);
1816 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1818 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1819 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1820 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1821 buf
[31] = int_to_itoa64 (l
& 0x3f);
1823 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1825 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1826 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1827 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1828 buf
[35] = int_to_itoa64 (l
& 0x3f);
1830 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1832 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1833 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1834 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1835 buf
[39] = int_to_itoa64 (l
& 0x3f);
1837 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1839 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1840 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1841 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1842 buf
[43] = int_to_itoa64 (l
& 0x3f);
1844 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1846 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1847 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1848 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1849 buf
[47] = int_to_itoa64 (l
& 0x3f);
1851 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1853 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1854 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1855 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1856 buf
[51] = int_to_itoa64 (l
& 0x3f);
1858 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1860 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1861 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1862 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1863 buf
[55] = int_to_itoa64 (l
& 0x3f);
1865 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1867 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1868 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1869 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1870 buf
[59] = int_to_itoa64 (l
& 0x3f);
1872 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1874 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1875 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1876 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1877 buf
[63] = int_to_itoa64 (l
& 0x3f);
1879 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1881 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1882 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1883 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1884 buf
[67] = int_to_itoa64 (l
& 0x3f);
1886 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1888 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1889 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1890 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1891 buf
[71] = int_to_itoa64 (l
& 0x3f);
1893 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1895 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1896 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1897 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1898 buf
[75] = int_to_itoa64 (l
& 0x3f);
1900 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1902 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1903 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1904 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1905 buf
[79] = int_to_itoa64 (l
& 0x3f);
1907 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1909 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1910 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1911 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1912 buf
[83] = int_to_itoa64 (l
& 0x3f);
1914 l
= 0 | 0 | (digest
[63] << 16);
1916 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1917 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1920 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1924 l
= itoa64_to_int (buf
[ 0]) << 0;
1925 l
|= itoa64_to_int (buf
[ 1]) << 6;
1926 l
|= itoa64_to_int (buf
[ 2]) << 12;
1927 l
|= itoa64_to_int (buf
[ 3]) << 18;
1929 digest
[ 0] = (l
>> 16) & 0xff;
1930 digest
[10] = (l
>> 8) & 0xff;
1931 digest
[20] = (l
>> 0) & 0xff;
1933 l
= itoa64_to_int (buf
[ 4]) << 0;
1934 l
|= itoa64_to_int (buf
[ 5]) << 6;
1935 l
|= itoa64_to_int (buf
[ 6]) << 12;
1936 l
|= itoa64_to_int (buf
[ 7]) << 18;
1938 digest
[21] = (l
>> 16) & 0xff;
1939 digest
[ 1] = (l
>> 8) & 0xff;
1940 digest
[11] = (l
>> 0) & 0xff;
1942 l
= itoa64_to_int (buf
[ 8]) << 0;
1943 l
|= itoa64_to_int (buf
[ 9]) << 6;
1944 l
|= itoa64_to_int (buf
[10]) << 12;
1945 l
|= itoa64_to_int (buf
[11]) << 18;
1947 digest
[12] = (l
>> 16) & 0xff;
1948 digest
[22] = (l
>> 8) & 0xff;
1949 digest
[ 2] = (l
>> 0) & 0xff;
1951 l
= itoa64_to_int (buf
[12]) << 0;
1952 l
|= itoa64_to_int (buf
[13]) << 6;
1953 l
|= itoa64_to_int (buf
[14]) << 12;
1954 l
|= itoa64_to_int (buf
[15]) << 18;
1956 digest
[ 3] = (l
>> 16) & 0xff;
1957 digest
[13] = (l
>> 8) & 0xff;
1958 digest
[23] = (l
>> 0) & 0xff;
1960 l
= itoa64_to_int (buf
[16]) << 0;
1961 l
|= itoa64_to_int (buf
[17]) << 6;
1962 l
|= itoa64_to_int (buf
[18]) << 12;
1963 l
|= itoa64_to_int (buf
[19]) << 18;
1965 digest
[24] = (l
>> 16) & 0xff;
1966 digest
[ 4] = (l
>> 8) & 0xff;
1967 digest
[14] = (l
>> 0) & 0xff;
1969 l
= itoa64_to_int (buf
[20]) << 0;
1970 l
|= itoa64_to_int (buf
[21]) << 6;
1971 l
|= itoa64_to_int (buf
[22]) << 12;
1972 l
|= itoa64_to_int (buf
[23]) << 18;
1974 digest
[15] = (l
>> 16) & 0xff;
1975 digest
[25] = (l
>> 8) & 0xff;
1976 digest
[ 5] = (l
>> 0) & 0xff;
1978 l
= itoa64_to_int (buf
[24]) << 0;
1979 l
|= itoa64_to_int (buf
[25]) << 6;
1980 l
|= itoa64_to_int (buf
[26]) << 12;
1981 l
|= itoa64_to_int (buf
[27]) << 18;
1983 digest
[ 6] = (l
>> 16) & 0xff;
1984 digest
[16] = (l
>> 8) & 0xff;
1985 digest
[26] = (l
>> 0) & 0xff;
1987 l
= itoa64_to_int (buf
[28]) << 0;
1988 l
|= itoa64_to_int (buf
[29]) << 6;
1989 l
|= itoa64_to_int (buf
[30]) << 12;
1990 l
|= itoa64_to_int (buf
[31]) << 18;
1992 digest
[27] = (l
>> 16) & 0xff;
1993 digest
[ 7] = (l
>> 8) & 0xff;
1994 digest
[17] = (l
>> 0) & 0xff;
1996 l
= itoa64_to_int (buf
[32]) << 0;
1997 l
|= itoa64_to_int (buf
[33]) << 6;
1998 l
|= itoa64_to_int (buf
[34]) << 12;
1999 l
|= itoa64_to_int (buf
[35]) << 18;
2001 digest
[18] = (l
>> 16) & 0xff;
2002 digest
[28] = (l
>> 8) & 0xff;
2003 digest
[ 8] = (l
>> 0) & 0xff;
2005 l
= itoa64_to_int (buf
[36]) << 0;
2006 l
|= itoa64_to_int (buf
[37]) << 6;
2007 l
|= itoa64_to_int (buf
[38]) << 12;
2008 l
|= itoa64_to_int (buf
[39]) << 18;
2010 digest
[ 9] = (l
>> 16) & 0xff;
2011 digest
[19] = (l
>> 8) & 0xff;
2012 digest
[29] = (l
>> 0) & 0xff;
2014 l
= itoa64_to_int (buf
[40]) << 0;
2015 l
|= itoa64_to_int (buf
[41]) << 6;
2016 l
|= itoa64_to_int (buf
[42]) << 12;
2018 digest
[31] = (l
>> 8) & 0xff;
2019 digest
[30] = (l
>> 0) & 0xff;
2022 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2026 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2028 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2029 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2030 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2031 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2033 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2035 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2036 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2037 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2038 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2042 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2043 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2044 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2045 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2049 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2050 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2051 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2052 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2056 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2057 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2058 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2059 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2063 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2064 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2065 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2066 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2070 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2071 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2072 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2073 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2077 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2078 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2079 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2080 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2084 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2085 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2086 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2087 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2091 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2092 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2093 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2094 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2096 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2098 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2099 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2100 buf
[42] = int_to_itoa64 (l
& 0x3f);
2103 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2107 l
= itoa64_to_int (buf
[ 0]) << 0;
2108 l
|= itoa64_to_int (buf
[ 1]) << 6;
2109 l
|= itoa64_to_int (buf
[ 2]) << 12;
2110 l
|= itoa64_to_int (buf
[ 3]) << 18;
2112 digest
[ 0] = (l
>> 0) & 0xff;
2113 digest
[ 1] = (l
>> 8) & 0xff;
2114 digest
[ 2] = (l
>> 16) & 0xff;
2116 l
= itoa64_to_int (buf
[ 4]) << 0;
2117 l
|= itoa64_to_int (buf
[ 5]) << 6;
2118 l
|= itoa64_to_int (buf
[ 6]) << 12;
2119 l
|= itoa64_to_int (buf
[ 7]) << 18;
2121 digest
[ 3] = (l
>> 0) & 0xff;
2122 digest
[ 4] = (l
>> 8) & 0xff;
2123 digest
[ 5] = (l
>> 16) & 0xff;
2125 l
= itoa64_to_int (buf
[ 8]) << 0;
2126 l
|= itoa64_to_int (buf
[ 9]) << 6;
2127 l
|= itoa64_to_int (buf
[10]) << 12;
2128 l
|= itoa64_to_int (buf
[11]) << 18;
2130 digest
[ 6] = (l
>> 0) & 0xff;
2131 digest
[ 7] = (l
>> 8) & 0xff;
2132 digest
[ 8] = (l
>> 16) & 0xff;
2134 l
= itoa64_to_int (buf
[12]) << 0;
2135 l
|= itoa64_to_int (buf
[13]) << 6;
2136 l
|= itoa64_to_int (buf
[14]) << 12;
2137 l
|= itoa64_to_int (buf
[15]) << 18;
2139 digest
[ 9] = (l
>> 0) & 0xff;
2140 digest
[10] = (l
>> 8) & 0xff;
2141 digest
[11] = (l
>> 16) & 0xff;
2143 l
= itoa64_to_int (buf
[16]) << 0;
2144 l
|= itoa64_to_int (buf
[17]) << 6;
2145 l
|= itoa64_to_int (buf
[18]) << 12;
2146 l
|= itoa64_to_int (buf
[19]) << 18;
2148 digest
[12] = (l
>> 0) & 0xff;
2149 digest
[13] = (l
>> 8) & 0xff;
2150 digest
[14] = (l
>> 16) & 0xff;
2152 l
= itoa64_to_int (buf
[20]) << 0;
2153 l
|= itoa64_to_int (buf
[21]) << 6;
2154 l
|= itoa64_to_int (buf
[22]) << 12;
2155 l
|= itoa64_to_int (buf
[23]) << 18;
2157 digest
[15] = (l
>> 0) & 0xff;
2158 digest
[16] = (l
>> 8) & 0xff;
2159 digest
[17] = (l
>> 16) & 0xff;
2161 l
= itoa64_to_int (buf
[24]) << 0;
2162 l
|= itoa64_to_int (buf
[25]) << 6;
2163 l
|= itoa64_to_int (buf
[26]) << 12;
2164 l
|= itoa64_to_int (buf
[27]) << 18;
2166 digest
[18] = (l
>> 0) & 0xff;
2167 digest
[19] = (l
>> 8) & 0xff;
2168 digest
[20] = (l
>> 16) & 0xff;
2170 l
= itoa64_to_int (buf
[28]) << 0;
2171 l
|= itoa64_to_int (buf
[29]) << 6;
2172 l
|= itoa64_to_int (buf
[30]) << 12;
2173 l
|= itoa64_to_int (buf
[31]) << 18;
2175 digest
[21] = (l
>> 0) & 0xff;
2176 digest
[22] = (l
>> 8) & 0xff;
2177 digest
[23] = (l
>> 16) & 0xff;
2179 l
= itoa64_to_int (buf
[32]) << 0;
2180 l
|= itoa64_to_int (buf
[33]) << 6;
2181 l
|= itoa64_to_int (buf
[34]) << 12;
2182 l
|= itoa64_to_int (buf
[35]) << 18;
2184 digest
[24] = (l
>> 0) & 0xff;
2185 digest
[25] = (l
>> 8) & 0xff;
2186 digest
[26] = (l
>> 16) & 0xff;
2188 l
= itoa64_to_int (buf
[36]) << 0;
2189 l
|= itoa64_to_int (buf
[37]) << 6;
2190 l
|= itoa64_to_int (buf
[38]) << 12;
2191 l
|= itoa64_to_int (buf
[39]) << 18;
2193 digest
[27] = (l
>> 0) & 0xff;
2194 digest
[28] = (l
>> 8) & 0xff;
2195 digest
[29] = (l
>> 16) & 0xff;
2197 l
= itoa64_to_int (buf
[40]) << 0;
2198 l
|= itoa64_to_int (buf
[41]) << 6;
2199 l
|= itoa64_to_int (buf
[42]) << 12;
2200 l
|= itoa64_to_int (buf
[43]) << 18;
2202 digest
[30] = (l
>> 0) & 0xff;
2203 digest
[31] = (l
>> 8) & 0xff;
2204 digest
[32] = (l
>> 16) & 0xff;
2239 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2243 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2245 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2246 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2247 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2248 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2250 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2252 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2253 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2254 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2255 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2257 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2259 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2260 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2261 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2262 buf
[11] = int_to_itoa64 (l
& 0x3f);
2264 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2266 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2267 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2268 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2269 buf
[15] = int_to_itoa64 (l
& 0x3f);
2271 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2273 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2274 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2275 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2276 buf
[19] = int_to_itoa64 (l
& 0x3f);
2278 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2280 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2281 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2282 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2283 buf
[23] = int_to_itoa64 (l
& 0x3f);
2285 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2287 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2288 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2289 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2290 buf
[27] = int_to_itoa64 (l
& 0x3f);
2292 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2294 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2295 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2296 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2297 buf
[31] = int_to_itoa64 (l
& 0x3f);
2299 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2301 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2302 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2303 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2304 buf
[35] = int_to_itoa64 (l
& 0x3f);
2306 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2308 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2309 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2310 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2311 buf
[39] = int_to_itoa64 (l
& 0x3f);
2313 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2315 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2316 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2317 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2318 //buf[43] = int_to_itoa64 (l & 0x3f);
2326 static struct termio savemodes
;
2327 static int havemodes
= 0;
2331 struct termio modmodes
;
2333 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2337 modmodes
= savemodes
;
2338 modmodes
.c_lflag
&= ~ICANON
;
2339 modmodes
.c_cc
[VMIN
] = 1;
2340 modmodes
.c_cc
[VTIME
] = 0;
2342 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2351 FD_SET (fileno (stdin
), &rfds
);
2358 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2360 if (retval
== 0) return 0;
2361 if (retval
== -1) return -1;
2368 if (!havemodes
) return 0;
2370 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2375 static struct termios savemodes
;
2376 static int havemodes
= 0;
2380 struct termios modmodes
;
2382 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2386 modmodes
= savemodes
;
2387 modmodes
.c_lflag
&= ~ICANON
;
2388 modmodes
.c_cc
[VMIN
] = 1;
2389 modmodes
.c_cc
[VTIME
] = 0;
2391 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2400 FD_SET (fileno (stdin
), &rfds
);
2407 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2409 if (retval
== 0) return 0;
2410 if (retval
== -1) return -1;
2417 if (!havemodes
) return 0;
2419 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2424 static DWORD saveMode
= 0;
2428 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2430 GetConsoleMode (stdinHandle
, &saveMode
);
2431 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2438 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2440 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2442 if (rc
== WAIT_TIMEOUT
) return 0;
2443 if (rc
== WAIT_ABANDONED
) return -1;
2444 if (rc
== WAIT_FAILED
) return -1;
2446 // The whole ReadConsoleInput () part is a workaround.
2447 // For some unknown reason, maybe a mingw bug, a random signal
2448 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2449 // Then it wants to read with getche () a keyboard input
2450 // which has never been made.
2452 INPUT_RECORD buf
[100];
2456 memset (buf
, 0, sizeof (buf
));
2458 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2460 FlushConsoleInputBuffer (stdinHandle
);
2462 for (uint i
= 0; i
< num
; i
++)
2464 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2466 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2468 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2470 return KeyEvent
.uChar
.AsciiChar
;
2478 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2480 SetConsoleMode (stdinHandle
, saveMode
);
2490 #define MSG_ENOMEM "Insufficient memory available"
2492 void *mycalloc (size_t nmemb
, size_t size
)
2494 void *p
= calloc (nmemb
, size
);
2498 log_error ("ERROR: %s", MSG_ENOMEM
);
2506 void *mymalloc (size_t size
)
2508 void *p
= malloc (size
);
2512 log_error ("ERROR: %s", MSG_ENOMEM
);
2517 memset (p
, 0, size
);
2522 void myfree (void *ptr
)
2524 if (ptr
== NULL
) return;
2529 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2531 void *p
= realloc (ptr
, oldsz
+ add
);
2535 log_error ("ERROR: %s", MSG_ENOMEM
);
2540 memset ((char *) p
+ oldsz
, 0, add
);
2545 char *mystrdup (const char *s
)
2547 const size_t len
= strlen (s
);
2549 char *b
= (char *) mymalloc (len
+ 1);
2556 FILE *logfile_open (char *logfile
)
2558 FILE *fp
= fopen (logfile
, "ab");
2568 void logfile_close (FILE *fp
)
2570 if (fp
== stdout
) return;
2575 void logfile_append (const char *fmt
, ...)
2577 if (data
.logfile_disable
== 1) return;
2579 FILE *fp
= logfile_open (data
.logfile
);
2585 vfprintf (fp
, fmt
, ap
);
2596 int logfile_generate_id ()
2598 const int n
= rand ();
2607 char *logfile_generate_topid ()
2609 const int id
= logfile_generate_id ();
2611 char *topid
= (char *) mymalloc (1 + 16 + 1);
2613 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2618 char *logfile_generate_subid ()
2620 const int id
= logfile_generate_id ();
2622 char *subid
= (char *) mymalloc (1 + 16 + 1);
2624 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2634 void lock_file (FILE *fp
)
2638 memset (&lock
, 0, sizeof (struct flock
));
2640 lock
.l_type
= F_WRLCK
;
2641 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2645 log_error ("ERROR: failed acquiring write lock: %s", strerror (errno
));
2652 void unlock_file (FILE *fp
)
2656 memset (&lock
, 0, sizeof (struct flock
));
2658 lock
.l_type
= F_UNLCK
;
2659 fcntl(fileno(fp
), F_SETLK
, &lock
);
2666 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2668 FlushFileBuffers (h
);
2677 #if defined(_WIN) && defined(HAVE_NVAPI)
2678 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2682 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nv
, nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2686 log_info ("WARN: No NvAPI adapters found");
2693 #endif // _WIN && HAVE_NVAPI
2695 #if defined(LINUX) && defined(HAVE_NVML)
2696 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2700 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2702 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nv
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2704 // can be used to determine if the device by index matches the cuda device by index
2705 // char name[100]; memset (name, 0, sizeof (name));
2706 // hm_NVML_nvmlDeviceGetName (data.hm_nv, nvGPUHandle[i], name, sizeof (name) - 1);
2713 log_info ("WARN: No NVML adapters found");
2720 #endif // LINUX && HAVE_NVML
2723 int get_adapters_num_amd (void *adl
, int *iNumberAdapters
)
2725 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2727 if (iNumberAdapters
== 0)
2729 log_info ("WARN: No ADL adapters found.");
2738 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2740 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2741 ADLODParameters lpOdParameters;
2743 lpOdParameters.iSize = sizeof (ADLODParameters);
2744 size_t plevels_size = 0;
2746 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2748 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2749 __func__, iAdapterIndex,
2750 lpOdParameters.iNumberOfPerformanceLevels,
2751 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2752 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2754 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2756 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2758 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2760 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2762 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2763 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2764 __func__, iAdapterIndex, j,
2765 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2767 myfree (lpOdPerformanceLevels);
2773 LPAdapterInfo
hm_get_adapter_info_amd (void *adl
, int iNumberAdapters
)
2775 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2777 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2779 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2781 return lpAdapterInfo
;
2786 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2789 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2793 for (uint i = 0; i < num_adl_adapters; i++)
2795 int opencl_bus_num = hm_device[i].busid;
2796 int opencl_dev_num = hm_device[i].devid;
2798 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2806 if (idx >= DEVICES_MAX) return -1;
2811 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2813 for (uint i = 0; i < opencl_num_devices; i++)
2815 cl_device_topology_amd device_topology;
2817 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2819 hm_device[i].busid = device_topology.pcie.bus;
2820 hm_device[i].devid = device_topology.pcie.device;
2825 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2827 // basically bubble sort
2829 for (int i
= 0; i
< num_adl_adapters
; i
++)
2831 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2833 // get info of adapter [x]
2835 u32 adapter_index_x
= valid_adl_device_list
[j
];
2836 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2838 u32 bus_num_x
= info_x
.iBusNumber
;
2839 u32 dev_num_x
= info_x
.iDeviceNumber
;
2841 // get info of adapter [y]
2843 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2844 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2846 u32 bus_num_y
= info_y
.iBusNumber
;
2847 u32 dev_num_y
= info_y
.iDeviceNumber
;
2851 if (bus_num_y
< bus_num_x
)
2855 else if (bus_num_y
== bus_num_x
)
2857 if (dev_num_y
< dev_num_x
)
2865 u32 temp
= valid_adl_device_list
[j
+ 1];
2867 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2868 valid_adl_device_list
[j
+ 0] = temp
;
2874 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2876 *num_adl_adapters
= 0;
2878 u32
*adl_adapters
= NULL
;
2880 int *bus_numbers
= NULL
;
2881 int *device_numbers
= NULL
;
2883 for (int i
= 0; i
< iNumberAdapters
; i
++)
2885 AdapterInfo info
= lpAdapterInfo
[i
];
2887 if (strlen (info
.strUDID
) < 1) continue;
2890 if (info
.iVendorID
!= 1002) continue;
2892 if (info
.iVendorID
!= 0x1002) continue;
2895 if (info
.iBusNumber
< 0) continue;
2896 if (info
.iDeviceNumber
< 0) continue;
2900 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2902 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2909 if (found
) continue;
2911 // add it to the list
2913 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2915 adl_adapters
[*num_adl_adapters
] = i
;
2917 // rest is just bookkeeping
2919 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2920 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2922 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2923 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2925 (*num_adl_adapters
)++;
2928 myfree (bus_numbers
);
2929 myfree (device_numbers
);
2931 // sort the list by increasing bus id, device id number
2933 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2935 return adl_adapters
;
2938 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2940 // loop through all valid devices
2942 for (int i
= 0; i
< num_adl_adapters
; i
++)
2944 u32 adapter_index
= valid_adl_device_list
[i
];
2948 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2950 // unfortunately this doesn't work since bus id and dev id are not unique
2951 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2952 // if (opencl_device_index == -1) continue;
2954 int opencl_device_index
= i
;
2956 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2958 // get fanspeed info
2960 if (hm_device
[opencl_device_index
].od_version
== 5)
2962 ADLFanSpeedInfo FanSpeedInfo
;
2964 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2966 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2968 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2970 // check read and write capability in fanspeedinfo
2972 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2973 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2975 hm_device
[opencl_device_index
].fan_supported
= 1;
2979 hm_device
[opencl_device_index
].fan_supported
= 0;
2982 else // od_version == 6
2984 ADLOD6FanSpeedInfo faninfo
;
2986 memset (&faninfo
, 0, sizeof (faninfo
));
2988 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2990 // check read capability in fanspeedinfo
2992 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2994 hm_device
[opencl_device_index
].fan_supported
= 1;
2998 hm_device
[opencl_device_index
].fan_supported
= 0;
3006 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3008 for (int i
= 0; i
< num_adl_adapters
; i
++)
3010 u32 adapter_index
= valid_adl_device_list
[i
];
3014 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3016 // get overdrive version
3018 int od_supported
= 0;
3022 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3024 // store the overdrive version in hm_device
3026 // unfortunately this doesn't work since bus id and dev id are not unique
3027 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3028 // if (opencl_device_index == -1) continue;
3030 int opencl_device_index
= i
;
3032 hm_device
[opencl_device_index
].od_version
= od_version
;
3038 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3040 for (int i
= 0; i
< num_adl_adapters
; i
++)
3042 u32 adapter_index
= valid_adl_device_list
[i
];
3046 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3048 // store the iAdapterIndex in hm_device
3050 // unfortunately this doesn't work since bus id and dev id are not unique
3051 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3052 // if (opencl_device_index == -1) continue;
3054 int opencl_device_index
= i
;
3056 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3059 return num_adl_adapters
;
3063 int hm_get_temperature_with_device_id (const uint device_id
)
3065 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3068 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3072 if (data
.hm_device
[device_id
].od_version
== 5)
3074 ADLTemperature Temperature
;
3076 Temperature
.iSize
= sizeof (ADLTemperature
);
3078 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3080 return Temperature
.iTemperature
/ 1000;
3082 else if (data
.hm_device
[device_id
].od_version
== 6)
3084 int Temperature
= 0;
3086 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3088 return Temperature
/ 1000;
3094 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3095 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3097 #if defined(LINUX) && defined(HAVE_NVML)
3098 int temperature
= 0;
3100 hm_NVML_nvmlDeviceGetTemperature (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (unsigned int *) &temperature
);
3105 #if defined(WIN) && defined(HAVE_NVAPI)
3106 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3108 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3109 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3110 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3111 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3113 if (hm_NvAPI_GPU_GetThermalSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3115 return pThermalSettings
.sensor
[0].currentTemp
;
3116 #endif // WIN && HAVE_NVAPI
3118 #endif // HAVE_NVML || HAVE_NVAPI
3123 int hm_get_fanspeed_with_device_id (const uint device_id
)
3125 // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
3126 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3128 if (data
.hm_device
[device_id
].fan_supported
== 1)
3131 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3135 if (data
.hm_device
[device_id
].od_version
== 5)
3137 ADLFanSpeedValue lpFanSpeedValue
;
3139 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3141 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3142 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3143 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3145 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3147 return lpFanSpeedValue
.iFanSpeed
;
3149 else // od_version == 6
3151 ADLOD6FanSpeedInfo faninfo
;
3153 memset (&faninfo
, 0, sizeof (faninfo
));
3155 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3157 return faninfo
.iFanSpeedPercent
;
3163 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3164 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3166 #if defined(LINUX) && defined(HAVE_NVML)
3169 hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (unsigned int *) &speed
);
3174 #if defined(WIN) && defined(HAVE_NVAPI)
3176 NV_GPU_COOLER_SETTINGS pCoolerSettings
;
3178 pCoolerSettings
.Version
= GPU_COOLER_SETTINGS_VER
| sizeof (NV_GPU_COOLER_SETTINGS
);
3180 hm_NvAPI_GPU_GetCoolerSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pCoolerSettings
);
3182 return pCoolerSettings
.Cooler
[0].CurrentLevel
;
3185 #endif // HAVE_NVML || HAVE_NVAPI
3191 int hm_get_utilization_with_device_id (const uint device_id
)
3193 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3196 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3200 ADLPMActivity PMActivity
;
3202 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3204 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3206 return PMActivity
.iActivityPercent
;
3211 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3212 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3214 #if defined(LINUX) && defined(HAVE_NVML)
3215 nvmlUtilization_t utilization
;
3217 hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3219 return utilization
.gpu
;
3222 #if defined(WIN) && defined(HAVE_NVAPI)
3223 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3225 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3227 if (hm_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3229 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3232 #endif // HAVE_NVML || HAVE_NVAPI
3238 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3240 if (data
.hm_device
[device_id
].fan_supported
== 1)
3244 if (data
.hm_device
[device_id
].od_version
== 5)
3246 ADLFanSpeedValue lpFanSpeedValue
;
3248 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3250 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3251 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3252 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3253 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3255 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3259 else // od_version == 6
3261 ADLOD6FanSpeedValue fan_speed_value
;
3263 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3265 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3266 fan_speed_value
.iFanSpeed
= fanspeed
;
3268 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3279 // helper function for status display
3281 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3283 #define VALUE_NOT_AVAILABLE "N/A"
3287 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3291 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3294 #endif // HAVE_HWMON
3300 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3302 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3304 if (css_cnt
> SP_PW_MAX
)
3306 log_error ("ERROR: mask length is too long");
3311 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3313 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3315 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3316 uint cs_len
= css
[css_pos
].cs_len
;
3318 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3320 uint c
= cs_buf
[cs_pos
] & 0xff;
3327 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3329 cs_t
*cs
= &css
[css_cnt
];
3331 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3333 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3337 for (i
= 0; i
< cs
->cs_len
; i
++)
3339 const uint u
= cs
->cs_buf
[i
];
3344 for (i
= 0; i
< in_len
; i
++)
3346 uint u
= in_buf
[i
] & 0xff;
3348 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3350 if (css_uniq
[u
] == 1) continue;
3354 cs
->cs_buf
[cs
->cs_len
] = u
;
3362 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3366 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3368 uint p0
= in_buf
[in_pos
] & 0xff;
3370 if (interpret
== 1 && p0
== '?')
3374 if (in_pos
== in_len
) break;
3376 uint p1
= in_buf
[in_pos
] & 0xff;
3380 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3382 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3384 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3386 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3388 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3390 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3392 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3393 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3395 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3396 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3398 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3399 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3401 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3402 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3404 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3406 default: log_error ("Syntax error: %s", in_buf
);
3412 if (data
.hex_charset
)
3416 if (in_pos
== in_len
)
3418 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3423 uint p1
= in_buf
[in_pos
] & 0xff;
3425 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3427 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3434 chr
= hex_convert (p1
) << 0;
3435 chr
|= hex_convert (p0
) << 4;
3437 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3443 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3449 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3453 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3455 sum
*= css
[css_pos
].cs_len
;
3461 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3463 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3468 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3470 char p0
= mask_buf
[mask_pos
];
3476 if (mask_pos
== mask_len
) break;
3478 char p1
= mask_buf
[mask_pos
];
3484 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3486 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3488 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3490 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3492 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3494 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3496 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3497 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3499 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3500 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3502 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3503 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3505 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3506 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3508 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3510 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3516 if (data
.hex_charset
)
3520 // if there is no 2nd hex character, show an error:
3522 if (mask_pos
== mask_len
)
3524 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3529 char p1
= mask_buf
[mask_pos
];
3531 // if they are not valid hex character, show an error:
3533 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3535 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3542 chr
|= hex_convert (p1
) << 0;
3543 chr
|= hex_convert (p0
) << 4;
3545 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3551 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3558 log_error ("ERROR: invalid mask length (0)");
3568 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3570 for (int i
= 0; i
< css_cnt
; i
++)
3572 uint len
= css
[i
].cs_len
;
3573 u64 next
= val
/ len
;
3574 uint pos
= val
% len
;
3575 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3580 void mp_cut_at (char *mask
, uint max
)
3584 uint mask_len
= strlen (mask
);
3586 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3588 if (mask
[i
] == '?') i
++;
3594 void mp_setup_sys (cs_t
*mp_sys
)
3598 uint donec
[CHARSIZ
] = { 0 };
3600 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3601 mp_sys
[0].cs_buf
[pos
++] = chr
;
3602 mp_sys
[0].cs_len
= pos
; }
3604 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3605 mp_sys
[1].cs_buf
[pos
++] = chr
;
3606 mp_sys
[1].cs_len
= pos
; }
3608 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3609 mp_sys
[2].cs_buf
[pos
++] = chr
;
3610 mp_sys
[2].cs_len
= pos
; }
3612 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3613 mp_sys
[3].cs_buf
[pos
++] = chr
;
3614 mp_sys
[3].cs_len
= pos
; }
3616 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3617 mp_sys
[4].cs_len
= pos
; }
3619 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3620 mp_sys
[5].cs_len
= pos
; }
3623 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3625 FILE *fp
= fopen (buf
, "rb");
3627 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3629 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3633 char mp_file
[1024] = { 0 };
3635 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3639 len
= in_superchop (mp_file
);
3643 log_info ("WARNING: charset file corrupted");
3645 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3649 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3654 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3656 mp_usr
[index
].cs_len
= 0;
3658 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3661 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3663 char *new_mask_buf
= (char *) mymalloc (256);
3669 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3671 if (css_pos
== len
) break;
3673 char p0
= mask_buf
[mask_pos
];
3675 new_mask_buf
[mask_pos
] = p0
;
3681 if (mask_pos
== mask_len
) break;
3683 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3687 if (data
.hex_charset
)
3691 if (mask_pos
== mask_len
)
3693 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3698 char p1
= mask_buf
[mask_pos
];
3700 // if they are not valid hex character, show an error:
3702 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3704 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3709 new_mask_buf
[mask_pos
] = p1
;
3714 if (css_pos
== len
) return (new_mask_buf
);
3716 myfree (new_mask_buf
);
3725 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3731 for (i
= start
; i
< stop
; i
++)
3733 sum
*= root_css_buf
[i
].cs_len
;
3739 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3743 cs_t
*cs
= &root_css_buf
[start
];
3747 for (i
= start
; i
< stop
; i
++)
3749 const u64 m
= v
% cs
->cs_len
;
3750 const u64 d
= v
/ cs
->cs_len
;
3754 const uint k
= cs
->cs_buf
[m
];
3756 pw_buf
[i
- start
] = (char) k
;
3758 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3762 int sp_comp_val (const void *p1
, const void *p2
)
3764 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3765 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3767 return b2
->val
- b1
->val
;
3770 void sp_setup_tbl (const char *shared_dir
, char *hcstat
, uint disable
, uint classic
, hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
)
3777 * Initialize hcstats
3780 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3782 u64
*root_stats_ptr
= root_stats_buf
;
3784 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3786 for (i
= 0; i
< SP_PW_MAX
; i
++)
3788 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3790 root_stats_ptr
+= CHARSIZ
;
3793 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3795 u64
*markov_stats_ptr
= markov_stats_buf
;
3797 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3799 for (i
= 0; i
< SP_PW_MAX
; i
++)
3801 for (j
= 0; j
< CHARSIZ
; j
++)
3803 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3805 markov_stats_ptr
+= CHARSIZ
;
3815 char hcstat_tmp
[256] = { 0 };
3817 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3819 hcstat
= hcstat_tmp
;
3822 FILE *fd
= fopen (hcstat
, "rb");
3826 log_error ("%s: %s", hcstat
, strerror (errno
));
3831 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3833 log_error ("%s: Could not load data", hcstat
);
3840 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3842 log_error ("%s: Could not load data", hcstat
);
3852 * Markov modifier of hcstat_table on user request
3857 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
3858 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
3863 /* Add all stats to first position */
3865 for (i
= 1; i
< SP_PW_MAX
; i
++)
3867 u64
*out
= root_stats_buf_by_pos
[0];
3868 u64
*in
= root_stats_buf_by_pos
[i
];
3870 for (j
= 0; j
< CHARSIZ
; j
++)
3876 for (i
= 1; i
< SP_PW_MAX
; i
++)
3878 u64
*out
= markov_stats_buf_by_key
[0][0];
3879 u64
*in
= markov_stats_buf_by_key
[i
][0];
3881 for (j
= 0; j
< CHARSIZ
; j
++)
3883 for (k
= 0; k
< CHARSIZ
; k
++)
3890 /* copy them to all pw_positions */
3892 for (i
= 1; i
< SP_PW_MAX
; i
++)
3894 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
3897 for (i
= 1; i
< SP_PW_MAX
; i
++)
3899 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
3907 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3909 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3911 for (i
= 0; i
< SP_PW_MAX
; i
++)
3913 root_table_buf_by_pos
[i
] = root_table_ptr
;
3915 root_table_ptr
+= CHARSIZ
;
3918 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3920 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3922 for (i
= 0; i
< SP_PW_MAX
; i
++)
3924 for (j
= 0; j
< CHARSIZ
; j
++)
3926 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3928 markov_table_ptr
+= CHARSIZ
;
3933 * Convert hcstat to tables
3936 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3938 uint key
= i
% CHARSIZ
;
3940 root_table_buf
[i
].key
= key
;
3941 root_table_buf
[i
].val
= root_stats_buf
[i
];
3944 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3946 uint key
= i
% CHARSIZ
;
3948 markov_table_buf
[i
].key
= key
;
3949 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3952 myfree (root_stats_buf
);
3953 myfree (markov_stats_buf
);
3959 for (i
= 0; i
< SP_PW_MAX
; i
++)
3961 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3964 for (i
= 0; i
< SP_PW_MAX
; i
++)
3966 for (j
= 0; j
< CHARSIZ
; j
++)
3968 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3973 void sp_tbl_to_css (hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint threshold
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3976 * Convert tables to css
3979 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
3981 uint pw_pos
= i
/ CHARSIZ
;
3983 cs_t
*cs
= &root_css_buf
[pw_pos
];
3985 if (cs
->cs_len
== threshold
) continue;
3987 uint key
= root_table_buf
[i
].key
;
3989 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
3991 cs
->cs_buf
[cs
->cs_len
] = key
;
3997 * Convert table to css
4000 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4002 uint c
= i
/ CHARSIZ
;
4004 cs_t
*cs
= &markov_css_buf
[c
];
4006 if (cs
->cs_len
== threshold
) continue;
4008 uint pw_pos
= c
/ CHARSIZ
;
4010 uint key
= markov_table_buf
[i
].key
;
4012 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4014 cs
->cs_buf
[cs
->cs_len
] = key
;
4020 for (uint i = 0; i < 8; i++)
4022 for (uint j = 0x20; j < 0x80; j++)
4024 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4026 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4028 for (uint k = 0; k < 10; k++)
4030 printf (" %u\n", ptr->cs_buf[k]);
4037 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4039 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4041 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4051 for (uint j
= 1; j
< CHARSIZ
; j
++)
4061 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4063 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4065 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4067 out
+= CHARSIZ
* CHARSIZ
;
4068 in
+= CHARSIZ
* CHARSIZ
;
4070 for (uint j
= 0; j
< CHARSIZ
; j
++)
4077 for (uint k
= 1; k
< CHARSIZ
; k
++)
4089 * mixed shared functions
4092 void dump_hex (const u8
*s
, const int sz
)
4094 for (int i
= 0; i
< sz
; i
++)
4096 log_info_nn ("%02x ", s
[i
]);
4102 void usage_mini_print (const char *progname
)
4104 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4107 void usage_big_print (const char *progname
)
4109 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4112 char *get_exec_path ()
4114 int exec_path_len
= 1024;
4116 char *exec_path
= (char *) mymalloc (exec_path_len
);
4120 char tmp
[32] = { 0 };
4122 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4124 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4128 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4132 uint size
= exec_path_len
;
4134 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4136 log_error("! executable path buffer too small\n");
4141 const int len
= strlen (exec_path
);
4144 #error Your Operating System is not supported or detected
4152 char *get_install_dir (const char *progname
)
4154 char *install_dir
= mystrdup (progname
);
4155 char *last_slash
= NULL
;
4157 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4161 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4167 install_dir
[0] = '.';
4171 return (install_dir
);
4174 char *get_profile_dir (const char *homedir
)
4176 #define DOT_HASHCAT ".hashcat"
4178 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4180 char *profile_dir
= (char *) mymalloc (len
+ 1);
4182 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4187 char *get_session_dir (const char *profile_dir
)
4189 #define SESSIONS_FOLDER "sessions"
4191 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4193 char *session_dir
= (char *) mymalloc (len
+ 1);
4195 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4200 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4204 FILE *fd
= fopen (filename
, "rb");
4208 log_error ("%s: %s", filename
, strerror (errno
));
4213 #define MAX_KEY_SIZE (1024 * 1024)
4215 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4217 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4223 for (int fpos
= 0; fpos
< nread
; fpos
++)
4225 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4227 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4228 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4229 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4230 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4232 if (kpos
>= 64) kpos
= 0;
4239 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4243 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4244 if (CPU_ISSET(core
, cpu_set
)) break;
4246 thread_affinity_policy_data_t policy
= { core
};
4248 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4250 if (data
.quiet
== 0)
4252 if (rc
!= KERN_SUCCESS
)
4254 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4262 void set_cpu_affinity (char *cpu_affinity
)
4265 DWORD_PTR aff_mask
= 0;
4273 char *devices
= strdup (cpu_affinity
);
4275 char *next
= strtok (devices
, ",");
4279 uint cpu_id
= atoi (next
);
4294 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4300 aff_mask
|= 1 << (cpu_id
- 1);
4302 CPU_SET ((cpu_id
- 1), &cpuset
);
4305 } while ((next
= strtok (NULL
, ",")) != NULL
);
4311 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4312 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4314 pthread_t thread
= pthread_self ();
4315 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4319 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4321 char *element
, *end
;
4323 end
= (char *) base
+ nmemb
* size
;
4325 for (element
= (char *) base
; element
< end
; element
+= size
)
4326 if (!compar (element
, key
))
4332 int sort_by_salt (const void *v1
, const void *v2
)
4334 const salt_t
*s1
= (const salt_t
*) v1
;
4335 const salt_t
*s2
= (const salt_t
*) v2
;
4337 const int res1
= s1
->salt_len
- s2
->salt_len
;
4339 if (res1
!= 0) return (res1
);
4341 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4343 if (res2
!= 0) return (res2
);
4351 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4352 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4359 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4360 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4366 int sort_by_salt_buf (const void *v1
, const void *v2
)
4368 const pot_t
*p1
= (const pot_t
*) v1
;
4369 const pot_t
*p2
= (const pot_t
*) v2
;
4371 const hash_t
*h1
= &p1
->hash
;
4372 const hash_t
*h2
= &p2
->hash
;
4374 const salt_t
*s1
= h1
->salt
;
4375 const salt_t
*s2
= h2
->salt
;
4381 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4382 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4388 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4390 const hash_t
*h1
= (const hash_t
*) v1
;
4391 const hash_t
*h2
= (const hash_t
*) v2
;
4393 const salt_t
*s1
= h1
->salt
;
4394 const salt_t
*s2
= h2
->salt
;
4396 // testphase: this should work
4401 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4402 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4405 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4406 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4407 if (s1->salt_len > s2->salt_len) return ( 1);
4408 if (s1->salt_len < s2->salt_len) return (-1);
4410 uint n = s1->salt_len;
4414 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4415 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4422 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4424 const hash_t
*h1
= (const hash_t
*) v1
;
4425 const hash_t
*h2
= (const hash_t
*) v2
;
4427 const salt_t
*s1
= h1
->salt
;
4428 const salt_t
*s2
= h2
->salt
;
4430 // 12 - 2 (since last 2 uints contain the digest)
4435 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4436 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4442 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4444 const hash_t
*h1
= (const hash_t
*) v1
;
4445 const hash_t
*h2
= (const hash_t
*) v2
;
4447 const void *d1
= h1
->digest
;
4448 const void *d2
= h2
->digest
;
4450 return data
.sort_by_digest (d1
, d2
);
4453 int sort_by_hash (const void *v1
, const void *v2
)
4455 const hash_t
*h1
= (const hash_t
*) v1
;
4456 const hash_t
*h2
= (const hash_t
*) v2
;
4460 const salt_t
*s1
= h1
->salt
;
4461 const salt_t
*s2
= h2
->salt
;
4463 int res
= sort_by_salt (s1
, s2
);
4465 if (res
!= 0) return (res
);
4468 const void *d1
= h1
->digest
;
4469 const void *d2
= h2
->digest
;
4471 return data
.sort_by_digest (d1
, d2
);
4474 int sort_by_pot (const void *v1
, const void *v2
)
4476 const pot_t
*p1
= (const pot_t
*) v1
;
4477 const pot_t
*p2
= (const pot_t
*) v2
;
4479 const hash_t
*h1
= &p1
->hash
;
4480 const hash_t
*h2
= &p2
->hash
;
4482 return sort_by_hash (h1
, h2
);
4485 int sort_by_mtime (const void *p1
, const void *p2
)
4487 const char **f1
= (const char **) p1
;
4488 const char **f2
= (const char **) p2
;
4490 struct stat s1
; stat (*f1
, &s1
);
4491 struct stat s2
; stat (*f2
, &s2
);
4493 return s2
.st_mtime
- s1
.st_mtime
;
4496 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4498 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4499 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4501 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4504 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4506 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4507 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4509 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4512 int sort_by_stringptr (const void *p1
, const void *p2
)
4514 const char **s1
= (const char **) p1
;
4515 const char **s2
= (const char **) p2
;
4517 return strcmp (*s1
, *s2
);
4520 int sort_by_dictstat (const void *s1
, const void *s2
)
4522 dictstat_t
*d1
= (dictstat_t
*) s1
;
4523 dictstat_t
*d2
= (dictstat_t
*) s2
;
4526 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4528 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4531 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4534 int sort_by_bitmap (const void *p1
, const void *p2
)
4536 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4537 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4539 return b1
->collisions
- b2
->collisions
;
4542 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4544 const u32
*d1
= (const u32
*) v1
;
4545 const u32
*d2
= (const u32
*) v2
;
4551 if (d1
[n
] > d2
[n
]) return ( 1);
4552 if (d1
[n
] < d2
[n
]) return (-1);
4558 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4560 const u32
*d1
= (const u32
*) v1
;
4561 const u32
*d2
= (const u32
*) v2
;
4567 if (d1
[n
] > d2
[n
]) return ( 1);
4568 if (d1
[n
] < d2
[n
]) return (-1);
4574 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4576 const u32
*d1
= (const u32
*) v1
;
4577 const u32
*d2
= (const u32
*) v2
;
4583 if (d1
[n
] > d2
[n
]) return ( 1);
4584 if (d1
[n
] < d2
[n
]) return (-1);
4590 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4592 const u32
*d1
= (const u32
*) v1
;
4593 const u32
*d2
= (const u32
*) v2
;
4599 if (d1
[n
] > d2
[n
]) return ( 1);
4600 if (d1
[n
] < d2
[n
]) return (-1);
4606 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4608 const u32
*d1
= (const u32
*) v1
;
4609 const u32
*d2
= (const u32
*) v2
;
4615 if (d1
[n
] > d2
[n
]) return ( 1);
4616 if (d1
[n
] < d2
[n
]) return (-1);
4622 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4624 const u32
*d1
= (const u32
*) v1
;
4625 const u32
*d2
= (const u32
*) v2
;
4631 if (d1
[n
] > d2
[n
]) return ( 1);
4632 if (d1
[n
] < d2
[n
]) return (-1);
4638 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4640 const u32
*d1
= (const u32
*) v1
;
4641 const u32
*d2
= (const u32
*) v2
;
4647 if (d1
[n
] > d2
[n
]) return ( 1);
4648 if (d1
[n
] < d2
[n
]) return (-1);
4654 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4656 const u32
*d1
= (const u32
*) v1
;
4657 const u32
*d2
= (const u32
*) v2
;
4663 if (d1
[n
] > d2
[n
]) return ( 1);
4664 if (d1
[n
] < d2
[n
]) return (-1);
4670 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4672 const u64
*d1
= (const u64
*) v1
;
4673 const u64
*d2
= (const u64
*) v2
;
4679 if (d1
[n
] > d2
[n
]) return ( 1);
4680 if (d1
[n
] < d2
[n
]) return (-1);
4686 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4688 const u64
*d1
= (const u64
*) v1
;
4689 const u64
*d2
= (const u64
*) v2
;
4695 if (d1
[n
] > d2
[n
]) return ( 1);
4696 if (d1
[n
] < d2
[n
]) return (-1);
4702 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4704 const u64
*d1
= (const u64
*) v1
;
4705 const u64
*d2
= (const u64
*) v2
;
4711 if (d1
[n
] > d2
[n
]) return ( 1);
4712 if (d1
[n
] < d2
[n
]) return (-1);
4718 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4720 const u32
*d1
= (const u32
*) v1
;
4721 const u32
*d2
= (const u32
*) v2
;
4723 const uint dgst_pos0
= data
.dgst_pos0
;
4724 const uint dgst_pos1
= data
.dgst_pos1
;
4725 const uint dgst_pos2
= data
.dgst_pos2
;
4726 const uint dgst_pos3
= data
.dgst_pos3
;
4728 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4729 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4730 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4731 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4732 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4733 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4734 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4735 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4740 void format_debug (char *debug_file
, uint debug_mode
, unsigned char *orig_plain_ptr
, uint orig_plain_len
, unsigned char *mod_plain_ptr
, uint mod_plain_len
, char *rule_buf
, int rule_len
)
4742 uint outfile_autohex
= data
.outfile_autohex
;
4744 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4746 FILE *debug_fp
= NULL
;
4748 if (debug_file
!= NULL
)
4750 debug_fp
= fopen (debug_file
, "ab");
4752 lock_file (debug_fp
);
4759 if (debug_fp
== NULL
)
4761 log_info ("WARNING: Could not open debug-file for writing");
4765 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4767 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4769 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4772 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4774 if (debug_mode
== 4)
4776 fputc (':', debug_fp
);
4778 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4781 fputc ('\n', debug_fp
);
4783 if (debug_file
!= NULL
) fclose (debug_fp
);
4787 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4789 int needs_hexify
= 0;
4791 if (outfile_autohex
== 1)
4793 for (uint i
= 0; i
< plain_len
; i
++)
4795 if (plain_ptr
[i
] < 0x20)
4802 if (plain_ptr
[i
] > 0x7f)
4811 if (needs_hexify
== 1)
4813 fprintf (fp
, "$HEX[");
4815 for (uint i
= 0; i
< plain_len
; i
++)
4817 fprintf (fp
, "%02x", plain_ptr
[i
]);
4824 fwrite (plain_ptr
, plain_len
, 1, fp
);
4828 void format_output (FILE *out_fp
, char *out_buf
, unsigned char *plain_ptr
, const uint plain_len
, const u64 crackpos
, unsigned char *username
, const uint user_len
)
4830 uint outfile_format
= data
.outfile_format
;
4832 char separator
= data
.separator
;
4834 if (outfile_format
& OUTFILE_FMT_HASH
)
4836 fprintf (out_fp
, "%s", out_buf
);
4838 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4840 fputc (separator
, out_fp
);
4843 else if (data
.username
)
4845 if (username
!= NULL
)
4847 for (uint i
= 0; i
< user_len
; i
++)
4849 fprintf (out_fp
, "%c", username
[i
]);
4852 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4854 fputc (separator
, out_fp
);
4859 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4861 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4863 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4865 fputc (separator
, out_fp
);
4869 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4871 for (uint i
= 0; i
< plain_len
; i
++)
4873 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4876 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4878 fputc (separator
, out_fp
);
4882 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4885 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4890 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
4892 fprintf (out_fp
, "%llu", crackpos
);
4897 fputc ('\n', out_fp
);
4900 void handle_show_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
4904 pot_key
.hash
.salt
= hashes_buf
->salt
;
4905 pot_key
.hash
.digest
= hashes_buf
->digest
;
4907 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4913 input_buf
[input_len
] = 0;
4916 unsigned char *username
= NULL
;
4921 user_t
*user
= hashes_buf
->hash_info
->user
;
4925 username
= (unsigned char *) (user
->user_name
);
4927 user_len
= user
->user_len
;
4931 // do output the line
4932 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
4936 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
4937 #define LM_MASKED_PLAIN "[notfound]"
4939 void handle_show_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
4945 pot_left_key
.hash
.salt
= hash_left
->salt
;
4946 pot_left_key
.hash
.digest
= hash_left
->digest
;
4948 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4952 uint weak_hash_found
= 0;
4954 pot_t pot_right_key
;
4956 pot_right_key
.hash
.salt
= hash_right
->salt
;
4957 pot_right_key
.hash
.digest
= hash_right
->digest
;
4959 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4961 if (pot_right_ptr
== NULL
)
4963 // special case, if "weak hash"
4965 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
4967 weak_hash_found
= 1;
4969 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4971 // in theory this is not needed, but we are paranoia:
4973 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4974 pot_right_ptr
->plain_len
= 0;
4978 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
4980 if (weak_hash_found
== 1) myfree (pot_right_ptr
); // this shouldn't happen at all: if weak_hash_found == 1, than pot_right_ptr is not NULL for sure
4985 // at least one half was found:
4989 input_buf
[input_len
] = 0;
4993 unsigned char *username
= NULL
;
4998 user_t
*user
= hash_left
->hash_info
->user
;
5002 username
= (unsigned char *) (user
->user_name
);
5004 user_len
= user
->user_len
;
5008 // mask the part which was not found
5010 uint left_part_masked
= 0;
5011 uint right_part_masked
= 0;
5013 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5015 if (pot_left_ptr
== NULL
)
5017 left_part_masked
= 1;
5019 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5021 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5023 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5024 pot_left_ptr
->plain_len
= mask_plain_len
;
5027 if (pot_right_ptr
== NULL
)
5029 right_part_masked
= 1;
5031 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5033 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5035 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5036 pot_right_ptr
->plain_len
= mask_plain_len
;
5039 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5043 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5045 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5047 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5049 // do output the line
5051 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5053 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5055 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5056 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5059 void handle_left_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5063 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5065 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5067 if (pot_ptr
== NULL
)
5071 input_buf
[input_len
] = 0;
5073 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5077 void handle_left_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5083 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5085 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5089 pot_t pot_right_key
;
5091 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5093 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5095 uint weak_hash_found
= 0;
5097 if (pot_right_ptr
== NULL
)
5099 // special case, if "weak hash"
5101 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5103 weak_hash_found
= 1;
5105 // we just need that pot_right_ptr is not a NULL pointer
5107 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5111 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5113 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5118 // ... at least one part was not cracked
5122 input_buf
[input_len
] = 0;
5124 // only show the hash part which is still not cracked
5126 uint user_len
= input_len
- 32;
5128 char *hash_output
= (char *) mymalloc (33);
5130 memcpy (hash_output
, input_buf
, input_len
);
5132 if (pot_left_ptr
!= NULL
)
5134 // only show right part (because left part was already found)
5136 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5138 hash_output
[user_len
+ 16] = 0;
5141 if (pot_right_ptr
!= NULL
)
5143 // only show left part (because right part was already found)
5145 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5147 hash_output
[user_len
+ 16] = 0;
5150 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5152 myfree (hash_output
);
5154 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5157 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5159 uint opencl_platforms_filter
= 0;
5161 if (opencl_platforms
)
5163 char *platforms
= strdup (opencl_platforms
);
5165 char *next
= strtok (platforms
, ",");
5169 int platform
= atoi (next
);
5171 if (platform
< 1 || platform
> 32)
5173 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5178 opencl_platforms_filter
|= 1 << (platform
- 1);
5180 } while ((next
= strtok (NULL
, ",")) != NULL
);
5186 opencl_platforms_filter
= -1;
5189 return opencl_platforms_filter
;
5192 u32
setup_devices_filter (char *opencl_devices
)
5194 u32 devices_filter
= 0;
5198 char *devices
= strdup (opencl_devices
);
5200 char *next
= strtok (devices
, ",");
5204 int device_id
= atoi (next
);
5206 if (device_id
< 1 || device_id
> 32)
5208 log_error ("ERROR: invalid device_id %u specified", device_id
);
5213 devices_filter
|= 1 << (device_id
- 1);
5215 } while ((next
= strtok (NULL
, ",")) != NULL
);
5221 devices_filter
= -1;
5224 return devices_filter
;
5227 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5229 cl_device_type device_types_filter
= 0;
5231 if (opencl_device_types
)
5233 char *device_types
= strdup (opencl_device_types
);
5235 char *next
= strtok (device_types
, ",");
5239 int device_type
= atoi (next
);
5241 if (device_type
< 1 || device_type
> 3)
5243 log_error ("ERROR: invalid device_type %u specified", device_type
);
5248 device_types_filter
|= 1 << device_type
;
5250 } while ((next
= strtok (NULL
, ",")) != NULL
);
5252 free (device_types
);
5256 // Do not use CPU by default, this often reduces GPU performance because
5257 // the CPU is too busy to handle GPU synchronization
5259 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5262 return device_types_filter
;
5265 u32
get_random_num (const u32 min
, const u32 max
)
5267 if (min
== max
) return (min
);
5269 return ((rand () % (max
- min
)) + min
);
5272 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5274 u32 quotient
= dividend
/ divisor
;
5276 if (dividend
% divisor
) quotient
++;
5281 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5283 u64 quotient
= dividend
/ divisor
;
5285 if (dividend
% divisor
) quotient
++;
5290 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5292 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5293 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5295 if (tm
->tm_year
- 70)
5297 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5298 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5300 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5302 else if (tm
->tm_yday
)
5304 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5305 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5307 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5309 else if (tm
->tm_hour
)
5311 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5312 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5314 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5316 else if (tm
->tm_min
)
5318 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5319 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5321 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5325 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5327 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5331 void format_speed_display (float val
, char *buf
, size_t len
)
5342 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5353 /* generate output */
5357 snprintf (buf
, len
- 1, "%.0f ", val
);
5361 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5365 void lowercase (u8
*buf
, int len
)
5367 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5370 void uppercase (u8
*buf
, int len
)
5372 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5375 int fgetl (FILE *fp
, char *line_buf
)
5381 const int c
= fgetc (fp
);
5383 if (c
== EOF
) break;
5385 line_buf
[line_len
] = (char) c
;
5389 if (line_len
== BUFSIZ
) line_len
--;
5391 if (c
== '\n') break;
5394 if (line_len
== 0) return 0;
5396 if (line_buf
[line_len
- 1] == '\n')
5400 line_buf
[line_len
] = 0;
5403 if (line_len
== 0) return 0;
5405 if (line_buf
[line_len
- 1] == '\r')
5409 line_buf
[line_len
] = 0;
5415 int in_superchop (char *buf
)
5417 int len
= strlen (buf
);
5421 if (buf
[len
- 1] == '\n')
5428 if (buf
[len
- 1] == '\r')
5443 char **scan_directory (const char *path
)
5445 char *tmp_path
= mystrdup (path
);
5447 size_t tmp_path_len
= strlen (tmp_path
);
5449 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5451 tmp_path
[tmp_path_len
- 1] = 0;
5453 tmp_path_len
= strlen (tmp_path
);
5456 char **files
= NULL
;
5462 if ((d
= opendir (tmp_path
)) != NULL
)
5468 memset (&e
, 0, sizeof (e
));
5469 struct dirent
*de
= NULL
;
5471 if (readdir_r (d
, &e
, &de
) != 0)
5473 log_error ("ERROR: readdir_r() failed");
5478 if (de
== NULL
) break;
5482 while ((de
= readdir (d
)) != NULL
)
5485 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5487 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5489 char *path_file
= (char *) mymalloc (path_size
+ 1);
5491 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5493 path_file
[path_size
] = 0;
5497 if ((d_test
= opendir (path_file
)) != NULL
)
5505 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5509 files
[num_files
- 1] = path_file
;
5515 else if (errno
== ENOTDIR
)
5517 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5521 files
[num_files
- 1] = mystrdup (path
);
5524 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5528 files
[num_files
- 1] = NULL
;
5535 int count_dictionaries (char **dictionary_files
)
5537 if (dictionary_files
== NULL
) return 0;
5541 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5549 char *stroptitype (const uint opti_type
)
5553 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5554 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5555 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5556 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5557 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5558 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5559 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5560 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5561 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5562 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5563 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5564 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5565 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5566 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5572 char *strparser (const uint parser_status
)
5574 switch (parser_status
)
5576 case PARSER_OK
: return ((char *) PA_000
); break;
5577 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5578 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5579 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5580 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5581 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5582 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5583 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5584 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5585 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5586 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5587 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5588 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5589 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5590 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5591 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5592 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5595 return ((char *) PA_255
);
5598 char *strhashtype (const uint hash_mode
)
5602 case 0: return ((char *) HT_00000
); break;
5603 case 10: return ((char *) HT_00010
); break;
5604 case 11: return ((char *) HT_00011
); break;
5605 case 12: return ((char *) HT_00012
); break;
5606 case 20: return ((char *) HT_00020
); break;
5607 case 21: return ((char *) HT_00021
); break;
5608 case 22: return ((char *) HT_00022
); break;
5609 case 23: return ((char *) HT_00023
); break;
5610 case 30: return ((char *) HT_00030
); break;
5611 case 40: return ((char *) HT_00040
); break;
5612 case 50: return ((char *) HT_00050
); break;
5613 case 60: return ((char *) HT_00060
); break;
5614 case 100: return ((char *) HT_00100
); break;
5615 case 101: return ((char *) HT_00101
); break;
5616 case 110: return ((char *) HT_00110
); break;
5617 case 111: return ((char *) HT_00111
); break;
5618 case 112: return ((char *) HT_00112
); break;
5619 case 120: return ((char *) HT_00120
); break;
5620 case 121: return ((char *) HT_00121
); break;
5621 case 122: return ((char *) HT_00122
); break;
5622 case 124: return ((char *) HT_00124
); break;
5623 case 130: return ((char *) HT_00130
); break;
5624 case 131: return ((char *) HT_00131
); break;
5625 case 132: return ((char *) HT_00132
); break;
5626 case 133: return ((char *) HT_00133
); break;
5627 case 140: return ((char *) HT_00140
); break;
5628 case 141: return ((char *) HT_00141
); break;
5629 case 150: return ((char *) HT_00150
); break;
5630 case 160: return ((char *) HT_00160
); break;
5631 case 190: return ((char *) HT_00190
); break;
5632 case 200: return ((char *) HT_00200
); break;
5633 case 300: return ((char *) HT_00300
); break;
5634 case 400: return ((char *) HT_00400
); break;
5635 case 500: return ((char *) HT_00500
); break;
5636 case 501: return ((char *) HT_00501
); break;
5637 case 900: return ((char *) HT_00900
); break;
5638 case 910: return ((char *) HT_00910
); break;
5639 case 1000: return ((char *) HT_01000
); break;
5640 case 1100: return ((char *) HT_01100
); break;
5641 case 1400: return ((char *) HT_01400
); break;
5642 case 1410: return ((char *) HT_01410
); break;
5643 case 1420: return ((char *) HT_01420
); break;
5644 case 1421: return ((char *) HT_01421
); break;
5645 case 1430: return ((char *) HT_01430
); break;
5646 case 1440: return ((char *) HT_01440
); break;
5647 case 1441: return ((char *) HT_01441
); break;
5648 case 1450: return ((char *) HT_01450
); break;
5649 case 1460: return ((char *) HT_01460
); break;
5650 case 1500: return ((char *) HT_01500
); break;
5651 case 1600: return ((char *) HT_01600
); break;
5652 case 1700: return ((char *) HT_01700
); break;
5653 case 1710: return ((char *) HT_01710
); break;
5654 case 1711: return ((char *) HT_01711
); break;
5655 case 1720: return ((char *) HT_01720
); break;
5656 case 1722: return ((char *) HT_01722
); break;
5657 case 1730: return ((char *) HT_01730
); break;
5658 case 1731: return ((char *) HT_01731
); break;
5659 case 1740: return ((char *) HT_01740
); break;
5660 case 1750: return ((char *) HT_01750
); break;
5661 case 1760: return ((char *) HT_01760
); break;
5662 case 1800: return ((char *) HT_01800
); break;
5663 case 2100: return ((char *) HT_02100
); break;
5664 case 2400: return ((char *) HT_02400
); break;
5665 case 2410: return ((char *) HT_02410
); break;
5666 case 2500: return ((char *) HT_02500
); break;
5667 case 2600: return ((char *) HT_02600
); break;
5668 case 2611: return ((char *) HT_02611
); break;
5669 case 2612: return ((char *) HT_02612
); break;
5670 case 2711: return ((char *) HT_02711
); break;
5671 case 2811: return ((char *) HT_02811
); break;
5672 case 3000: return ((char *) HT_03000
); break;
5673 case 3100: return ((char *) HT_03100
); break;
5674 case 3200: return ((char *) HT_03200
); break;
5675 case 3710: return ((char *) HT_03710
); break;
5676 case 3711: return ((char *) HT_03711
); break;
5677 case 3800: return ((char *) HT_03800
); break;
5678 case 4300: return ((char *) HT_04300
); break;
5679 case 4400: return ((char *) HT_04400
); break;
5680 case 4500: return ((char *) HT_04500
); break;
5681 case 4700: return ((char *) HT_04700
); break;
5682 case 4800: return ((char *) HT_04800
); break;
5683 case 4900: return ((char *) HT_04900
); break;
5684 case 5000: return ((char *) HT_05000
); break;
5685 case 5100: return ((char *) HT_05100
); break;
5686 case 5200: return ((char *) HT_05200
); break;
5687 case 5300: return ((char *) HT_05300
); break;
5688 case 5400: return ((char *) HT_05400
); break;
5689 case 5500: return ((char *) HT_05500
); break;
5690 case 5600: return ((char *) HT_05600
); break;
5691 case 5700: return ((char *) HT_05700
); break;
5692 case 5800: return ((char *) HT_05800
); break;
5693 case 6000: return ((char *) HT_06000
); break;
5694 case 6100: return ((char *) HT_06100
); break;
5695 case 6211: return ((char *) HT_06211
); break;
5696 case 6212: return ((char *) HT_06212
); break;
5697 case 6213: return ((char *) HT_06213
); break;
5698 case 6221: return ((char *) HT_06221
); break;
5699 case 6222: return ((char *) HT_06222
); break;
5700 case 6223: return ((char *) HT_06223
); break;
5701 case 6231: return ((char *) HT_06231
); break;
5702 case 6232: return ((char *) HT_06232
); break;
5703 case 6233: return ((char *) HT_06233
); break;
5704 case 6241: return ((char *) HT_06241
); break;
5705 case 6242: return ((char *) HT_06242
); break;
5706 case 6243: return ((char *) HT_06243
); break;
5707 case 6300: return ((char *) HT_06300
); break;
5708 case 6400: return ((char *) HT_06400
); break;
5709 case 6500: return ((char *) HT_06500
); break;
5710 case 6600: return ((char *) HT_06600
); break;
5711 case 6700: return ((char *) HT_06700
); break;
5712 case 6800: return ((char *) HT_06800
); break;
5713 case 6900: return ((char *) HT_06900
); break;
5714 case 7100: return ((char *) HT_07100
); break;
5715 case 7200: return ((char *) HT_07200
); break;
5716 case 7300: return ((char *) HT_07300
); break;
5717 case 7400: return ((char *) HT_07400
); break;
5718 case 7500: return ((char *) HT_07500
); break;
5719 case 7600: return ((char *) HT_07600
); break;
5720 case 7700: return ((char *) HT_07700
); break;
5721 case 7800: return ((char *) HT_07800
); break;
5722 case 7900: return ((char *) HT_07900
); break;
5723 case 8000: return ((char *) HT_08000
); break;
5724 case 8100: return ((char *) HT_08100
); break;
5725 case 8200: return ((char *) HT_08200
); break;
5726 case 8300: return ((char *) HT_08300
); break;
5727 case 8400: return ((char *) HT_08400
); break;
5728 case 8500: return ((char *) HT_08500
); break;
5729 case 8600: return ((char *) HT_08600
); break;
5730 case 8700: return ((char *) HT_08700
); break;
5731 case 8800: return ((char *) HT_08800
); break;
5732 case 8900: return ((char *) HT_08900
); break;
5733 case 9000: return ((char *) HT_09000
); break;
5734 case 9100: return ((char *) HT_09100
); break;
5735 case 9200: return ((char *) HT_09200
); break;
5736 case 9300: return ((char *) HT_09300
); break;
5737 case 9400: return ((char *) HT_09400
); break;
5738 case 9500: return ((char *) HT_09500
); break;
5739 case 9600: return ((char *) HT_09600
); break;
5740 case 9700: return ((char *) HT_09700
); break;
5741 case 9710: return ((char *) HT_09710
); break;
5742 case 9720: return ((char *) HT_09720
); break;
5743 case 9800: return ((char *) HT_09800
); break;
5744 case 9810: return ((char *) HT_09810
); break;
5745 case 9820: return ((char *) HT_09820
); break;
5746 case 9900: return ((char *) HT_09900
); break;
5747 case 10000: return ((char *) HT_10000
); break;
5748 case 10100: return ((char *) HT_10100
); break;
5749 case 10200: return ((char *) HT_10200
); break;
5750 case 10300: return ((char *) HT_10300
); break;
5751 case 10400: return ((char *) HT_10400
); break;
5752 case 10410: return ((char *) HT_10410
); break;
5753 case 10420: return ((char *) HT_10420
); break;
5754 case 10500: return ((char *) HT_10500
); break;
5755 case 10600: return ((char *) HT_10600
); break;
5756 case 10700: return ((char *) HT_10700
); break;
5757 case 10800: return ((char *) HT_10800
); break;
5758 case 10900: return ((char *) HT_10900
); break;
5759 case 11000: return ((char *) HT_11000
); break;
5760 case 11100: return ((char *) HT_11100
); break;
5761 case 11200: return ((char *) HT_11200
); break;
5762 case 11300: return ((char *) HT_11300
); break;
5763 case 11400: return ((char *) HT_11400
); break;
5764 case 11500: return ((char *) HT_11500
); break;
5765 case 11600: return ((char *) HT_11600
); break;
5766 case 11700: return ((char *) HT_11700
); break;
5767 case 11800: return ((char *) HT_11800
); break;
5768 case 11900: return ((char *) HT_11900
); break;
5769 case 12000: return ((char *) HT_12000
); break;
5770 case 12100: return ((char *) HT_12100
); break;
5771 case 12200: return ((char *) HT_12200
); break;
5772 case 12300: return ((char *) HT_12300
); break;
5773 case 12400: return ((char *) HT_12400
); break;
5774 case 12500: return ((char *) HT_12500
); break;
5775 case 12600: return ((char *) HT_12600
); break;
5776 case 12700: return ((char *) HT_12700
); break;
5777 case 12800: return ((char *) HT_12800
); break;
5778 case 12900: return ((char *) HT_12900
); break;
5779 case 13000: return ((char *) HT_13000
); break;
5782 return ((char *) "Unknown");
5785 char *strstatus (const uint devices_status
)
5787 switch (devices_status
)
5789 case STATUS_INIT
: return ((char *) ST_0000
); break;
5790 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5791 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5792 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5793 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5794 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5795 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5796 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5797 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5798 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5801 return ((char *) "Unknown");
5804 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5806 uint hash_type
= data
.hash_type
;
5807 uint hash_mode
= data
.hash_mode
;
5808 uint salt_type
= data
.salt_type
;
5809 uint opts_type
= data
.opts_type
;
5810 uint opti_type
= data
.opti_type
;
5811 uint dgst_size
= data
.dgst_size
;
5813 char *hashfile
= data
.hashfile
;
5817 uint digest_buf
[64] = { 0 };
5819 u64
*digest_buf64
= (u64
*) digest_buf
;
5821 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5823 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5825 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5831 case HASH_TYPE_DESCRYPT
:
5832 FP (digest_buf
[1], digest_buf
[0], tt
);
5835 case HASH_TYPE_DESRACF
:
5836 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5837 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5839 FP (digest_buf
[1], digest_buf
[0], tt
);
5843 FP (digest_buf
[1], digest_buf
[0], tt
);
5846 case HASH_TYPE_NETNTLM
:
5847 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5848 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5849 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5850 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5852 FP (digest_buf
[1], digest_buf
[0], tt
);
5853 FP (digest_buf
[3], digest_buf
[2], tt
);
5856 case HASH_TYPE_BSDICRYPT
:
5857 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5858 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5860 FP (digest_buf
[1], digest_buf
[0], tt
);
5865 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5870 digest_buf
[0] += MD4M_A
;
5871 digest_buf
[1] += MD4M_B
;
5872 digest_buf
[2] += MD4M_C
;
5873 digest_buf
[3] += MD4M_D
;
5877 digest_buf
[0] += MD5M_A
;
5878 digest_buf
[1] += MD5M_B
;
5879 digest_buf
[2] += MD5M_C
;
5880 digest_buf
[3] += MD5M_D
;
5883 case HASH_TYPE_SHA1
:
5884 digest_buf
[0] += SHA1M_A
;
5885 digest_buf
[1] += SHA1M_B
;
5886 digest_buf
[2] += SHA1M_C
;
5887 digest_buf
[3] += SHA1M_D
;
5888 digest_buf
[4] += SHA1M_E
;
5891 case HASH_TYPE_SHA256
:
5892 digest_buf
[0] += SHA256M_A
;
5893 digest_buf
[1] += SHA256M_B
;
5894 digest_buf
[2] += SHA256M_C
;
5895 digest_buf
[3] += SHA256M_D
;
5896 digest_buf
[4] += SHA256M_E
;
5897 digest_buf
[5] += SHA256M_F
;
5898 digest_buf
[6] += SHA256M_G
;
5899 digest_buf
[7] += SHA256M_H
;
5902 case HASH_TYPE_SHA384
:
5903 digest_buf64
[0] += SHA384M_A
;
5904 digest_buf64
[1] += SHA384M_B
;
5905 digest_buf64
[2] += SHA384M_C
;
5906 digest_buf64
[3] += SHA384M_D
;
5907 digest_buf64
[4] += SHA384M_E
;
5908 digest_buf64
[5] += SHA384M_F
;
5909 digest_buf64
[6] += 0;
5910 digest_buf64
[7] += 0;
5913 case HASH_TYPE_SHA512
:
5914 digest_buf64
[0] += SHA512M_A
;
5915 digest_buf64
[1] += SHA512M_B
;
5916 digest_buf64
[2] += SHA512M_C
;
5917 digest_buf64
[3] += SHA512M_D
;
5918 digest_buf64
[4] += SHA512M_E
;
5919 digest_buf64
[5] += SHA512M_F
;
5920 digest_buf64
[6] += SHA512M_G
;
5921 digest_buf64
[7] += SHA512M_H
;
5926 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
5928 if (dgst_size
== DGST_SIZE_4_2
)
5930 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5932 else if (dgst_size
== DGST_SIZE_4_4
)
5934 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5936 else if (dgst_size
== DGST_SIZE_4_5
)
5938 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5940 else if (dgst_size
== DGST_SIZE_4_6
)
5942 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5944 else if (dgst_size
== DGST_SIZE_4_8
)
5946 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5948 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
5950 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
5952 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5954 else if (hash_type
== HASH_TYPE_SHA384
)
5956 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5958 else if (hash_type
== HASH_TYPE_SHA512
)
5960 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5962 else if (hash_type
== HASH_TYPE_GOST
)
5964 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5967 else if (dgst_size
== DGST_SIZE_4_64
)
5969 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5971 else if (dgst_size
== DGST_SIZE_8_25
)
5973 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5977 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
5978 | (data
.salt_type
== SALT_TYPE_EXTERN
)
5979 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
5985 memset (&salt
, 0, sizeof (salt_t
));
5987 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
5989 char *ptr
= (char *) salt
.salt_buf
;
5991 uint len
= salt
.salt_len
;
5993 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5999 case HASH_TYPE_NETNTLM
:
6001 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6002 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6004 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6010 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6012 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6020 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6022 uint max
= salt
.salt_len
/ 4;
6026 for (uint i
= 0; i
< max
; i
++)
6028 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6032 if (opts_type
& OPTS_TYPE_ST_HEX
)
6034 char tmp
[64] = { 0 };
6036 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6038 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6043 memcpy (ptr
, tmp
, len
);
6046 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6048 memset (ptr
+ len
, 0, memset_size
);
6050 salt
.salt_len
= len
;
6054 // some modes require special encoding
6057 uint out_buf_plain
[256] = { 0 };
6058 uint out_buf_salt
[256] = { 0 };
6060 char tmp_buf
[1024] = { 0 };
6062 char *ptr_plain
= (char *) out_buf_plain
;
6063 char *ptr_salt
= (char *) out_buf_salt
;
6065 if (hash_mode
== 22)
6067 char username
[30] = { 0 };
6069 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6071 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6073 u16
*ptr
= (u16
*) digest_buf
;
6075 tmp_buf
[ 0] = sig
[0];
6076 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6077 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6078 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6079 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6080 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6081 tmp_buf
[ 6] = sig
[1];
6082 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6083 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6084 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6085 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6086 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6087 tmp_buf
[12] = sig
[2];
6088 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6089 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6090 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6091 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6092 tmp_buf
[17] = sig
[3];
6093 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6094 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6095 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6096 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6097 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6098 tmp_buf
[23] = sig
[4];
6099 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6100 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6101 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6102 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6103 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6104 tmp_buf
[29] = sig
[5];
6106 snprintf (out_buf
, len
-1, "%s:%s",
6110 else if (hash_mode
== 23)
6112 // do not show the \nskyper\n part in output
6114 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6116 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6118 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6125 else if (hash_mode
== 101)
6127 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6129 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6130 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6131 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6132 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6133 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6135 memcpy (tmp_buf
, digest_buf
, 20);
6137 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6139 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6141 else if (hash_mode
== 111)
6143 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6145 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6146 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6147 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6148 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6149 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6151 memcpy (tmp_buf
, digest_buf
, 20);
6152 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6154 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6156 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6158 else if (hash_mode
== 122)
6160 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6161 (char *) salt
.salt_buf
,
6168 else if (hash_mode
== 124)
6170 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6171 (char *) salt
.salt_buf
,
6178 else if (hash_mode
== 131)
6180 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6181 (char *) salt
.salt_buf
,
6189 else if (hash_mode
== 132)
6191 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6192 (char *) salt
.salt_buf
,
6199 else if (hash_mode
== 133)
6201 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6203 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6204 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6205 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6206 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6207 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6209 memcpy (tmp_buf
, digest_buf
, 20);
6211 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6213 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6215 else if (hash_mode
== 141)
6217 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6219 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6221 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6223 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6225 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6226 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6227 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6228 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6229 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6231 memcpy (tmp_buf
, digest_buf
, 20);
6233 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6237 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6239 else if (hash_mode
== 400)
6241 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6243 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6244 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6245 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6246 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6248 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6250 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6252 else if (hash_mode
== 500)
6254 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6256 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6257 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6258 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6259 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6261 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6263 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6265 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6269 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6272 else if (hash_mode
== 501)
6274 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6276 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6277 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6279 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6281 else if (hash_mode
== 1421)
6283 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6285 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6301 else if (hash_mode
== 1441)
6303 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6305 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6307 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6309 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6311 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6312 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6313 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6314 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6315 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6316 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6317 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6318 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6320 memcpy (tmp_buf
, digest_buf
, 32);
6322 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6326 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6328 else if (hash_mode
== 1500)
6330 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6331 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6332 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6333 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6334 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6336 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6338 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6340 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6341 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6343 memcpy (tmp_buf
, digest_buf
, 8);
6345 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6347 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6351 else if (hash_mode
== 1600)
6353 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6355 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6356 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6357 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6358 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6360 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6362 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6364 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6368 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6371 else if (hash_mode
== 1711)
6373 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6375 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6376 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6377 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6378 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6379 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6380 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6381 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6382 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6384 memcpy (tmp_buf
, digest_buf
, 64);
6385 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6387 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6389 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6391 else if (hash_mode
== 1722)
6393 uint
*ptr
= digest_buf
;
6395 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6396 (unsigned char *) salt
.salt_buf
,
6406 else if (hash_mode
== 1731)
6408 uint
*ptr
= digest_buf
;
6410 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6411 (unsigned char *) salt
.salt_buf
,
6421 else if (hash_mode
== 1800)
6425 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6426 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6427 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6428 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6429 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6430 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6431 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6432 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6434 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6436 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6438 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6442 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6445 else if (hash_mode
== 2100)
6449 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6451 salt
.salt_iter
+ 1);
6453 uint signature_len
= strlen (out_buf
);
6455 pos
+= signature_len
;
6456 len
-= signature_len
;
6458 char *salt_ptr
= (char *) salt
.salt_buf
;
6460 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6462 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6463 byte_swap_32 (digest_buf
[0]),
6464 byte_swap_32 (digest_buf
[1]),
6465 byte_swap_32 (digest_buf
[2]),
6466 byte_swap_32 (digest_buf
[3]));
6468 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6470 memcpy (tmp_buf
, digest_buf
, 16);
6472 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6474 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6475 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6476 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6477 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6479 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6480 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6481 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6482 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6484 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6485 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6486 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6487 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6489 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6490 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6491 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6492 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6494 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6495 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6496 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6497 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6501 else if (hash_mode
== 2500)
6503 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6505 wpa_t
*wpa
= &wpas
[salt_pos
];
6507 uint pke
[25] = { 0 };
6509 char *pke_ptr
= (char *) pke
;
6511 for (uint i
= 0; i
< 25; i
++)
6513 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6516 unsigned char mac1
[6] = { 0 };
6517 unsigned char mac2
[6] = { 0 };
6519 memcpy (mac1
, pke_ptr
+ 23, 6);
6520 memcpy (mac2
, pke_ptr
+ 29, 6);
6522 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6523 (char *) salt
.salt_buf
,
6537 else if (hash_mode
== 4400)
6539 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6540 byte_swap_32 (digest_buf
[0]),
6541 byte_swap_32 (digest_buf
[1]),
6542 byte_swap_32 (digest_buf
[2]),
6543 byte_swap_32 (digest_buf
[3]));
6545 else if (hash_mode
== 4700)
6547 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6548 byte_swap_32 (digest_buf
[0]),
6549 byte_swap_32 (digest_buf
[1]),
6550 byte_swap_32 (digest_buf
[2]),
6551 byte_swap_32 (digest_buf
[3]),
6552 byte_swap_32 (digest_buf
[4]));
6554 else if (hash_mode
== 4800)
6556 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6558 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6563 byte_swap_32 (salt
.salt_buf
[0]),
6564 byte_swap_32 (salt
.salt_buf
[1]),
6565 byte_swap_32 (salt
.salt_buf
[2]),
6566 byte_swap_32 (salt
.salt_buf
[3]),
6569 else if (hash_mode
== 4900)
6571 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6572 byte_swap_32 (digest_buf
[0]),
6573 byte_swap_32 (digest_buf
[1]),
6574 byte_swap_32 (digest_buf
[2]),
6575 byte_swap_32 (digest_buf
[3]),
6576 byte_swap_32 (digest_buf
[4]));
6578 else if (hash_mode
== 5100)
6580 snprintf (out_buf
, len
-1, "%08x%08x",
6584 else if (hash_mode
== 5200)
6586 snprintf (out_buf
, len
-1, "%s", hashfile
);
6588 else if (hash_mode
== 5300)
6590 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6592 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6594 int buf_len
= len
-1;
6598 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6600 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6602 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6604 snprintf (out_buf
, buf_len
, ":");
6610 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6618 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6620 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6622 if ((i
== 0) || (i
== 5))
6624 snprintf (out_buf
, buf_len
, ":");
6630 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6638 for (uint i
= 0; i
< 4; i
++)
6642 snprintf (out_buf
, buf_len
, ":");
6648 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6654 else if (hash_mode
== 5400)
6656 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6658 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6660 int buf_len
= len
-1;
6664 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6666 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6668 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6670 snprintf (out_buf
, buf_len
, ":");
6676 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6684 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6686 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6688 if ((i
== 0) || (i
== 5))
6690 snprintf (out_buf
, buf_len
, ":");
6696 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6704 for (uint i
= 0; i
< 5; i
++)
6708 snprintf (out_buf
, buf_len
, ":");
6714 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6720 else if (hash_mode
== 5500)
6722 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6724 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6726 char user_buf
[64] = { 0 };
6727 char domain_buf
[64] = { 0 };
6728 char srvchall_buf
[1024] = { 0 };
6729 char clichall_buf
[1024] = { 0 };
6731 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6733 char *ptr
= (char *) netntlm
->userdomain_buf
;
6735 user_buf
[i
] = ptr
[j
];
6738 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6740 char *ptr
= (char *) netntlm
->userdomain_buf
;
6742 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6745 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6747 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6749 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6752 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6754 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6756 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6759 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6767 byte_swap_32 (salt
.salt_buf_pc
[0]),
6768 byte_swap_32 (salt
.salt_buf_pc
[1]),
6771 else if (hash_mode
== 5600)
6773 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6775 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6777 char user_buf
[64] = { 0 };
6778 char domain_buf
[64] = { 0 };
6779 char srvchall_buf
[1024] = { 0 };
6780 char clichall_buf
[1024] = { 0 };
6782 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6784 char *ptr
= (char *) netntlm
->userdomain_buf
;
6786 user_buf
[i
] = ptr
[j
];
6789 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6791 char *ptr
= (char *) netntlm
->userdomain_buf
;
6793 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6796 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6798 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6800 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6803 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6805 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6807 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6810 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6820 else if (hash_mode
== 5700)
6822 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6824 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6825 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6826 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6827 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6828 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6829 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6830 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6831 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6833 memcpy (tmp_buf
, digest_buf
, 32);
6835 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6839 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6841 else if (hash_mode
== 5800)
6843 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6844 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6845 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6846 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6847 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6849 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6856 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6858 snprintf (out_buf
, len
-1, "%s", hashfile
);
6860 else if (hash_mode
== 6300)
6862 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6864 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6865 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6866 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6867 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6869 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6871 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6873 else if (hash_mode
== 6400)
6875 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6877 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6879 else if (hash_mode
== 6500)
6881 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6883 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6885 else if (hash_mode
== 6600)
6887 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6889 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6891 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6892 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6894 uint buf_len
= len
- 1;
6896 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6899 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6901 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6906 else if (hash_mode
== 6700)
6908 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6910 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6912 else if (hash_mode
== 6800)
6914 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6916 else if (hash_mode
== 7100)
6918 uint
*ptr
= digest_buf
;
6920 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6922 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6924 uint esalt
[8] = { 0 };
6926 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6927 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6928 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6929 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6930 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6931 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6932 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6933 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6935 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",
6936 SIGNATURE_SHA512OSX
,
6938 esalt
[ 0], esalt
[ 1],
6939 esalt
[ 2], esalt
[ 3],
6940 esalt
[ 4], esalt
[ 5],
6941 esalt
[ 6], esalt
[ 7],
6949 ptr
[15], ptr
[14]);
6951 else if (hash_mode
== 7200)
6953 uint
*ptr
= digest_buf
;
6955 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6957 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6961 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
6963 len_used
= strlen (out_buf
);
6965 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
6967 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
6969 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
6972 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",
6980 ptr
[15], ptr
[14]);
6982 else if (hash_mode
== 7300)
6984 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
6986 rakp_t
*rakp
= &rakps
[salt_pos
];
6988 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
6990 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
6993 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7000 else if (hash_mode
== 7400)
7002 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7004 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7005 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7006 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7007 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7008 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7009 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7010 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7011 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7013 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7015 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7017 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7021 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7024 else if (hash_mode
== 7500)
7026 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7028 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7030 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7031 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7033 char data
[128] = { 0 };
7035 char *ptr_data
= data
;
7037 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7039 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7042 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7044 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7049 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7051 (char *) krb5pa
->user
,
7052 (char *) krb5pa
->realm
,
7053 (char *) krb5pa
->salt
,
7056 else if (hash_mode
== 7700)
7058 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7059 (char *) salt
.salt_buf
,
7063 else if (hash_mode
== 7800)
7065 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7066 (char *) salt
.salt_buf
,
7073 else if (hash_mode
== 7900)
7075 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7079 char *tmp
= (char *) salt
.salt_buf_pc
;
7081 ptr_plain
[42] = tmp
[0];
7087 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7089 else if (hash_mode
== 8000)
7091 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7092 (unsigned char *) salt
.salt_buf
,
7102 else if (hash_mode
== 8100)
7104 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7105 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7107 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7108 (unsigned char *) salt
.salt_buf
,
7115 else if (hash_mode
== 8200)
7117 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7119 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7121 char data_buf
[4096] = { 0 };
7123 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7125 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7128 data_buf
[cloudkey
->data_len
* 2] = 0;
7130 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7131 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7132 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7133 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7134 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7135 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7136 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7137 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7139 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7140 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7141 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7142 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7144 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7160 else if (hash_mode
== 8300)
7162 char digest_buf_c
[34] = { 0 };
7164 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7166 digest_buf_c
[32] = 0;
7170 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7172 char domain_buf_c
[33] = { 0 };
7174 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7176 for (uint i
= 0; i
< salt_pc_len
; i
++)
7178 const char next
= domain_buf_c
[i
];
7180 domain_buf_c
[i
] = '.';
7185 domain_buf_c
[salt_pc_len
] = 0;
7189 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7191 else if (hash_mode
== 8500)
7193 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7195 else if (hash_mode
== 2612)
7197 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7199 (char *) salt
.salt_buf
,
7205 else if (hash_mode
== 3711)
7207 char *salt_ptr
= (char *) salt
.salt_buf
;
7209 salt_ptr
[salt
.salt_len
- 1] = 0;
7211 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7212 SIGNATURE_MEDIAWIKI_B
,
7219 else if (hash_mode
== 8800)
7221 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7223 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7225 char tmp
[3073] = { 0 };
7227 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7229 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7234 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7235 SIGNATURE_ANDROIDFDE
,
7236 byte_swap_32 (salt
.salt_buf
[0]),
7237 byte_swap_32 (salt
.salt_buf
[1]),
7238 byte_swap_32 (salt
.salt_buf
[2]),
7239 byte_swap_32 (salt
.salt_buf
[3]),
7240 byte_swap_32 (digest_buf
[0]),
7241 byte_swap_32 (digest_buf
[1]),
7242 byte_swap_32 (digest_buf
[2]),
7243 byte_swap_32 (digest_buf
[3]),
7246 else if (hash_mode
== 8900)
7248 uint N
= salt
.scrypt_N
;
7249 uint r
= salt
.scrypt_r
;
7250 uint p
= salt
.scrypt_p
;
7252 char base64_salt
[32] = { 0 };
7254 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7256 memset (tmp_buf
, 0, 46);
7258 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7259 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7260 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7261 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7262 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7263 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7264 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7265 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7266 digest_buf
[8] = 0; // needed for base64_encode ()
7268 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7270 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7278 else if (hash_mode
== 9000)
7280 snprintf (out_buf
, len
-1, "%s", hashfile
);
7282 else if (hash_mode
== 9200)
7286 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7288 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7290 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7294 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7295 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7296 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7297 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7298 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7299 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7300 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7301 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7302 digest_buf
[8] = 0; // needed for base64_encode ()
7304 char tmp_buf
[64] = { 0 };
7306 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7307 tmp_buf
[43] = 0; // cut it here
7311 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7313 else if (hash_mode
== 9300)
7315 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7316 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7317 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7318 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7319 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7320 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7321 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7322 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7323 digest_buf
[8] = 0; // needed for base64_encode ()
7325 char tmp_buf
[64] = { 0 };
7327 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7328 tmp_buf
[43] = 0; // cut it here
7330 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7332 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7334 else if (hash_mode
== 9400)
7336 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7338 office2007_t
*office2007
= &office2007s
[salt_pos
];
7340 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7341 SIGNATURE_OFFICE2007
,
7344 office2007
->keySize
,
7350 office2007
->encryptedVerifier
[0],
7351 office2007
->encryptedVerifier
[1],
7352 office2007
->encryptedVerifier
[2],
7353 office2007
->encryptedVerifier
[3],
7354 office2007
->encryptedVerifierHash
[0],
7355 office2007
->encryptedVerifierHash
[1],
7356 office2007
->encryptedVerifierHash
[2],
7357 office2007
->encryptedVerifierHash
[3],
7358 office2007
->encryptedVerifierHash
[4]);
7360 else if (hash_mode
== 9500)
7362 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7364 office2010_t
*office2010
= &office2010s
[salt_pos
];
7366 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,
7372 office2010
->encryptedVerifier
[0],
7373 office2010
->encryptedVerifier
[1],
7374 office2010
->encryptedVerifier
[2],
7375 office2010
->encryptedVerifier
[3],
7376 office2010
->encryptedVerifierHash
[0],
7377 office2010
->encryptedVerifierHash
[1],
7378 office2010
->encryptedVerifierHash
[2],
7379 office2010
->encryptedVerifierHash
[3],
7380 office2010
->encryptedVerifierHash
[4],
7381 office2010
->encryptedVerifierHash
[5],
7382 office2010
->encryptedVerifierHash
[6],
7383 office2010
->encryptedVerifierHash
[7]);
7385 else if (hash_mode
== 9600)
7387 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7389 office2013_t
*office2013
= &office2013s
[salt_pos
];
7391 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,
7397 office2013
->encryptedVerifier
[0],
7398 office2013
->encryptedVerifier
[1],
7399 office2013
->encryptedVerifier
[2],
7400 office2013
->encryptedVerifier
[3],
7401 office2013
->encryptedVerifierHash
[0],
7402 office2013
->encryptedVerifierHash
[1],
7403 office2013
->encryptedVerifierHash
[2],
7404 office2013
->encryptedVerifierHash
[3],
7405 office2013
->encryptedVerifierHash
[4],
7406 office2013
->encryptedVerifierHash
[5],
7407 office2013
->encryptedVerifierHash
[6],
7408 office2013
->encryptedVerifierHash
[7]);
7410 else if (hash_mode
== 9700)
7412 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7414 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7416 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7417 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7418 byte_swap_32 (salt
.salt_buf
[0]),
7419 byte_swap_32 (salt
.salt_buf
[1]),
7420 byte_swap_32 (salt
.salt_buf
[2]),
7421 byte_swap_32 (salt
.salt_buf
[3]),
7422 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7423 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7424 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7425 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7426 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7427 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7428 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7429 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7431 else if (hash_mode
== 9710)
7433 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7435 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7437 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7438 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7439 byte_swap_32 (salt
.salt_buf
[0]),
7440 byte_swap_32 (salt
.salt_buf
[1]),
7441 byte_swap_32 (salt
.salt_buf
[2]),
7442 byte_swap_32 (salt
.salt_buf
[3]),
7443 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7444 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7445 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7446 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7447 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7448 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7449 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7450 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7452 else if (hash_mode
== 9720)
7454 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7456 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7458 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7460 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7461 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7462 byte_swap_32 (salt
.salt_buf
[0]),
7463 byte_swap_32 (salt
.salt_buf
[1]),
7464 byte_swap_32 (salt
.salt_buf
[2]),
7465 byte_swap_32 (salt
.salt_buf
[3]),
7466 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7467 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7468 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7469 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7470 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7471 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7472 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7473 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7480 else if (hash_mode
== 9800)
7482 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7484 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7486 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7487 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7492 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7493 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7494 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7495 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7496 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7497 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7498 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7499 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7500 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7502 else if (hash_mode
== 9810)
7504 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7506 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7508 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7509 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7514 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7515 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7516 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7517 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7518 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7519 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7520 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7521 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7522 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7524 else if (hash_mode
== 9820)
7526 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7528 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7530 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7532 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7533 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7538 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7539 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7540 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7541 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7542 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7543 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7544 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7545 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7546 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7553 else if (hash_mode
== 10000)
7557 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7559 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7561 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7565 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7566 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7567 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7568 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7569 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7570 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7571 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7572 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7573 digest_buf
[8] = 0; // needed for base64_encode ()
7575 char tmp_buf
[64] = { 0 };
7577 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7581 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7583 else if (hash_mode
== 10100)
7585 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7590 byte_swap_32 (salt
.salt_buf
[0]),
7591 byte_swap_32 (salt
.salt_buf
[1]),
7592 byte_swap_32 (salt
.salt_buf
[2]),
7593 byte_swap_32 (salt
.salt_buf
[3]));
7595 else if (hash_mode
== 10200)
7597 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7599 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7603 char challenge
[100] = { 0 };
7605 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7609 char tmp_buf
[100] = { 0 };
7611 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7612 (char *) cram_md5
->user
,
7618 char response
[100] = { 0 };
7620 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7622 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7624 else if (hash_mode
== 10300)
7626 char tmp_buf
[100] = { 0 };
7628 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7629 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7631 uint tmp_len
= 20 + salt
.salt_len
;
7635 char base64_encoded
[100] = { 0 };
7637 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7639 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7641 else if (hash_mode
== 10400)
7643 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7645 pdf_t
*pdf
= &pdfs
[salt_pos
];
7647 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",
7655 byte_swap_32 (pdf
->id_buf
[0]),
7656 byte_swap_32 (pdf
->id_buf
[1]),
7657 byte_swap_32 (pdf
->id_buf
[2]),
7658 byte_swap_32 (pdf
->id_buf
[3]),
7660 byte_swap_32 (pdf
->u_buf
[0]),
7661 byte_swap_32 (pdf
->u_buf
[1]),
7662 byte_swap_32 (pdf
->u_buf
[2]),
7663 byte_swap_32 (pdf
->u_buf
[3]),
7664 byte_swap_32 (pdf
->u_buf
[4]),
7665 byte_swap_32 (pdf
->u_buf
[5]),
7666 byte_swap_32 (pdf
->u_buf
[6]),
7667 byte_swap_32 (pdf
->u_buf
[7]),
7669 byte_swap_32 (pdf
->o_buf
[0]),
7670 byte_swap_32 (pdf
->o_buf
[1]),
7671 byte_swap_32 (pdf
->o_buf
[2]),
7672 byte_swap_32 (pdf
->o_buf
[3]),
7673 byte_swap_32 (pdf
->o_buf
[4]),
7674 byte_swap_32 (pdf
->o_buf
[5]),
7675 byte_swap_32 (pdf
->o_buf
[6]),
7676 byte_swap_32 (pdf
->o_buf
[7])
7679 else if (hash_mode
== 10410)
7681 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7683 pdf_t
*pdf
= &pdfs
[salt_pos
];
7685 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",
7693 byte_swap_32 (pdf
->id_buf
[0]),
7694 byte_swap_32 (pdf
->id_buf
[1]),
7695 byte_swap_32 (pdf
->id_buf
[2]),
7696 byte_swap_32 (pdf
->id_buf
[3]),
7698 byte_swap_32 (pdf
->u_buf
[0]),
7699 byte_swap_32 (pdf
->u_buf
[1]),
7700 byte_swap_32 (pdf
->u_buf
[2]),
7701 byte_swap_32 (pdf
->u_buf
[3]),
7702 byte_swap_32 (pdf
->u_buf
[4]),
7703 byte_swap_32 (pdf
->u_buf
[5]),
7704 byte_swap_32 (pdf
->u_buf
[6]),
7705 byte_swap_32 (pdf
->u_buf
[7]),
7707 byte_swap_32 (pdf
->o_buf
[0]),
7708 byte_swap_32 (pdf
->o_buf
[1]),
7709 byte_swap_32 (pdf
->o_buf
[2]),
7710 byte_swap_32 (pdf
->o_buf
[3]),
7711 byte_swap_32 (pdf
->o_buf
[4]),
7712 byte_swap_32 (pdf
->o_buf
[5]),
7713 byte_swap_32 (pdf
->o_buf
[6]),
7714 byte_swap_32 (pdf
->o_buf
[7])
7717 else if (hash_mode
== 10420)
7719 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7721 pdf_t
*pdf
= &pdfs
[salt_pos
];
7723 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7725 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",
7733 byte_swap_32 (pdf
->id_buf
[0]),
7734 byte_swap_32 (pdf
->id_buf
[1]),
7735 byte_swap_32 (pdf
->id_buf
[2]),
7736 byte_swap_32 (pdf
->id_buf
[3]),
7738 byte_swap_32 (pdf
->u_buf
[0]),
7739 byte_swap_32 (pdf
->u_buf
[1]),
7740 byte_swap_32 (pdf
->u_buf
[2]),
7741 byte_swap_32 (pdf
->u_buf
[3]),
7742 byte_swap_32 (pdf
->u_buf
[4]),
7743 byte_swap_32 (pdf
->u_buf
[5]),
7744 byte_swap_32 (pdf
->u_buf
[6]),
7745 byte_swap_32 (pdf
->u_buf
[7]),
7747 byte_swap_32 (pdf
->o_buf
[0]),
7748 byte_swap_32 (pdf
->o_buf
[1]),
7749 byte_swap_32 (pdf
->o_buf
[2]),
7750 byte_swap_32 (pdf
->o_buf
[3]),
7751 byte_swap_32 (pdf
->o_buf
[4]),
7752 byte_swap_32 (pdf
->o_buf
[5]),
7753 byte_swap_32 (pdf
->o_buf
[6]),
7754 byte_swap_32 (pdf
->o_buf
[7]),
7762 else if (hash_mode
== 10500)
7764 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7766 pdf_t
*pdf
= &pdfs
[salt_pos
];
7768 if (pdf
->id_len
== 32)
7770 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",
7778 byte_swap_32 (pdf
->id_buf
[0]),
7779 byte_swap_32 (pdf
->id_buf
[1]),
7780 byte_swap_32 (pdf
->id_buf
[2]),
7781 byte_swap_32 (pdf
->id_buf
[3]),
7782 byte_swap_32 (pdf
->id_buf
[4]),
7783 byte_swap_32 (pdf
->id_buf
[5]),
7784 byte_swap_32 (pdf
->id_buf
[6]),
7785 byte_swap_32 (pdf
->id_buf
[7]),
7787 byte_swap_32 (pdf
->u_buf
[0]),
7788 byte_swap_32 (pdf
->u_buf
[1]),
7789 byte_swap_32 (pdf
->u_buf
[2]),
7790 byte_swap_32 (pdf
->u_buf
[3]),
7791 byte_swap_32 (pdf
->u_buf
[4]),
7792 byte_swap_32 (pdf
->u_buf
[5]),
7793 byte_swap_32 (pdf
->u_buf
[6]),
7794 byte_swap_32 (pdf
->u_buf
[7]),
7796 byte_swap_32 (pdf
->o_buf
[0]),
7797 byte_swap_32 (pdf
->o_buf
[1]),
7798 byte_swap_32 (pdf
->o_buf
[2]),
7799 byte_swap_32 (pdf
->o_buf
[3]),
7800 byte_swap_32 (pdf
->o_buf
[4]),
7801 byte_swap_32 (pdf
->o_buf
[5]),
7802 byte_swap_32 (pdf
->o_buf
[6]),
7803 byte_swap_32 (pdf
->o_buf
[7])
7808 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",
7816 byte_swap_32 (pdf
->id_buf
[0]),
7817 byte_swap_32 (pdf
->id_buf
[1]),
7818 byte_swap_32 (pdf
->id_buf
[2]),
7819 byte_swap_32 (pdf
->id_buf
[3]),
7821 byte_swap_32 (pdf
->u_buf
[0]),
7822 byte_swap_32 (pdf
->u_buf
[1]),
7823 byte_swap_32 (pdf
->u_buf
[2]),
7824 byte_swap_32 (pdf
->u_buf
[3]),
7825 byte_swap_32 (pdf
->u_buf
[4]),
7826 byte_swap_32 (pdf
->u_buf
[5]),
7827 byte_swap_32 (pdf
->u_buf
[6]),
7828 byte_swap_32 (pdf
->u_buf
[7]),
7830 byte_swap_32 (pdf
->o_buf
[0]),
7831 byte_swap_32 (pdf
->o_buf
[1]),
7832 byte_swap_32 (pdf
->o_buf
[2]),
7833 byte_swap_32 (pdf
->o_buf
[3]),
7834 byte_swap_32 (pdf
->o_buf
[4]),
7835 byte_swap_32 (pdf
->o_buf
[5]),
7836 byte_swap_32 (pdf
->o_buf
[6]),
7837 byte_swap_32 (pdf
->o_buf
[7])
7841 else if (hash_mode
== 10600)
7843 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7845 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7846 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7848 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7850 else if (hash_mode
== 10700)
7852 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7854 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7855 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7857 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7859 else if (hash_mode
== 10900)
7861 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7863 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7864 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7866 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7868 else if (hash_mode
== 11100)
7870 u32 salt_challenge
= salt
.salt_buf
[0];
7872 salt_challenge
= byte_swap_32 (salt_challenge
);
7874 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7876 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7877 SIGNATURE_POSTGRESQL_AUTH
,
7885 else if (hash_mode
== 11200)
7887 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7888 SIGNATURE_MYSQL_AUTH
,
7889 (unsigned char *) salt
.salt_buf
,
7896 else if (hash_mode
== 11300)
7898 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7900 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7902 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7903 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7904 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7906 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7907 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7908 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7910 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7912 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7914 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7917 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7919 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7921 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7924 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7926 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
7928 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7931 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
7932 SIGNATURE_BITCOIN_WALLET
,
7936 (unsigned char *) salt
.salt_buf
,
7944 free (cry_master_buf
);
7946 free (public_key_buf
);
7948 else if (hash_mode
== 11400)
7950 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7952 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7953 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7955 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7957 else if (hash_mode
== 11600)
7959 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
7961 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
7963 const uint data_len
= seven_zip
->data_len
;
7965 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
7967 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
7969 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
7971 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
7974 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
7975 SIGNATURE_SEVEN_ZIP
,
7979 (char *) seven_zip
->salt_buf
,
7981 seven_zip
->iv_buf
[0],
7982 seven_zip
->iv_buf
[1],
7983 seven_zip
->iv_buf
[2],
7984 seven_zip
->iv_buf
[3],
7986 seven_zip
->data_len
,
7987 seven_zip
->unpack_size
,
7992 else if (hash_mode
== 11700)
7994 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8004 else if (hash_mode
== 11800)
8006 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8024 else if (hash_mode
== 11900)
8026 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8028 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8029 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8031 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8033 else if (hash_mode
== 12000)
8035 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8037 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8038 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8040 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8042 else if (hash_mode
== 12100)
8044 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8046 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8047 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8049 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8051 else if (hash_mode
== 12200)
8053 uint
*ptr_digest
= digest_buf
;
8054 uint
*ptr_salt
= salt
.salt_buf
;
8056 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8063 else if (hash_mode
== 12300)
8065 uint
*ptr_digest
= digest_buf
;
8066 uint
*ptr_salt
= salt
.salt_buf
;
8068 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",
8069 ptr_digest
[ 0], ptr_digest
[ 1],
8070 ptr_digest
[ 2], ptr_digest
[ 3],
8071 ptr_digest
[ 4], ptr_digest
[ 5],
8072 ptr_digest
[ 6], ptr_digest
[ 7],
8073 ptr_digest
[ 8], ptr_digest
[ 9],
8074 ptr_digest
[10], ptr_digest
[11],
8075 ptr_digest
[12], ptr_digest
[13],
8076 ptr_digest
[14], ptr_digest
[15],
8082 else if (hash_mode
== 12400)
8084 // encode iteration count
8086 char salt_iter
[5] = { 0 };
8088 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8089 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8090 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8091 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8096 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8097 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8098 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8099 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8104 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8106 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8107 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8109 memcpy (tmp_buf
, digest_buf
, 8);
8111 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8115 // fill the resulting buffer
8117 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8119 else if (hash_mode
== 12500)
8121 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8123 byte_swap_32 (salt
.salt_buf
[0]),
8124 byte_swap_32 (salt
.salt_buf
[1]),
8130 else if (hash_mode
== 12600)
8132 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8133 digest_buf
[0] + salt
.salt_buf_pc
[0],
8134 digest_buf
[1] + salt
.salt_buf_pc
[1],
8135 digest_buf
[2] + salt
.salt_buf_pc
[2],
8136 digest_buf
[3] + salt
.salt_buf_pc
[3],
8137 digest_buf
[4] + salt
.salt_buf_pc
[4],
8138 digest_buf
[5] + salt
.salt_buf_pc
[5],
8139 digest_buf
[6] + salt
.salt_buf_pc
[6],
8140 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8142 else if (hash_mode
== 12700)
8144 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8146 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8147 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8149 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8151 else if (hash_mode
== 12800)
8153 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8155 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",
8168 byte_swap_32 (digest_buf
[0]),
8169 byte_swap_32 (digest_buf
[1]),
8170 byte_swap_32 (digest_buf
[2]),
8171 byte_swap_32 (digest_buf
[3]),
8172 byte_swap_32 (digest_buf
[4]),
8173 byte_swap_32 (digest_buf
[5]),
8174 byte_swap_32 (digest_buf
[6]),
8175 byte_swap_32 (digest_buf
[7])
8178 else if (hash_mode
== 12900)
8180 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",
8189 byte_swap_32 (digest_buf
[0]),
8190 byte_swap_32 (digest_buf
[1]),
8191 byte_swap_32 (digest_buf
[2]),
8192 byte_swap_32 (digest_buf
[3]),
8193 byte_swap_32 (digest_buf
[4]),
8194 byte_swap_32 (digest_buf
[5]),
8195 byte_swap_32 (digest_buf
[6]),
8196 byte_swap_32 (digest_buf
[7]),
8203 else if (hash_mode
== 13000)
8205 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8207 rar5_t
*rar5
= &rar5s
[salt_pos
];
8209 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8219 byte_swap_32 (digest_buf
[0]),
8220 byte_swap_32 (digest_buf
[1])
8225 if (hash_type
== HASH_TYPE_MD4
)
8227 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8233 else if (hash_type
== HASH_TYPE_MD5
)
8235 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8241 else if (hash_type
== HASH_TYPE_SHA1
)
8243 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8250 else if (hash_type
== HASH_TYPE_SHA256
)
8252 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8262 else if (hash_type
== HASH_TYPE_SHA384
)
8264 uint
*ptr
= digest_buf
;
8266 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8274 else if (hash_type
== HASH_TYPE_SHA512
)
8276 uint
*ptr
= digest_buf
;
8278 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8288 else if (hash_type
== HASH_TYPE_LM
)
8290 snprintf (out_buf
, len
-1, "%08x%08x",
8294 else if (hash_type
== HASH_TYPE_ORACLEH
)
8296 snprintf (out_buf
, len
-1, "%08X%08X",
8300 else if (hash_type
== HASH_TYPE_BCRYPT
)
8302 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8303 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8305 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8307 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8309 else if (hash_type
== HASH_TYPE_KECCAK
)
8311 uint
*ptr
= digest_buf
;
8313 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",
8341 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8343 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8345 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8352 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8354 digest_buf
[ 0] = digest_buf
[ 0];
8355 digest_buf
[ 1] = digest_buf
[ 1];
8356 digest_buf
[ 2] = digest_buf
[ 2];
8357 digest_buf
[ 3] = digest_buf
[ 3];
8358 digest_buf
[ 4] = digest_buf
[ 4];
8359 digest_buf
[ 5] = digest_buf
[ 5];
8360 digest_buf
[ 6] = digest_buf
[ 6];
8361 digest_buf
[ 7] = digest_buf
[ 7];
8362 digest_buf
[ 8] = digest_buf
[ 8];
8363 digest_buf
[ 9] = digest_buf
[ 9];
8364 digest_buf
[10] = digest_buf
[10];
8365 digest_buf
[11] = digest_buf
[11];
8366 digest_buf
[12] = digest_buf
[12];
8367 digest_buf
[13] = digest_buf
[13];
8368 digest_buf
[14] = digest_buf
[14];
8369 digest_buf
[15] = digest_buf
[15];
8371 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8389 else if (hash_type
== HASH_TYPE_GOST
)
8391 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8401 else if (hash_type
== HASH_TYPE_MYSQL
)
8403 snprintf (out_buf
, len
-1, "%08x%08x",
8407 else if (hash_type
== HASH_TYPE_LOTUS5
)
8409 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8415 else if (hash_type
== HASH_TYPE_LOTUS6
)
8417 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8418 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8419 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8420 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8422 char buf
[16] = { 0 };
8424 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8425 memcpy (buf
+ 5, digest_buf
, 9);
8429 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8431 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8434 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8436 else if (hash_type
== HASH_TYPE_LOTUS8
)
8438 char buf
[52] = { 0 };
8442 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8448 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8452 buf
[26] = salt
.salt_buf_pc
[0];
8453 buf
[27] = salt
.salt_buf_pc
[1];
8457 memcpy (buf
+ 28, digest_buf
, 8);
8459 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8463 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8465 else if (hash_type
== HASH_TYPE_CRC32
)
8467 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8471 if (salt_type
== SALT_TYPE_INTERN
)
8473 size_t pos
= strlen (out_buf
);
8475 out_buf
[pos
] = data
.separator
;
8477 char *ptr
= (char *) salt
.salt_buf
;
8479 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8481 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8485 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8487 memset (hccap
, 0, sizeof (hccap_t
));
8489 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8491 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8493 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8494 wpa_t
*wpa
= &wpas
[salt_pos
];
8496 hccap
->keyver
= wpa
->keyver
;
8498 hccap
->eapol_size
= wpa
->eapol_size
;
8500 if (wpa
->keyver
!= 1)
8502 uint eapol_tmp
[64] = { 0 };
8504 for (uint i
= 0; i
< 64; i
++)
8506 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8509 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8513 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8516 uint pke_tmp
[25] = { 0 };
8518 for (int i
= 5; i
< 25; i
++)
8520 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8523 char *pke_ptr
= (char *) pke_tmp
;
8525 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8526 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8527 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8528 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8530 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8532 uint dgst_size
= data
.dgst_size
;
8534 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8536 if (wpa
->keyver
!= 1)
8538 uint digest_tmp
[4] = { 0 };
8540 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8541 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8542 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8543 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8545 memcpy (hccap
->keymic
, digest_tmp
, 16);
8549 memcpy (hccap
->keymic
, digest_ptr
, 16);
8553 void SuspendThreads ()
8555 if (data
.devices_status
== STATUS_RUNNING
)
8557 hc_timer_set (&data
.timer_paused
);
8559 data
.devices_status
= STATUS_PAUSED
;
8561 log_info ("Paused");
8565 void ResumeThreads ()
8567 if (data
.devices_status
== STATUS_PAUSED
)
8571 hc_timer_get (data
.timer_paused
, ms_paused
);
8573 data
.ms_paused
+= ms_paused
;
8575 data
.devices_status
= STATUS_RUNNING
;
8577 log_info ("Resumed");
8583 if (data
.devices_status
!= STATUS_RUNNING
) return;
8585 data
.devices_status
= STATUS_BYPASS
;
8587 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8590 void stop_at_checkpoint ()
8592 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8594 if (data
.devices_status
!= STATUS_RUNNING
) return;
8597 // this feature only makes sense if --restore-disable was not specified
8599 if (data
.restore_disable
== 1)
8601 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8606 // check if monitoring of Restore Point updates should be enabled or disabled
8608 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8610 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8612 // save the current restore point value
8614 data
.checkpoint_cur_words
= get_lowest_words_done ();
8616 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8620 data
.devices_status
= STATUS_RUNNING
;
8622 // reset the global value for checkpoint checks
8624 data
.checkpoint_cur_words
= 0;
8626 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8632 if (data
.devices_status
== STATUS_INIT
) return;
8633 if (data
.devices_status
== STATUS_STARTING
) return;
8635 data
.devices_status
= STATUS_ABORTED
;
8640 if (data
.devices_status
== STATUS_INIT
) return;
8641 if (data
.devices_status
== STATUS_STARTING
) return;
8643 data
.devices_status
= STATUS_QUIT
;
8646 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8648 FILE *fp
= fopen (kernel_file
, "rb");
8654 memset (&st
, 0, sizeof (st
));
8656 stat (kernel_file
, &st
);
8658 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8660 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8662 if (num_read
!= (size_t) st
.st_size
)
8664 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8671 buf
[st
.st_size
] = 0;
8673 for (int i
= 0; i
< num_devices
; i
++)
8675 kernel_lengths
[i
] = (size_t) st
.st_size
;
8677 kernel_sources
[i
] = buf
;
8682 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8690 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8692 if (binary_size
> 0)
8694 FILE *fp
= fopen (dst
, "wb");
8697 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8708 restore_data_t
*init_restore (int argc
, char **argv
)
8710 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8712 if (data
.restore_disable
== 0)
8714 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8718 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8722 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8731 char pidbin
[BUFSIZ
] = { 0 };
8733 int pidbin_len
= -1;
8736 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8738 FILE *fd
= fopen (pidbin
, "rb");
8742 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8744 pidbin
[pidbin_len
] = 0;
8748 char *argv0_r
= strrchr (argv
[0], '/');
8750 char *pidbin_r
= strrchr (pidbin
, '/');
8752 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8754 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8756 if (strcmp (argv0_r
, pidbin_r
) == 0)
8758 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8765 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8767 char pidbin2
[BUFSIZ
] = { 0 };
8769 int pidbin2_len
= -1;
8771 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8772 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8774 pidbin
[pidbin_len
] = 0;
8775 pidbin2
[pidbin2_len
] = 0;
8779 if (strcmp (pidbin
, pidbin2
) == 0)
8781 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8789 if (rd
->version_bin
< RESTORE_MIN
)
8791 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8798 memset (rd
, 0, sizeof (restore_data_t
));
8800 rd
->version_bin
= VERSION_BIN
;
8803 rd
->pid
= getpid ();
8805 rd
->pid
= GetCurrentProcessId ();
8808 if (getcwd (rd
->cwd
, 255) == NULL
)
8821 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8823 FILE *fp
= fopen (eff_restore_file
, "rb");
8827 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8832 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8834 log_error ("ERROR: cannot read %s", eff_restore_file
);
8839 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8841 for (uint i
= 0; i
< rd
->argc
; i
++)
8843 char buf
[BUFSIZ
] = { 0 };
8845 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8847 log_error ("ERROR: cannot read %s", eff_restore_file
);
8852 size_t len
= strlen (buf
);
8854 if (len
) buf
[len
- 1] = 0;
8856 rd
->argv
[i
] = mystrdup (buf
);
8861 char new_cwd
[1024] = { 0 };
8863 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8867 log_error ("Restore file is corrupted");
8870 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8872 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8874 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8879 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8882 if (chdir (rd
->cwd
))
8884 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8890 u64
get_lowest_words_done ()
8894 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8896 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8898 if (device_param
->skipped
) continue;
8900 const u64 words_done
= device_param
->words_done
;
8902 if (words_done
< words_cur
) words_cur
= words_done
;
8905 // It's possible that a device's workload isn't finished right after a restore-case.
8906 // In that case, this function would return 0 and overwrite the real restore point
8907 // There's also data.words_cur which is set to rd->words_cur but it changes while
8908 // the attack is running therefore we should stick to rd->words_cur.
8909 // Note that -s influences rd->words_cur we should keep a close look on that.
8911 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
8916 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
8918 u64 words_cur
= get_lowest_words_done ();
8920 rd
->words_cur
= words_cur
;
8922 FILE *fp
= fopen (new_restore_file
, "wb");
8926 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
8931 if (setvbuf (fp
, NULL
, _IONBF
, 0))
8933 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
8938 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
8940 for (uint i
= 0; i
< rd
->argc
; i
++)
8942 fprintf (fp
, "%s", rd
->argv
[i
]);
8948 fsync (fileno (fp
));
8953 void cycle_restore ()
8955 const char *eff_restore_file
= data
.eff_restore_file
;
8956 const char *new_restore_file
= data
.new_restore_file
;
8958 restore_data_t
*rd
= data
.rd
;
8960 write_restore (new_restore_file
, rd
);
8964 memset (&st
, 0, sizeof(st
));
8966 if (stat (eff_restore_file
, &st
) == 0)
8968 if (unlink (eff_restore_file
))
8970 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
8974 if (rename (new_restore_file
, eff_restore_file
))
8976 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
8980 void check_checkpoint ()
8982 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
8984 u64 words_cur
= get_lowest_words_done ();
8986 if (words_cur
!= data
.checkpoint_cur_words
)
8997 uint
set_kernel_accel_osx (uint hash_mode
)
9001 case 1800: return GET_ACCEL_OSX (1800);
9002 case 2500: return GET_ACCEL_OSX (2500);
9003 case 5000: return GET_ACCEL_OSX (5000);
9004 case 6100: return GET_ACCEL_OSX (6100);
9005 case 6211: return GET_ACCEL_OSX (6211);
9006 case 6231: return GET_ACCEL_OSX (6231);
9007 case 6241: return GET_ACCEL_OSX (6241);
9008 case 6800: return GET_ACCEL_OSX (6800);
9009 case 7100: return GET_ACCEL_OSX (7100);
9010 case 7200: return GET_ACCEL_OSX (7200);
9011 case 7900: return GET_ACCEL_OSX (7900);
9012 case 8200: return GET_ACCEL_OSX (8200);
9013 case 8700: return GET_ACCEL_OSX (8700);
9014 case 9100: return GET_ACCEL_OSX (9100);
9015 case 9200: return GET_ACCEL_OSX (9200);
9016 case 9300: return GET_ACCEL_OSX (9300);
9017 case 9400: return GET_ACCEL_OSX (9400);
9018 case 9500: return GET_ACCEL_OSX (9500);
9019 case 9600: return GET_ACCEL_OSX (9600);
9020 case 10000: return GET_ACCEL_OSX (10000);
9021 case 10500: return GET_ACCEL_OSX (10500);
9022 case 11300: return GET_ACCEL_OSX (11300);
9023 case 11600: return GET_ACCEL_OSX (11600);
9024 case 11700: return GET_ACCEL_OSX (11700);
9025 case 11800: return GET_ACCEL_OSX (11800);
9026 case 12200: return GET_ACCEL_OSX (12200);
9027 case 12400: return GET_ACCEL_OSX (12400);
9028 case 12500: return GET_ACCEL_OSX (12500);
9029 case 13000: return GET_ACCEL_OSX (13000);
9035 uint
set_kernel_accel (uint hash_mode
, bool isGpu
)
9040 accel
= set_kernel_accel_osx (hash_mode
);
9046 uint
set_kernel_accel (uint hash_mode
)
9053 case 0: return GET_ACCEL (0);
9054 case 10: return GET_ACCEL (10);
9055 case 11: return GET_ACCEL (11);
9056 case 12: return GET_ACCEL (12);
9057 case 20: return GET_ACCEL (20);
9058 case 21: return GET_ACCEL (21);
9059 case 22: return GET_ACCEL (22);
9060 case 23: return GET_ACCEL (23);
9061 case 30: return GET_ACCEL (30);
9062 case 40: return GET_ACCEL (40);
9063 case 50: return GET_ACCEL (50);
9064 case 60: return GET_ACCEL (60);
9065 case 100: return GET_ACCEL (100);
9066 case 101: return GET_ACCEL (101);
9067 case 110: return GET_ACCEL (110);
9068 case 111: return GET_ACCEL (111);
9069 case 112: return GET_ACCEL (112);
9070 case 120: return GET_ACCEL (120);
9071 case 121: return GET_ACCEL (121);
9072 case 122: return GET_ACCEL (122);
9073 case 124: return GET_ACCEL (124);
9074 case 130: return GET_ACCEL (130);
9075 case 131: return GET_ACCEL (131);
9076 case 132: return GET_ACCEL (132);
9077 case 133: return GET_ACCEL (133);
9078 case 140: return GET_ACCEL (140);
9079 case 141: return GET_ACCEL (141);
9080 case 150: return GET_ACCEL (150);
9081 case 160: return GET_ACCEL (160);
9082 case 190: return GET_ACCEL (190);
9083 case 200: return GET_ACCEL (200);
9084 case 300: return GET_ACCEL (300);
9085 case 400: return GET_ACCEL (400);
9086 case 500: return GET_ACCEL (500);
9087 case 501: return GET_ACCEL (501);
9088 case 900: return GET_ACCEL (900);
9089 case 910: return GET_ACCEL (910);
9090 case 1000: return GET_ACCEL (1000);
9091 case 1100: return GET_ACCEL (1100);
9092 case 1400: return GET_ACCEL (1400);
9093 case 1410: return GET_ACCEL (1410);
9094 case 1420: return GET_ACCEL (1420);
9095 case 1421: return GET_ACCEL (1421);
9096 case 1430: return GET_ACCEL (1430);
9097 case 1440: return GET_ACCEL (1440);
9098 case 1441: return GET_ACCEL (1441);
9099 case 1450: return GET_ACCEL (1450);
9100 case 1460: return GET_ACCEL (1460);
9101 case 1500: return GET_ACCEL (1500);
9102 case 1600: return GET_ACCEL (1600);
9103 case 1700: return GET_ACCEL (1700);
9104 case 1710: return GET_ACCEL (1710);
9105 case 1711: return GET_ACCEL (1711);
9106 case 1720: return GET_ACCEL (1720);
9107 case 1722: return GET_ACCEL (1722);
9108 case 1730: return GET_ACCEL (1730);
9109 case 1731: return GET_ACCEL (1731);
9110 case 1740: return GET_ACCEL (1740);
9111 case 1750: return GET_ACCEL (1750);
9112 case 1760: return GET_ACCEL (1760);
9113 case 1800: return GET_ACCEL (1800);
9114 case 2100: return GET_ACCEL (2100);
9115 case 2400: return GET_ACCEL (2400);
9116 case 2410: return GET_ACCEL (2410);
9117 case 2500: return GET_ACCEL (2500);
9118 case 2600: return GET_ACCEL (2600);
9119 case 2611: return GET_ACCEL (2611);
9120 case 2612: return GET_ACCEL (2612);
9121 case 2711: return GET_ACCEL (2711);
9122 case 2811: return GET_ACCEL (2811);
9123 case 3000: return GET_ACCEL (3000);
9124 case 3100: return GET_ACCEL (3100);
9125 case 3200: return GET_ACCEL (3200);
9126 case 3710: return GET_ACCEL (3710);
9127 case 3711: return GET_ACCEL (3711);
9128 case 3800: return GET_ACCEL (3800);
9129 case 4300: return GET_ACCEL (4300);
9130 case 4400: return GET_ACCEL (4400);
9131 case 4500: return GET_ACCEL (4500);
9132 case 4700: return GET_ACCEL (4700);
9133 case 4800: return GET_ACCEL (4800);
9134 case 4900: return GET_ACCEL (4900);
9135 case 5000: return GET_ACCEL (5000);
9136 case 5100: return GET_ACCEL (5100);
9137 case 5200: return GET_ACCEL (5200);
9138 case 5300: return GET_ACCEL (5300);
9139 case 5400: return GET_ACCEL (5400);
9140 case 5500: return GET_ACCEL (5500);
9141 case 5600: return GET_ACCEL (5600);
9142 case 5700: return GET_ACCEL (5700);
9143 case 5800: return GET_ACCEL (5800);
9144 case 6000: return GET_ACCEL (6000);
9145 case 6100: return GET_ACCEL (6100);
9146 case 6211: return GET_ACCEL (6211);
9147 case 6212: return GET_ACCEL (6212);
9148 case 6213: return GET_ACCEL (6213);
9149 case 6221: return GET_ACCEL (6221);
9150 case 6222: return GET_ACCEL (6222);
9151 case 6223: return GET_ACCEL (6223);
9152 case 6231: return GET_ACCEL (6231);
9153 case 6232: return GET_ACCEL (6232);
9154 case 6233: return GET_ACCEL (6233);
9155 case 6241: return GET_ACCEL (6241);
9156 case 6242: return GET_ACCEL (6242);
9157 case 6243: return GET_ACCEL (6243);
9158 case 6300: return GET_ACCEL (6300);
9159 case 6400: return GET_ACCEL (6400);
9160 case 6500: return GET_ACCEL (6500);
9161 case 6600: return GET_ACCEL (6600);
9162 case 6700: return GET_ACCEL (6700);
9163 case 6800: return GET_ACCEL (6800);
9164 case 6900: return GET_ACCEL (6900);
9165 case 7100: return GET_ACCEL (7100);
9166 case 7200: return GET_ACCEL (7200);
9167 case 7300: return GET_ACCEL (7300);
9168 case 7400: return GET_ACCEL (7400);
9169 case 7500: return GET_ACCEL (7500);
9170 case 7600: return GET_ACCEL (7600);
9171 case 7700: return GET_ACCEL (7700);
9172 case 7800: return GET_ACCEL (7800);
9173 case 7900: return GET_ACCEL (7900);
9174 case 8000: return GET_ACCEL (8000);
9175 case 8100: return GET_ACCEL (8100);
9176 case 8200: return GET_ACCEL (8200);
9177 case 8300: return GET_ACCEL (8300);
9178 case 8400: return GET_ACCEL (8400);
9179 case 8500: return GET_ACCEL (8500);
9180 case 8600: return GET_ACCEL (8600);
9181 case 8700: return GET_ACCEL (8700);
9182 case 8800: return GET_ACCEL (8800);
9183 case 8900: return GET_ACCEL (8900);
9184 case 9000: return GET_ACCEL (9000);
9185 case 9100: return GET_ACCEL (9100);
9186 case 9200: return GET_ACCEL (9200);
9187 case 9300: return GET_ACCEL (9300);
9188 case 9400: return GET_ACCEL (9400);
9189 case 9500: return GET_ACCEL (9500);
9190 case 9600: return GET_ACCEL (9600);
9191 case 9700: return GET_ACCEL (9700);
9192 case 9710: return GET_ACCEL (9710);
9193 case 9720: return GET_ACCEL (9720);
9194 case 9800: return GET_ACCEL (9800);
9195 case 9810: return GET_ACCEL (9810);
9196 case 9820: return GET_ACCEL (9820);
9197 case 9900: return GET_ACCEL (9900);
9198 case 10000: return GET_ACCEL (10000);
9199 case 10100: return GET_ACCEL (10100);
9200 case 10200: return GET_ACCEL (10200);
9201 case 10300: return GET_ACCEL (10300);
9202 case 10400: return GET_ACCEL (10400);
9203 case 10410: return GET_ACCEL (10410);
9204 case 10420: return GET_ACCEL (10420);
9205 case 10500: return GET_ACCEL (10500);
9206 case 10600: return GET_ACCEL (10600);
9207 case 10700: return GET_ACCEL (10700);
9208 case 10800: return GET_ACCEL (10800);
9209 case 10900: return GET_ACCEL (10900);
9210 case 11000: return GET_ACCEL (11000);
9211 case 11100: return GET_ACCEL (11100);
9212 case 11200: return GET_ACCEL (11200);
9213 case 11300: return GET_ACCEL (11300);
9214 case 11400: return GET_ACCEL (11400);
9215 case 11500: return GET_ACCEL (11500);
9216 case 11600: return GET_ACCEL (11600);
9217 case 11700: return GET_ACCEL (11700);
9218 case 11800: return GET_ACCEL (11800);
9219 case 11900: return GET_ACCEL (11900);
9220 case 12000: return GET_ACCEL (12000);
9221 case 12100: return GET_ACCEL (12100);
9222 case 12200: return GET_ACCEL (12200);
9223 case 12300: return GET_ACCEL (12300);
9224 case 12400: return GET_ACCEL (12400);
9225 case 12500: return GET_ACCEL (12500);
9226 case 12600: return GET_ACCEL (12600);
9227 case 12700: return GET_ACCEL (12700);
9228 case 12800: return GET_ACCEL (12800);
9229 case 12900: return GET_ACCEL (12900);
9230 case 13000: return GET_ACCEL (13000);
9237 uint
set_kernel_loops_osx (uint hash_mode
)
9241 case 0: return GET_LOOPS_OSX (0);
9242 case 10: return GET_LOOPS_OSX (10);
9243 case 11: return GET_LOOPS_OSX (11);
9244 case 12: return GET_LOOPS_OSX (12);
9245 case 20: return GET_LOOPS_OSX (20);
9246 case 21: return GET_LOOPS_OSX (21);
9247 case 22: return GET_LOOPS_OSX (22);
9248 case 23: return GET_LOOPS_OSX (23);
9249 case 30: return GET_LOOPS_OSX (30);
9250 case 40: return GET_LOOPS_OSX (40);
9251 case 50: return GET_LOOPS_OSX (50);
9252 case 60: return GET_LOOPS_OSX (60);
9253 case 100: return GET_LOOPS_OSX (100);
9254 case 101: return GET_LOOPS_OSX (101);
9255 case 110: return GET_LOOPS_OSX (110);
9256 case 111: return GET_LOOPS_OSX (111);
9257 case 112: return GET_LOOPS_OSX (112);
9258 case 120: return GET_LOOPS_OSX (120);
9259 case 121: return GET_LOOPS_OSX (121);
9260 case 122: return GET_LOOPS_OSX (122);
9261 case 124: return GET_LOOPS_OSX (124);
9262 case 130: return GET_LOOPS_OSX (130);
9263 case 131: return GET_LOOPS_OSX (131);
9264 case 132: return GET_LOOPS_OSX (132);
9265 case 133: return GET_LOOPS_OSX (133);
9266 case 140: return GET_LOOPS_OSX (140);
9267 case 141: return GET_LOOPS_OSX (141);
9268 case 150: return GET_LOOPS_OSX (150);
9269 case 160: return GET_LOOPS_OSX (160);
9270 case 190: return GET_LOOPS_OSX (190);
9271 case 200: return GET_LOOPS_OSX (200);
9272 case 300: return GET_LOOPS_OSX (300);
9273 case 900: return GET_LOOPS_OSX (900);
9274 case 1000: return GET_LOOPS_OSX (1000);
9275 case 1100: return GET_LOOPS_OSX (1100);
9276 case 1400: return GET_LOOPS_OSX (1400);
9277 case 1410: return GET_LOOPS_OSX (1410);
9278 case 1420: return GET_LOOPS_OSX (1420);
9279 case 1421: return GET_LOOPS_OSX (1421);
9280 case 1430: return GET_LOOPS_OSX (1430);
9281 case 1440: return GET_LOOPS_OSX (1440);
9282 case 1441: return GET_LOOPS_OSX (1441);
9283 case 1450: return GET_LOOPS_OSX (1450);
9284 case 1460: return GET_LOOPS_OSX (1460);
9285 case 1700: return GET_LOOPS_OSX (1700);
9286 case 1710: return GET_LOOPS_OSX (1710);
9287 case 1711: return GET_LOOPS_OSX (1711);
9288 case 1720: return GET_LOOPS_OSX (1720);
9289 case 1722: return GET_LOOPS_OSX (1722);
9290 case 1730: return GET_LOOPS_OSX (1730);
9291 case 1731: return GET_LOOPS_OSX (1731);
9292 case 1740: return GET_LOOPS_OSX (1740);
9293 case 1750: return GET_LOOPS_OSX (1750);
9294 case 1760: return GET_LOOPS_OSX (1760);
9295 case 2400: return GET_LOOPS_OSX (2400);
9296 case 2410: return GET_LOOPS_OSX (2410);
9297 case 2600: return GET_LOOPS_OSX (2600);
9298 case 2611: return GET_LOOPS_OSX (2611);
9299 case 2612: return GET_LOOPS_OSX (2612);
9300 case 2711: return GET_LOOPS_OSX (2711);
9301 case 2811: return GET_LOOPS_OSX (2811);
9302 case 3100: return GET_LOOPS_OSX (3100);
9303 case 3200: return GET_LOOPS_OSX (3200);
9304 case 3710: return GET_LOOPS_OSX (3710);
9305 case 3711: return GET_LOOPS_OSX (3711);
9306 case 3800: return GET_LOOPS_OSX (3800);
9307 case 4300: return GET_LOOPS_OSX (4300);
9308 case 4400: return GET_LOOPS_OSX (4400);
9309 case 4500: return GET_LOOPS_OSX (4500);
9310 case 4700: return GET_LOOPS_OSX (4700);
9311 case 4800: return GET_LOOPS_OSX (4800);
9312 case 4900: return GET_LOOPS_OSX (4900);
9313 case 5000: return GET_LOOPS_OSX (5000);
9314 case 5100: return GET_LOOPS_OSX (5100);
9315 case 5300: return GET_LOOPS_OSX (5300);
9316 case 5400: return GET_LOOPS_OSX (5400);
9317 case 5500: return GET_LOOPS_OSX (5500);
9318 case 5600: return GET_LOOPS_OSX (5600);
9319 case 5700: return GET_LOOPS_OSX (5700);
9320 case 6000: return GET_LOOPS_OSX (6000);
9321 case 6100: return GET_LOOPS_OSX (6100);
9322 case 6231: return GET_LOOPS_OSX (6231);
9323 case 6232: return GET_LOOPS_OSX (6232);
9324 case 6233: return GET_LOOPS_OSX (6233);
9325 case 6900: return GET_LOOPS_OSX (6900);
9326 case 7300: return GET_LOOPS_OSX (7300);
9327 case 7500: return GET_LOOPS_OSX (7500);
9328 case 7600: return GET_LOOPS_OSX (7600);
9329 case 7700: return GET_LOOPS_OSX (7700);
9330 case 7800: return GET_LOOPS_OSX (7800);
9331 case 8000: return GET_LOOPS_OSX (8000);
9332 case 8100: return GET_LOOPS_OSX (8100);
9333 case 8200: return GET_LOOPS_OSX (8200);
9334 case 8300: return GET_LOOPS_OSX (8300);
9335 case 8400: return GET_LOOPS_OSX (8400);
9336 case 8500: return GET_LOOPS_OSX (8500);
9337 case 8600: return GET_LOOPS_OSX (8600);
9338 case 8700: return GET_LOOPS_OSX (8700);
9339 case 9700: return GET_LOOPS_OSX (9700);
9340 case 9710: return GET_LOOPS_OSX (9710);
9341 case 9720: return GET_LOOPS_OSX (9720);
9342 case 9800: return GET_LOOPS_OSX (9800);
9343 case 9810: return GET_LOOPS_OSX (9810);
9344 case 9820: return GET_LOOPS_OSX (9820);
9345 case 9900: return GET_LOOPS_OSX (9900);
9346 case 10100: return GET_LOOPS_OSX (10100);
9347 case 10200: return GET_LOOPS_OSX (10200);
9348 case 10400: return GET_LOOPS_OSX (10400);
9349 case 10410: return GET_LOOPS_OSX (10410);
9350 case 10420: return GET_LOOPS_OSX (10420);
9351 case 10600: return GET_LOOPS_OSX (10600);
9352 case 10700: return GET_LOOPS_OSX (10700);
9353 case 10800: return GET_LOOPS_OSX (10800);
9354 case 11000: return GET_LOOPS_OSX (11000);
9355 case 11100: return GET_LOOPS_OSX (11100);
9356 case 11200: return GET_LOOPS_OSX (11200);
9357 case 11300: return GET_LOOPS_OSX (11300);
9358 case 11400: return GET_LOOPS_OSX (11400);
9359 case 11500: return GET_LOOPS_OSX (11500);
9360 case 11700: return GET_LOOPS_OSX (11700);
9361 case 11800: return GET_LOOPS_OSX (11800);
9362 case 12600: return GET_LOOPS_OSX (12600);
9368 uint
set_kernel_loops (uint hash_mode
, bool isGpu
)
9372 loops
= set_kernel_loops_osx (hash_mode
);
9379 uint
set_kernel_loops (uint hash_mode
)
9386 case 0: return GET_LOOPS (0);
9387 case 10: return GET_LOOPS (10);
9388 case 11: return GET_LOOPS (11);
9389 case 12: return GET_LOOPS (12);
9390 case 20: return GET_LOOPS (20);
9391 case 21: return GET_LOOPS (21);
9392 case 22: return GET_LOOPS (22);
9393 case 23: return GET_LOOPS (23);
9394 case 30: return GET_LOOPS (30);
9395 case 40: return GET_LOOPS (40);
9396 case 50: return GET_LOOPS (50);
9397 case 60: return GET_LOOPS (60);
9398 case 100: return GET_LOOPS (100);
9399 case 101: return GET_LOOPS (101);
9400 case 110: return GET_LOOPS (110);
9401 case 111: return GET_LOOPS (111);
9402 case 112: return GET_LOOPS (112);
9403 case 120: return GET_LOOPS (120);
9404 case 121: return GET_LOOPS (121);
9405 case 122: return GET_LOOPS (122);
9406 case 124: return GET_LOOPS (124);
9407 case 130: return GET_LOOPS (130);
9408 case 131: return GET_LOOPS (131);
9409 case 132: return GET_LOOPS (132);
9410 case 133: return GET_LOOPS (133);
9411 case 140: return GET_LOOPS (140);
9412 case 141: return GET_LOOPS (141);
9413 case 150: return GET_LOOPS (150);
9414 case 160: return GET_LOOPS (160);
9415 case 190: return GET_LOOPS (190);
9416 case 200: return GET_LOOPS (200);
9417 case 300: return GET_LOOPS (300);
9418 case 400: return GET_LOOPS (400);
9419 case 500: return GET_LOOPS (500);
9420 case 501: return GET_LOOPS (501);
9421 case 900: return GET_LOOPS (900);
9422 case 910: return GET_LOOPS (910);
9423 case 1000: return GET_LOOPS (1000);
9424 case 1100: return GET_LOOPS (1100);
9425 case 1400: return GET_LOOPS (1400);
9426 case 1410: return GET_LOOPS (1410);
9427 case 1420: return GET_LOOPS (1420);
9428 case 1421: return GET_LOOPS (1421);
9429 case 1430: return GET_LOOPS (1430);
9430 case 1440: return GET_LOOPS (1440);
9431 case 1441: return GET_LOOPS (1441);
9432 case 1450: return GET_LOOPS (1450);
9433 case 1460: return GET_LOOPS (1460);
9434 case 1500: return GET_LOOPS (1500);
9435 case 1600: return GET_LOOPS (1600);
9436 case 1700: return GET_LOOPS (1700);
9437 case 1710: return GET_LOOPS (1710);
9438 case 1711: return GET_LOOPS (1711);
9439 case 1720: return GET_LOOPS (1720);
9440 case 1722: return GET_LOOPS (1722);
9441 case 1730: return GET_LOOPS (1730);
9442 case 1731: return GET_LOOPS (1731);
9443 case 1740: return GET_LOOPS (1740);
9444 case 1750: return GET_LOOPS (1750);
9445 case 1760: return GET_LOOPS (1760);
9446 case 1800: return GET_LOOPS (1800);
9447 case 2100: return GET_LOOPS (2100);
9448 case 2400: return GET_LOOPS (2400);
9449 case 2410: return GET_LOOPS (2410);
9450 case 2500: return GET_LOOPS (2500);
9451 case 2600: return GET_LOOPS (2600);
9452 case 2611: return GET_LOOPS (2611);
9453 case 2612: return GET_LOOPS (2612);
9454 case 2711: return GET_LOOPS (2711);
9455 case 2811: return GET_LOOPS (2811);
9456 case 3000: return GET_LOOPS (3000);
9457 case 3100: return GET_LOOPS (3100);
9458 case 3200: return GET_LOOPS (3200);
9459 case 3710: return GET_LOOPS (3710);
9460 case 3711: return GET_LOOPS (3711);
9461 case 3800: return GET_LOOPS (3800);
9462 case 4300: return GET_LOOPS (4300);
9463 case 4400: return GET_LOOPS (4400);
9464 case 4500: return GET_LOOPS (4500);
9465 case 4700: return GET_LOOPS (4700);
9466 case 4800: return GET_LOOPS (4800);
9467 case 4900: return GET_LOOPS (4900);
9468 case 5000: return GET_LOOPS (5000);
9469 case 5100: return GET_LOOPS (5100);
9470 case 5200: return GET_LOOPS (5200);
9471 case 5300: return GET_LOOPS (5300);
9472 case 5400: return GET_LOOPS (5400);
9473 case 5500: return GET_LOOPS (5500);
9474 case 5600: return GET_LOOPS (5600);
9475 case 5700: return GET_LOOPS (5700);
9476 case 5800: return GET_LOOPS (5800);
9477 case 6000: return GET_LOOPS (6000);
9478 case 6100: return GET_LOOPS (6100);
9479 case 6211: return GET_LOOPS (6211);
9480 case 6212: return GET_LOOPS (6212);
9481 case 6213: return GET_LOOPS (6213);
9482 case 6221: return GET_LOOPS (6221);
9483 case 6222: return GET_LOOPS (6222);
9484 case 6223: return GET_LOOPS (6223);
9485 case 6231: return GET_LOOPS (6231);
9486 case 6232: return GET_LOOPS (6232);
9487 case 6233: return GET_LOOPS (6233);
9488 case 6241: return GET_LOOPS (6241);
9489 case 6242: return GET_LOOPS (6242);
9490 case 6243: return GET_LOOPS (6243);
9491 case 6300: return GET_LOOPS (6300);
9492 case 6400: return GET_LOOPS (6400);
9493 case 6500: return GET_LOOPS (6500);
9494 case 6600: return GET_LOOPS (6600);
9495 case 6700: return GET_LOOPS (6700);
9496 case 6800: return GET_LOOPS (6800);
9497 case 6900: return GET_LOOPS (6900);
9498 case 7100: return GET_LOOPS (7100);
9499 case 7200: return GET_LOOPS (7200);
9500 case 7300: return GET_LOOPS (7300);
9501 case 7400: return GET_LOOPS (7400);
9502 case 7500: return GET_LOOPS (7500);
9503 case 7600: return GET_LOOPS (7600);
9504 case 7700: return GET_LOOPS (7700);
9505 case 7800: return GET_LOOPS (7800);
9506 case 7900: return GET_LOOPS (7900);
9507 case 8000: return GET_LOOPS (8000);
9508 case 8100: return GET_LOOPS (8100);
9509 case 8200: return GET_LOOPS (8200);
9510 case 8300: return GET_LOOPS (8300);
9511 case 8400: return GET_LOOPS (8400);
9512 case 8500: return GET_LOOPS (8500);
9513 case 8600: return GET_LOOPS (8600);
9514 case 8700: return GET_LOOPS (8700);
9515 case 8800: return GET_LOOPS (8800);
9516 case 8900: return GET_LOOPS (8900);
9517 case 9000: return GET_LOOPS (9000);
9518 case 9100: return GET_LOOPS (9100);
9519 case 9200: return GET_LOOPS (9200);
9520 case 9300: return GET_LOOPS (9300);
9521 case 9400: return GET_LOOPS (9400);
9522 case 9500: return GET_LOOPS (9500);
9523 case 9600: return GET_LOOPS (9600);
9524 case 9700: return GET_LOOPS (9700);
9525 case 9710: return GET_LOOPS (9710);
9526 case 9720: return GET_LOOPS (9720);
9527 case 9800: return GET_LOOPS (9800);
9528 case 9810: return GET_LOOPS (9810);
9529 case 9820: return GET_LOOPS (9820);
9530 case 9900: return GET_LOOPS (9900);
9531 case 10000: return GET_LOOPS (10000);
9532 case 10100: return GET_LOOPS (10100);
9533 case 10200: return GET_LOOPS (10200);
9534 case 10300: return GET_LOOPS (10300);
9535 case 10400: return GET_LOOPS (10400);
9536 case 10410: return GET_LOOPS (10410);
9537 case 10420: return GET_LOOPS (10420);
9538 case 10500: return GET_LOOPS (10500);
9539 case 10600: return GET_LOOPS (10600);
9540 case 10700: return GET_LOOPS (10700);
9541 case 10800: return GET_LOOPS (10800);
9542 case 10900: return GET_LOOPS (10900);
9543 case 11000: return GET_LOOPS (11000);
9544 case 11100: return GET_LOOPS (11100);
9545 case 11200: return GET_LOOPS (11200);
9546 case 11300: return GET_LOOPS (11300);
9547 case 11400: return GET_LOOPS (11400);
9548 case 11500: return GET_LOOPS (11500);
9549 case 11600: return GET_LOOPS (11600);
9550 case 11700: return GET_LOOPS (11700);
9551 case 11800: return GET_LOOPS (11800);
9552 case 11900: return GET_LOOPS (11900);
9553 case 12000: return GET_LOOPS (12000);
9554 case 12100: return GET_LOOPS (12100);
9555 case 12200: return GET_LOOPS (12200);
9556 case 12300: return GET_LOOPS (12300);
9557 case 12400: return GET_LOOPS (12400);
9558 case 12500: return GET_LOOPS (12500);
9559 case 12600: return GET_LOOPS (12600);
9560 case 12700: return GET_LOOPS (12700);
9561 case 12800: return GET_LOOPS (12800);
9562 case 12900: return GET_LOOPS (12900);
9563 case 13000: return GET_LOOPS (13000);
9573 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9575 u8 tmp
[256] = { 0 };
9577 if (salt_len
> sizeof (tmp
))
9582 memcpy (tmp
, in
, salt_len
);
9584 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9586 if ((salt_len
% 2) == 0)
9588 u32 new_salt_len
= salt_len
/ 2;
9590 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9595 tmp
[i
] = hex_convert (p1
) << 0;
9596 tmp
[i
] |= hex_convert (p0
) << 4;
9599 salt_len
= new_salt_len
;
9606 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9608 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9611 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9613 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9617 u32
*tmp_uint
= (u32
*) tmp
;
9619 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9620 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9621 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9622 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9623 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9624 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9625 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9626 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9627 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9628 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9630 salt_len
= salt_len
* 2;
9638 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9640 lowercase (tmp
, salt_len
);
9643 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9645 uppercase (tmp
, salt_len
);
9650 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9655 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9660 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9662 u32
*tmp_uint
= (uint
*) tmp
;
9668 for (u32 i
= 0; i
< max
; i
++)
9670 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9673 // Important: we may need to increase the length of memcpy since
9674 // we don't want to "loose" some swapped bytes (could happen if
9675 // they do not perfectly fit in the 4-byte blocks)
9676 // Memcpy does always copy the bytes in the BE order, but since
9677 // we swapped them, some important bytes could be in positions
9678 // we normally skip with the original len
9680 if (len
% 4) len
+= 4 - (len
% 4);
9683 memcpy (out
, tmp
, len
);
9688 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9690 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9692 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9694 u32
*digest
= (u32
*) hash_buf
->digest
;
9696 salt_t
*salt
= hash_buf
->salt
;
9698 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9700 char *iter_pos
= input_buf
+ 4;
9702 salt
->salt_iter
= 1 << atoi (iter_pos
);
9704 char *salt_pos
= strchr (iter_pos
, '$');
9706 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9712 salt
->salt_len
= salt_len
;
9714 u8 tmp_buf
[100] = { 0 };
9716 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9718 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9720 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9722 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9723 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9724 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9725 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9727 char *hash_pos
= salt_pos
+ 22;
9729 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9731 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9733 memcpy (digest
, tmp_buf
, 24);
9735 digest
[0] = byte_swap_32 (digest
[0]);
9736 digest
[1] = byte_swap_32 (digest
[1]);
9737 digest
[2] = byte_swap_32 (digest
[2]);
9738 digest
[3] = byte_swap_32 (digest
[3]);
9739 digest
[4] = byte_swap_32 (digest
[4]);
9740 digest
[5] = byte_swap_32 (digest
[5]);
9742 digest
[5] &= ~0xff; // its just 23 not 24 !
9747 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9749 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9751 u32
*digest
= (u32
*) hash_buf
->digest
;
9753 u8 tmp_buf
[100] = { 0 };
9755 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9757 memcpy (digest
, tmp_buf
, 32);
9759 digest
[0] = byte_swap_32 (digest
[0]);
9760 digest
[1] = byte_swap_32 (digest
[1]);
9761 digest
[2] = byte_swap_32 (digest
[2]);
9762 digest
[3] = byte_swap_32 (digest
[3]);
9763 digest
[4] = byte_swap_32 (digest
[4]);
9764 digest
[5] = byte_swap_32 (digest
[5]);
9765 digest
[6] = byte_swap_32 (digest
[6]);
9766 digest
[7] = byte_swap_32 (digest
[7]);
9768 digest
[0] -= SHA256M_A
;
9769 digest
[1] -= SHA256M_B
;
9770 digest
[2] -= SHA256M_C
;
9771 digest
[3] -= SHA256M_D
;
9772 digest
[4] -= SHA256M_E
;
9773 digest
[5] -= SHA256M_F
;
9774 digest
[6] -= SHA256M_G
;
9775 digest
[7] -= SHA256M_H
;
9780 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9782 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9784 u32
*digest
= (u32
*) hash_buf
->digest
;
9786 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9787 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9789 digest
[0] = byte_swap_32 (digest
[0]);
9790 digest
[1] = byte_swap_32 (digest
[1]);
9794 IP (digest
[0], digest
[1], tt
);
9796 digest
[0] = digest
[0];
9797 digest
[1] = digest
[1];
9804 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9806 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9808 u32
*digest
= (u32
*) hash_buf
->digest
;
9810 salt_t
*salt
= hash_buf
->salt
;
9812 char *hash_pos
= input_buf
+ 8;
9814 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9815 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9816 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9817 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9818 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9820 digest
[0] -= SHA1M_A
;
9821 digest
[1] -= SHA1M_B
;
9822 digest
[2] -= SHA1M_C
;
9823 digest
[3] -= SHA1M_D
;
9824 digest
[4] -= SHA1M_E
;
9828 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9830 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9832 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9834 salt
->salt_len
= salt_len
;
9839 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9841 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9843 u64
*digest
= (u64
*) hash_buf
->digest
;
9845 salt_t
*salt
= hash_buf
->salt
;
9847 char *hash_pos
= input_buf
+ 8;
9849 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9850 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9851 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9852 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9853 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9854 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9855 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9856 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9858 digest
[0] -= SHA512M_A
;
9859 digest
[1] -= SHA512M_B
;
9860 digest
[2] -= SHA512M_C
;
9861 digest
[3] -= SHA512M_D
;
9862 digest
[4] -= SHA512M_E
;
9863 digest
[5] -= SHA512M_F
;
9864 digest
[6] -= SHA512M_G
;
9865 digest
[7] -= SHA512M_H
;
9869 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9871 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9873 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9875 salt
->salt_len
= salt_len
;
9880 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9882 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9884 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9888 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9891 u32
*digest
= (u32
*) hash_buf
->digest
;
9893 salt_t
*salt
= hash_buf
->salt
;
9895 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9896 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9897 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9898 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9900 digest
[0] = byte_swap_32 (digest
[0]);
9901 digest
[1] = byte_swap_32 (digest
[1]);
9902 digest
[2] = byte_swap_32 (digest
[2]);
9903 digest
[3] = byte_swap_32 (digest
[3]);
9905 digest
[0] -= MD5M_A
;
9906 digest
[1] -= MD5M_B
;
9907 digest
[2] -= MD5M_C
;
9908 digest
[3] -= MD5M_D
;
9910 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9912 uint salt_len
= input_len
- 32 - 1;
9914 char *salt_buf
= input_buf
+ 32 + 1;
9916 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9918 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9920 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9922 salt
->salt_len
= salt_len
;
9927 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9929 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9931 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9935 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9940 char clean_input_buf
[32] = { 0 };
9942 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9943 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9945 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9949 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9955 clean_input_buf
[k
] = input_buf
[i
];
9963 u32
*digest
= (u32
*) hash_buf
->digest
;
9965 salt_t
*salt
= hash_buf
->salt
;
9967 u32 a
, b
, c
, d
, e
, f
;
9969 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9970 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9971 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9972 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9973 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9974 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9976 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9977 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9979 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9980 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9981 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9982 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9983 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9984 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9986 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9987 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9989 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9990 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9991 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9992 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9993 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9994 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9996 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9997 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9999 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10000 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10001 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10002 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10003 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10004 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10006 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10007 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10009 digest
[0] = byte_swap_32 (digest
[0]);
10010 digest
[1] = byte_swap_32 (digest
[1]);
10011 digest
[2] = byte_swap_32 (digest
[2]);
10012 digest
[3] = byte_swap_32 (digest
[3]);
10014 digest
[0] -= MD5M_A
;
10015 digest
[1] -= MD5M_B
;
10016 digest
[2] -= MD5M_C
;
10017 digest
[3] -= MD5M_D
;
10019 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10021 uint salt_len
= input_len
- 30 - 1;
10023 char *salt_buf
= input_buf
+ 30 + 1;
10025 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10027 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10029 // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
10030 if (salt_len
> 10) return (PARSER_SALT_LENGTH
);
10032 salt
->salt_len
= salt_len
;
10034 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10036 salt
->salt_len
+= 22;
10038 return (PARSER_OK
);
10041 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10043 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10045 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10049 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10052 u32
*digest
= (u32
*) hash_buf
->digest
;
10054 salt_t
*salt
= hash_buf
->salt
;
10056 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10057 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10058 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10059 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10060 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10062 digest
[0] -= SHA1M_A
;
10063 digest
[1] -= SHA1M_B
;
10064 digest
[2] -= SHA1M_C
;
10065 digest
[3] -= SHA1M_D
;
10066 digest
[4] -= SHA1M_E
;
10068 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10070 uint salt_len
= input_len
- 40 - 1;
10072 char *salt_buf
= input_buf
+ 40 + 1;
10074 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10076 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10078 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10080 salt
->salt_len
= salt_len
;
10082 return (PARSER_OK
);
10085 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10087 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10089 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10093 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10096 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10098 char *iter_pos
= input_buf
+ 6;
10100 salt_t
*salt
= hash_buf
->salt
;
10102 uint iter
= atoi (iter_pos
);
10106 iter
= ROUNDS_DCC2
;
10109 salt
->salt_iter
= iter
- 1;
10111 char *salt_pos
= strchr (iter_pos
, '#');
10113 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10117 char *digest_pos
= strchr (salt_pos
, '#');
10119 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10123 uint salt_len
= digest_pos
- salt_pos
- 1;
10125 u32
*digest
= (u32
*) hash_buf
->digest
;
10127 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10128 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10129 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10130 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10132 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10134 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10136 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10138 salt
->salt_len
= salt_len
;
10140 return (PARSER_OK
);
10143 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10145 u32
*digest
= (u32
*) hash_buf
->digest
;
10147 salt_t
*salt
= hash_buf
->salt
;
10149 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10153 memcpy (&in
, input_buf
, input_len
);
10155 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10157 memcpy (digest
, in
.keymic
, 16);
10160 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10161 The phrase "Pairwise key expansion"
10162 Access Point Address (referred to as Authenticator Address AA)
10163 Supplicant Address (referred to as Supplicant Address SA)
10164 Access Point Nonce (referred to as Authenticator Anonce)
10165 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10168 uint salt_len
= strlen (in
.essid
);
10170 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10172 salt
->salt_len
= salt_len
;
10174 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10176 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10178 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10180 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10182 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10183 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10187 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10188 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10191 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10193 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10194 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10198 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10199 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10202 for (int i
= 0; i
< 25; i
++)
10204 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10207 wpa
->keyver
= in
.keyver
;
10209 if (wpa
->keyver
> 255)
10211 log_info ("ATTENTION!");
10212 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10213 log_info (" This could be due to a recent aircrack-ng bug.");
10214 log_info (" The key version was automatically reset to a reasonable value.");
10217 wpa
->keyver
&= 0xff;
10220 wpa
->eapol_size
= in
.eapol_size
;
10222 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10224 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10226 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10228 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10230 if (wpa
->keyver
== 1)
10236 digest
[0] = byte_swap_32 (digest
[0]);
10237 digest
[1] = byte_swap_32 (digest
[1]);
10238 digest
[2] = byte_swap_32 (digest
[2]);
10239 digest
[3] = byte_swap_32 (digest
[3]);
10241 for (int i
= 0; i
< 64; i
++)
10243 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10247 salt
->salt_buf
[10] = digest
[1];
10248 salt
->salt_buf
[11] = digest
[2];
10250 return (PARSER_OK
);
10253 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10255 u32
*digest
= (u32
*) hash_buf
->digest
;
10257 salt_t
*salt
= hash_buf
->salt
;
10259 if (input_len
== 0)
10261 log_error ("Password Safe v2 container not specified");
10266 FILE *fp
= fopen (input_buf
, "rb");
10270 log_error ("%s: %s", input_buf
, strerror (errno
));
10277 memset (&buf
, 0, sizeof (psafe2_hdr
));
10279 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10283 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10285 salt
->salt_buf
[0] = buf
.random
[0];
10286 salt
->salt_buf
[1] = buf
.random
[1];
10288 salt
->salt_len
= 8;
10289 salt
->salt_iter
= 1000;
10291 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10292 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10293 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10294 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10295 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10297 return (PARSER_OK
);
10300 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10302 u32
*digest
= (u32
*) hash_buf
->digest
;
10304 salt_t
*salt
= hash_buf
->salt
;
10306 if (input_len
== 0)
10308 log_error (".psafe3 not specified");
10313 FILE *fp
= fopen (input_buf
, "rb");
10317 log_error ("%s: %s", input_buf
, strerror (errno
));
10324 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10328 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10330 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10332 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10334 salt
->salt_iter
= in
.iterations
+ 1;
10336 salt
->salt_buf
[0] = in
.salt_buf
[0];
10337 salt
->salt_buf
[1] = in
.salt_buf
[1];
10338 salt
->salt_buf
[2] = in
.salt_buf
[2];
10339 salt
->salt_buf
[3] = in
.salt_buf
[3];
10340 salt
->salt_buf
[4] = in
.salt_buf
[4];
10341 salt
->salt_buf
[5] = in
.salt_buf
[5];
10342 salt
->salt_buf
[6] = in
.salt_buf
[6];
10343 salt
->salt_buf
[7] = in
.salt_buf
[7];
10345 salt
->salt_len
= 32;
10347 digest
[0] = in
.hash_buf
[0];
10348 digest
[1] = in
.hash_buf
[1];
10349 digest
[2] = in
.hash_buf
[2];
10350 digest
[3] = in
.hash_buf
[3];
10351 digest
[4] = in
.hash_buf
[4];
10352 digest
[5] = in
.hash_buf
[5];
10353 digest
[6] = in
.hash_buf
[6];
10354 digest
[7] = in
.hash_buf
[7];
10356 digest
[0] = byte_swap_32 (digest
[0]);
10357 digest
[1] = byte_swap_32 (digest
[1]);
10358 digest
[2] = byte_swap_32 (digest
[2]);
10359 digest
[3] = byte_swap_32 (digest
[3]);
10360 digest
[4] = byte_swap_32 (digest
[4]);
10361 digest
[5] = byte_swap_32 (digest
[5]);
10362 digest
[6] = byte_swap_32 (digest
[6]);
10363 digest
[7] = byte_swap_32 (digest
[7]);
10365 return (PARSER_OK
);
10368 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10370 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10372 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10374 u32
*digest
= (u32
*) hash_buf
->digest
;
10376 salt_t
*salt
= hash_buf
->salt
;
10378 char *iter_pos
= input_buf
+ 3;
10380 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10382 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10384 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10386 salt
->salt_iter
= salt_iter
;
10388 char *salt_pos
= iter_pos
+ 1;
10392 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10394 salt
->salt_len
= salt_len
;
10396 char *hash_pos
= salt_pos
+ salt_len
;
10398 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10400 return (PARSER_OK
);
10403 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10405 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10407 u32
*digest
= (u32
*) hash_buf
->digest
;
10409 salt_t
*salt
= hash_buf
->salt
;
10411 char *salt_pos
= input_buf
+ 3;
10413 uint iterations_len
= 0;
10415 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10419 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10421 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10422 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10426 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10430 iterations_len
+= 8;
10434 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10437 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10439 char *hash_pos
= strchr (salt_pos
, '$');
10441 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10443 uint salt_len
= hash_pos
- salt_pos
;
10445 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10447 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10449 salt
->salt_len
= salt_len
;
10453 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10455 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10457 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10459 return (PARSER_OK
);
10462 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10464 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10466 u32
*digest
= (u32
*) hash_buf
->digest
;
10468 salt_t
*salt
= hash_buf
->salt
;
10470 char *salt_pos
= input_buf
+ 6;
10472 uint iterations_len
= 0;
10474 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10478 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10480 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10481 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10485 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10489 iterations_len
+= 8;
10493 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10496 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10498 char *hash_pos
= strchr (salt_pos
, '$');
10500 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10502 uint salt_len
= hash_pos
- salt_pos
;
10504 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10506 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10508 salt
->salt_len
= salt_len
;
10512 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10514 return (PARSER_OK
);
10517 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10519 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10521 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10523 u32
*digest
= (u32
*) hash_buf
->digest
;
10525 salt_t
*salt
= hash_buf
->salt
;
10527 char *salt_pos
= input_buf
+ 14;
10529 char *hash_pos
= strchr (salt_pos
, '*');
10531 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10535 uint salt_len
= hash_pos
- salt_pos
- 1;
10537 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10539 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10541 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10543 salt
->salt_len
= salt_len
;
10545 u8 tmp_buf
[100] = { 0 };
10547 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10549 memcpy (digest
, tmp_buf
, 20);
10551 digest
[0] = byte_swap_32 (digest
[0]);
10552 digest
[1] = byte_swap_32 (digest
[1]);
10553 digest
[2] = byte_swap_32 (digest
[2]);
10554 digest
[3] = byte_swap_32 (digest
[3]);
10555 digest
[4] = byte_swap_32 (digest
[4]);
10557 digest
[0] -= SHA1M_A
;
10558 digest
[1] -= SHA1M_B
;
10559 digest
[2] -= SHA1M_C
;
10560 digest
[3] -= SHA1M_D
;
10561 digest
[4] -= SHA1M_E
;
10563 return (PARSER_OK
);
10566 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10568 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10570 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10572 if (c12
& 3) return (PARSER_HASH_VALUE
);
10574 u32
*digest
= (u32
*) hash_buf
->digest
;
10576 salt_t
*salt
= hash_buf
->salt
;
10578 // for ascii_digest
10579 salt
->salt_sign
[0] = input_buf
[0];
10580 salt
->salt_sign
[1] = input_buf
[1];
10582 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10583 | itoa64_to_int (input_buf
[1]) << 6;
10585 salt
->salt_len
= 2;
10587 u8 tmp_buf
[100] = { 0 };
10589 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10591 memcpy (digest
, tmp_buf
, 8);
10595 IP (digest
[0], digest
[1], tt
);
10600 return (PARSER_OK
);
10603 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10605 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10607 u32
*digest
= (u32
*) hash_buf
->digest
;
10609 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10610 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10611 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10612 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10614 digest
[0] = byte_swap_32 (digest
[0]);
10615 digest
[1] = byte_swap_32 (digest
[1]);
10616 digest
[2] = byte_swap_32 (digest
[2]);
10617 digest
[3] = byte_swap_32 (digest
[3]);
10619 digest
[0] -= MD4M_A
;
10620 digest
[1] -= MD4M_B
;
10621 digest
[2] -= MD4M_C
;
10622 digest
[3] -= MD4M_D
;
10624 return (PARSER_OK
);
10627 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10629 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10631 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10635 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10638 u32
*digest
= (u32
*) hash_buf
->digest
;
10640 salt_t
*salt
= hash_buf
->salt
;
10642 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10643 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10644 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10645 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10647 digest
[0] = byte_swap_32 (digest
[0]);
10648 digest
[1] = byte_swap_32 (digest
[1]);
10649 digest
[2] = byte_swap_32 (digest
[2]);
10650 digest
[3] = byte_swap_32 (digest
[3]);
10652 digest
[0] -= MD4M_A
;
10653 digest
[1] -= MD4M_B
;
10654 digest
[2] -= MD4M_C
;
10655 digest
[3] -= MD4M_D
;
10657 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10659 uint salt_len
= input_len
- 32 - 1;
10661 char *salt_buf
= input_buf
+ 32 + 1;
10663 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10665 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10667 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10669 salt
->salt_len
= salt_len
;
10671 return (PARSER_OK
);
10674 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10676 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10678 u32
*digest
= (u32
*) hash_buf
->digest
;
10680 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10681 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10682 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10683 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10685 digest
[0] = byte_swap_32 (digest
[0]);
10686 digest
[1] = byte_swap_32 (digest
[1]);
10687 digest
[2] = byte_swap_32 (digest
[2]);
10688 digest
[3] = byte_swap_32 (digest
[3]);
10690 digest
[0] -= MD5M_A
;
10691 digest
[1] -= MD5M_B
;
10692 digest
[2] -= MD5M_C
;
10693 digest
[3] -= MD5M_D
;
10695 return (PARSER_OK
);
10698 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10700 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10702 u32
*digest
= (u32
*) hash_buf
->digest
;
10704 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10705 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10709 digest
[0] = byte_swap_32 (digest
[0]);
10710 digest
[1] = byte_swap_32 (digest
[1]);
10712 return (PARSER_OK
);
10715 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10717 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10719 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10723 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10726 u32
*digest
= (u32
*) hash_buf
->digest
;
10728 salt_t
*salt
= hash_buf
->salt
;
10730 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10731 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10732 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10733 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10735 digest
[0] = byte_swap_32 (digest
[0]);
10736 digest
[1] = byte_swap_32 (digest
[1]);
10737 digest
[2] = byte_swap_32 (digest
[2]);
10738 digest
[3] = byte_swap_32 (digest
[3]);
10740 digest
[0] -= MD5M_A
;
10741 digest
[1] -= MD5M_B
;
10742 digest
[2] -= MD5M_C
;
10743 digest
[3] -= MD5M_D
;
10745 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10747 uint salt_len
= input_len
- 32 - 1;
10749 char *salt_buf
= input_buf
+ 32 + 1;
10751 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10753 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10755 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10757 salt
->salt_len
= salt_len
;
10759 return (PARSER_OK
);
10762 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10764 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10766 u32
*digest
= (u32
*) hash_buf
->digest
;
10768 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10769 | itoa64_to_int (input_buf
[ 1]) << 6
10770 | itoa64_to_int (input_buf
[ 2]) << 12
10771 | itoa64_to_int (input_buf
[ 3]) << 18;
10772 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10773 | itoa64_to_int (input_buf
[ 5]) << 6
10774 | itoa64_to_int (input_buf
[ 6]) << 12
10775 | itoa64_to_int (input_buf
[ 7]) << 18;
10776 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10777 | itoa64_to_int (input_buf
[ 9]) << 6
10778 | itoa64_to_int (input_buf
[10]) << 12
10779 | itoa64_to_int (input_buf
[11]) << 18;
10780 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10781 | itoa64_to_int (input_buf
[13]) << 6
10782 | itoa64_to_int (input_buf
[14]) << 12
10783 | itoa64_to_int (input_buf
[15]) << 18;
10785 digest
[0] -= MD5M_A
;
10786 digest
[1] -= MD5M_B
;
10787 digest
[2] -= MD5M_C
;
10788 digest
[3] -= MD5M_D
;
10790 digest
[0] &= 0x00ffffff;
10791 digest
[1] &= 0x00ffffff;
10792 digest
[2] &= 0x00ffffff;
10793 digest
[3] &= 0x00ffffff;
10795 return (PARSER_OK
);
10798 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10800 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10802 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10806 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10809 u32
*digest
= (u32
*) hash_buf
->digest
;
10811 salt_t
*salt
= hash_buf
->salt
;
10813 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10814 | itoa64_to_int (input_buf
[ 1]) << 6
10815 | itoa64_to_int (input_buf
[ 2]) << 12
10816 | itoa64_to_int (input_buf
[ 3]) << 18;
10817 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10818 | itoa64_to_int (input_buf
[ 5]) << 6
10819 | itoa64_to_int (input_buf
[ 6]) << 12
10820 | itoa64_to_int (input_buf
[ 7]) << 18;
10821 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10822 | itoa64_to_int (input_buf
[ 9]) << 6
10823 | itoa64_to_int (input_buf
[10]) << 12
10824 | itoa64_to_int (input_buf
[11]) << 18;
10825 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10826 | itoa64_to_int (input_buf
[13]) << 6
10827 | itoa64_to_int (input_buf
[14]) << 12
10828 | itoa64_to_int (input_buf
[15]) << 18;
10830 digest
[0] -= MD5M_A
;
10831 digest
[1] -= MD5M_B
;
10832 digest
[2] -= MD5M_C
;
10833 digest
[3] -= MD5M_D
;
10835 digest
[0] &= 0x00ffffff;
10836 digest
[1] &= 0x00ffffff;
10837 digest
[2] &= 0x00ffffff;
10838 digest
[3] &= 0x00ffffff;
10840 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10842 uint salt_len
= input_len
- 16 - 1;
10844 char *salt_buf
= input_buf
+ 16 + 1;
10846 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10848 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10850 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10852 salt
->salt_len
= salt_len
;
10854 return (PARSER_OK
);
10857 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10859 key
[0] = (nthash
[0] >> 0);
10860 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10861 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10862 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10863 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10864 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10865 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10866 key
[7] = (nthash
[6] << 1);
10878 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10880 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10882 u32
*digest
= (u32
*) hash_buf
->digest
;
10884 salt_t
*salt
= hash_buf
->salt
;
10886 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10892 char *user_pos
= input_buf
;
10894 char *unused_pos
= strchr (user_pos
, ':');
10896 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10898 uint user_len
= unused_pos
- user_pos
;
10900 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10904 char *domain_pos
= strchr (unused_pos
, ':');
10906 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10908 uint unused_len
= domain_pos
- unused_pos
;
10910 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10914 char *srvchall_pos
= strchr (domain_pos
, ':');
10916 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10918 uint domain_len
= srvchall_pos
- domain_pos
;
10920 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10924 char *hash_pos
= strchr (srvchall_pos
, ':');
10926 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10928 uint srvchall_len
= hash_pos
- srvchall_pos
;
10930 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10934 char *clichall_pos
= strchr (hash_pos
, ':');
10936 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10938 uint hash_len
= clichall_pos
- hash_pos
;
10940 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10944 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10946 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10949 * store some data for later use
10952 netntlm
->user_len
= user_len
* 2;
10953 netntlm
->domain_len
= domain_len
* 2;
10954 netntlm
->srvchall_len
= srvchall_len
/ 2;
10955 netntlm
->clichall_len
= clichall_len
/ 2;
10957 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10958 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10961 * handle username and domainname
10964 for (uint i
= 0; i
< user_len
; i
++)
10966 *userdomain_ptr
++ = user_pos
[i
];
10967 *userdomain_ptr
++ = 0;
10970 for (uint i
= 0; i
< domain_len
; i
++)
10972 *userdomain_ptr
++ = domain_pos
[i
];
10973 *userdomain_ptr
++ = 0;
10977 * handle server challenge encoding
10980 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10982 const char p0
= srvchall_pos
[i
+ 0];
10983 const char p1
= srvchall_pos
[i
+ 1];
10985 *chall_ptr
++ = hex_convert (p1
) << 0
10986 | hex_convert (p0
) << 4;
10990 * handle client challenge encoding
10993 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10995 const char p0
= clichall_pos
[i
+ 0];
10996 const char p1
= clichall_pos
[i
+ 1];
10998 *chall_ptr
++ = hex_convert (p1
) << 0
10999 | hex_convert (p0
) << 4;
11006 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11008 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11010 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11012 salt
->salt_len
= salt_len
;
11014 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11015 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11016 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11017 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11019 digest
[0] = byte_swap_32 (digest
[0]);
11020 digest
[1] = byte_swap_32 (digest
[1]);
11021 digest
[2] = byte_swap_32 (digest
[2]);
11022 digest
[3] = byte_swap_32 (digest
[3]);
11024 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11026 uint digest_tmp
[2] = { 0 };
11028 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11029 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11031 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11032 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11034 /* special case 2: ESS */
11036 if (srvchall_len
== 48)
11038 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11040 uint w
[16] = { 0 };
11042 w
[ 0] = netntlm
->chall_buf
[6];
11043 w
[ 1] = netntlm
->chall_buf
[7];
11044 w
[ 2] = netntlm
->chall_buf
[0];
11045 w
[ 3] = netntlm
->chall_buf
[1];
11049 uint dgst
[4] = { 0 };
11058 salt
->salt_buf
[0] = dgst
[0];
11059 salt
->salt_buf
[1] = dgst
[1];
11063 /* precompute netntlmv1 exploit start */
11065 for (uint i
= 0; i
< 0x10000; i
++)
11067 uint key_md4
[2] = { i
, 0 };
11068 uint key_des
[2] = { 0, 0 };
11070 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11072 uint Kc
[16] = { 0 };
11073 uint Kd
[16] = { 0 };
11075 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11077 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11079 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11081 if (data3
[0] != digest_tmp
[0]) continue;
11082 if (data3
[1] != digest_tmp
[1]) continue;
11084 salt
->salt_buf
[2] = i
;
11086 salt
->salt_len
= 24;
11091 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11092 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11094 /* precompute netntlmv1 exploit stop */
11098 IP (digest
[0], digest
[1], tt
);
11099 IP (digest
[2], digest
[3], tt
);
11101 digest
[0] = rotr32 (digest
[0], 29);
11102 digest
[1] = rotr32 (digest
[1], 29);
11103 digest
[2] = rotr32 (digest
[2], 29);
11104 digest
[3] = rotr32 (digest
[3], 29);
11106 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11108 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11109 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11111 return (PARSER_OK
);
11114 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11116 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11118 u32
*digest
= (u32
*) hash_buf
->digest
;
11120 salt_t
*salt
= hash_buf
->salt
;
11122 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11128 char *user_pos
= input_buf
;
11130 char *unused_pos
= strchr (user_pos
, ':');
11132 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11134 uint user_len
= unused_pos
- user_pos
;
11136 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11140 char *domain_pos
= strchr (unused_pos
, ':');
11142 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11144 uint unused_len
= domain_pos
- unused_pos
;
11146 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11150 char *srvchall_pos
= strchr (domain_pos
, ':');
11152 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11154 uint domain_len
= srvchall_pos
- domain_pos
;
11156 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11160 char *hash_pos
= strchr (srvchall_pos
, ':');
11162 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11164 uint srvchall_len
= hash_pos
- srvchall_pos
;
11166 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11170 char *clichall_pos
= strchr (hash_pos
, ':');
11172 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11174 uint hash_len
= clichall_pos
- hash_pos
;
11176 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11180 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11182 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11184 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11187 * store some data for later use
11190 netntlm
->user_len
= user_len
* 2;
11191 netntlm
->domain_len
= domain_len
* 2;
11192 netntlm
->srvchall_len
= srvchall_len
/ 2;
11193 netntlm
->clichall_len
= clichall_len
/ 2;
11195 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11196 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11199 * handle username and domainname
11202 for (uint i
= 0; i
< user_len
; i
++)
11204 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11205 *userdomain_ptr
++ = 0;
11208 for (uint i
= 0; i
< domain_len
; i
++)
11210 *userdomain_ptr
++ = domain_pos
[i
];
11211 *userdomain_ptr
++ = 0;
11214 *userdomain_ptr
++ = 0x80;
11217 * handle server challenge encoding
11220 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11222 const char p0
= srvchall_pos
[i
+ 0];
11223 const char p1
= srvchall_pos
[i
+ 1];
11225 *chall_ptr
++ = hex_convert (p1
) << 0
11226 | hex_convert (p0
) << 4;
11230 * handle client challenge encoding
11233 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11235 const char p0
= clichall_pos
[i
+ 0];
11236 const char p1
= clichall_pos
[i
+ 1];
11238 *chall_ptr
++ = hex_convert (p1
) << 0
11239 | hex_convert (p0
) << 4;
11242 *chall_ptr
++ = 0x80;
11245 * handle hash itself
11248 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11249 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11250 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11251 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11253 digest
[0] = byte_swap_32 (digest
[0]);
11254 digest
[1] = byte_swap_32 (digest
[1]);
11255 digest
[2] = byte_swap_32 (digest
[2]);
11256 digest
[3] = byte_swap_32 (digest
[3]);
11259 * reuse challange data as salt_buf, its the buffer that is most likely unique
11262 salt
->salt_buf
[0] = 0;
11263 salt
->salt_buf
[1] = 0;
11264 salt
->salt_buf
[2] = 0;
11265 salt
->salt_buf
[3] = 0;
11266 salt
->salt_buf
[4] = 0;
11267 salt
->salt_buf
[5] = 0;
11268 salt
->salt_buf
[6] = 0;
11269 salt
->salt_buf
[7] = 0;
11273 uptr
= (uint
*) netntlm
->userdomain_buf
;
11275 for (uint i
= 0; i
< 16; i
+= 16)
11277 md5_64 (uptr
, salt
->salt_buf
);
11280 uptr
= (uint
*) netntlm
->chall_buf
;
11282 for (uint i
= 0; i
< 256; i
+= 16)
11284 md5_64 (uptr
, salt
->salt_buf
);
11287 salt
->salt_len
= 16;
11289 return (PARSER_OK
);
11292 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11294 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11296 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11300 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11303 u32
*digest
= (u32
*) hash_buf
->digest
;
11305 salt_t
*salt
= hash_buf
->salt
;
11307 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11308 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11309 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11310 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11312 digest
[0] = byte_swap_32 (digest
[0]);
11313 digest
[1] = byte_swap_32 (digest
[1]);
11314 digest
[2] = byte_swap_32 (digest
[2]);
11315 digest
[3] = byte_swap_32 (digest
[3]);
11317 digest
[0] -= MD5M_A
;
11318 digest
[1] -= MD5M_B
;
11319 digest
[2] -= MD5M_C
;
11320 digest
[3] -= MD5M_D
;
11322 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11324 uint salt_len
= input_len
- 32 - 1;
11326 char *salt_buf
= input_buf
+ 32 + 1;
11328 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11330 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11332 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11334 salt
->salt_len
= salt_len
;
11336 return (PARSER_OK
);
11339 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11341 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11343 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11347 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11350 u32
*digest
= (u32
*) hash_buf
->digest
;
11352 salt_t
*salt
= hash_buf
->salt
;
11354 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11355 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11356 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11357 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11359 digest
[0] = byte_swap_32 (digest
[0]);
11360 digest
[1] = byte_swap_32 (digest
[1]);
11361 digest
[2] = byte_swap_32 (digest
[2]);
11362 digest
[3] = byte_swap_32 (digest
[3]);
11364 digest
[0] -= MD5M_A
;
11365 digest
[1] -= MD5M_B
;
11366 digest
[2] -= MD5M_C
;
11367 digest
[3] -= MD5M_D
;
11369 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11371 uint salt_len
= input_len
- 32 - 1;
11373 char *salt_buf
= input_buf
+ 32 + 1;
11375 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11377 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11379 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11381 salt
->salt_len
= salt_len
;
11383 return (PARSER_OK
);
11386 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11388 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11390 u32
*digest
= (u32
*) hash_buf
->digest
;
11392 salt_t
*salt
= hash_buf
->salt
;
11394 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11395 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11396 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11397 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11399 digest
[0] = byte_swap_32 (digest
[0]);
11400 digest
[1] = byte_swap_32 (digest
[1]);
11401 digest
[2] = byte_swap_32 (digest
[2]);
11402 digest
[3] = byte_swap_32 (digest
[3]);
11404 digest
[0] -= MD5M_A
;
11405 digest
[1] -= MD5M_B
;
11406 digest
[2] -= MD5M_C
;
11407 digest
[3] -= MD5M_D
;
11410 * This is a virtual salt. While the algorithm is basically not salted
11411 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11412 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11415 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11417 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11419 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11421 salt
->salt_len
= salt_len
;
11423 return (PARSER_OK
);
11426 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11428 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11430 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11434 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11437 u32
*digest
= (u32
*) hash_buf
->digest
;
11439 salt_t
*salt
= hash_buf
->salt
;
11441 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11442 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11443 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11444 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11446 digest
[0] = byte_swap_32 (digest
[0]);
11447 digest
[1] = byte_swap_32 (digest
[1]);
11448 digest
[2] = byte_swap_32 (digest
[2]);
11449 digest
[3] = byte_swap_32 (digest
[3]);
11451 digest
[0] -= MD5M_A
;
11452 digest
[1] -= MD5M_B
;
11453 digest
[2] -= MD5M_C
;
11454 digest
[3] -= MD5M_D
;
11456 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11458 uint salt_len
= input_len
- 32 - 1;
11460 char *salt_buf
= input_buf
+ 32 + 1;
11462 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11464 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11466 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11468 salt
->salt_len
= salt_len
;
11470 return (PARSER_OK
);
11473 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11475 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11477 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11481 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11484 u32
*digest
= (u32
*) hash_buf
->digest
;
11486 salt_t
*salt
= hash_buf
->salt
;
11488 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11489 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11490 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11491 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11493 digest
[0] = byte_swap_32 (digest
[0]);
11494 digest
[1] = byte_swap_32 (digest
[1]);
11495 digest
[2] = byte_swap_32 (digest
[2]);
11496 digest
[3] = byte_swap_32 (digest
[3]);
11498 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11500 uint salt_len
= input_len
- 32 - 1;
11502 char *salt_buf
= input_buf
+ 32 + 1;
11504 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11506 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11508 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11510 salt
->salt_len
= salt_len
;
11512 return (PARSER_OK
);
11515 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11517 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11519 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11523 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11526 u32
*digest
= (u32
*) hash_buf
->digest
;
11528 salt_t
*salt
= hash_buf
->salt
;
11530 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11531 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11532 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11533 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11535 digest
[0] = byte_swap_32 (digest
[0]);
11536 digest
[1] = byte_swap_32 (digest
[1]);
11537 digest
[2] = byte_swap_32 (digest
[2]);
11538 digest
[3] = byte_swap_32 (digest
[3]);
11540 digest
[0] -= MD4M_A
;
11541 digest
[1] -= MD4M_B
;
11542 digest
[2] -= MD4M_C
;
11543 digest
[3] -= MD4M_D
;
11545 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11547 uint salt_len
= input_len
- 32 - 1;
11549 char *salt_buf
= input_buf
+ 32 + 1;
11551 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11553 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11555 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11557 salt
->salt_len
= salt_len
;
11559 return (PARSER_OK
);
11562 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11564 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11566 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11570 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11573 u32
*digest
= (u32
*) hash_buf
->digest
;
11575 salt_t
*salt
= hash_buf
->salt
;
11577 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11578 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11579 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11580 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11582 digest
[0] = byte_swap_32 (digest
[0]);
11583 digest
[1] = byte_swap_32 (digest
[1]);
11584 digest
[2] = byte_swap_32 (digest
[2]);
11585 digest
[3] = byte_swap_32 (digest
[3]);
11587 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11589 uint salt_len
= input_len
- 32 - 1;
11591 char *salt_buf
= input_buf
+ 32 + 1;
11593 uint salt_pc_block
[16] = { 0 };
11595 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11597 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11599 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11601 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11603 salt_pc_block
[14] = salt_len
* 8;
11605 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11607 md5_64 (salt_pc_block
, salt_pc_digest
);
11609 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11610 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11611 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11612 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11614 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11616 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11618 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11620 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11621 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11622 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11623 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11625 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11627 return (PARSER_OK
);
11630 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11632 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11634 u32
*digest
= (u32
*) hash_buf
->digest
;
11636 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11637 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11638 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11639 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11640 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11642 digest
[0] -= SHA1M_A
;
11643 digest
[1] -= SHA1M_B
;
11644 digest
[2] -= SHA1M_C
;
11645 digest
[3] -= SHA1M_D
;
11646 digest
[4] -= SHA1M_E
;
11648 return (PARSER_OK
);
11651 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11653 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11655 u32
*digest
= (u32
*) hash_buf
->digest
;
11657 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11658 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11659 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11660 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11661 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11663 return (PARSER_OK
);
11666 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11668 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11670 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11674 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11677 u32
*digest
= (u32
*) hash_buf
->digest
;
11679 salt_t
*salt
= hash_buf
->salt
;
11681 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11682 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11683 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11684 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11685 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11687 digest
[0] -= SHA1M_A
;
11688 digest
[1] -= SHA1M_B
;
11689 digest
[2] -= SHA1M_C
;
11690 digest
[3] -= SHA1M_D
;
11691 digest
[4] -= SHA1M_E
;
11693 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11695 uint salt_len
= input_len
- 40 - 1;
11697 char *salt_buf
= input_buf
+ 40 + 1;
11699 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11701 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11703 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11705 salt
->salt_len
= salt_len
;
11707 return (PARSER_OK
);
11710 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11712 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11714 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11716 u32
*digest
= (u32
*) hash_buf
->digest
;
11718 u8 tmp_buf
[100] = { 0 };
11720 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11722 memcpy (digest
, tmp_buf
, 20);
11724 digest
[0] = byte_swap_32 (digest
[0]);
11725 digest
[1] = byte_swap_32 (digest
[1]);
11726 digest
[2] = byte_swap_32 (digest
[2]);
11727 digest
[3] = byte_swap_32 (digest
[3]);
11728 digest
[4] = byte_swap_32 (digest
[4]);
11730 digest
[0] -= SHA1M_A
;
11731 digest
[1] -= SHA1M_B
;
11732 digest
[2] -= SHA1M_C
;
11733 digest
[3] -= SHA1M_D
;
11734 digest
[4] -= SHA1M_E
;
11736 return (PARSER_OK
);
11739 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11741 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11743 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11745 u32
*digest
= (u32
*) hash_buf
->digest
;
11747 salt_t
*salt
= hash_buf
->salt
;
11749 u8 tmp_buf
[100] = { 0 };
11751 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11753 memcpy (digest
, tmp_buf
, 20);
11755 salt
->salt_len
= tmp_len
- 20;
11757 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11759 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11761 char *ptr
= (char *) salt
->salt_buf
;
11763 ptr
[salt
->salt_len
] = 0x80;
11766 digest
[0] = byte_swap_32 (digest
[0]);
11767 digest
[1] = byte_swap_32 (digest
[1]);
11768 digest
[2] = byte_swap_32 (digest
[2]);
11769 digest
[3] = byte_swap_32 (digest
[3]);
11770 digest
[4] = byte_swap_32 (digest
[4]);
11772 digest
[0] -= SHA1M_A
;
11773 digest
[1] -= SHA1M_B
;
11774 digest
[2] -= SHA1M_C
;
11775 digest
[3] -= SHA1M_D
;
11776 digest
[4] -= SHA1M_E
;
11778 return (PARSER_OK
);
11781 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11783 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11785 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11787 u32
*digest
= (u32
*) hash_buf
->digest
;
11789 salt_t
*salt
= hash_buf
->salt
;
11791 char *salt_buf
= input_buf
+ 6;
11795 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11797 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11799 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11801 salt
->salt_len
= salt_len
;
11803 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11805 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11806 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11807 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11808 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11809 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11811 digest
[0] -= SHA1M_A
;
11812 digest
[1] -= SHA1M_B
;
11813 digest
[2] -= SHA1M_C
;
11814 digest
[3] -= SHA1M_D
;
11815 digest
[4] -= SHA1M_E
;
11817 return (PARSER_OK
);
11820 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11822 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11824 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11826 u32
*digest
= (u32
*) hash_buf
->digest
;
11828 salt_t
*salt
= hash_buf
->salt
;
11830 char *salt_buf
= input_buf
+ 6;
11834 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11836 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11838 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11840 salt
->salt_len
= salt_len
;
11842 char *hash_pos
= input_buf
+ 6 + 8;
11844 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11845 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11846 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11847 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11848 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11850 digest
[0] -= SHA1M_A
;
11851 digest
[1] -= SHA1M_B
;
11852 digest
[2] -= SHA1M_C
;
11853 digest
[3] -= SHA1M_D
;
11854 digest
[4] -= SHA1M_E
;
11856 return (PARSER_OK
);
11859 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11861 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11863 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11865 u64
*digest
= (u64
*) hash_buf
->digest
;
11867 salt_t
*salt
= hash_buf
->salt
;
11869 char *salt_buf
= input_buf
+ 6;
11873 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11875 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11877 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11879 salt
->salt_len
= salt_len
;
11881 char *hash_pos
= input_buf
+ 6 + 8;
11883 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11884 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11885 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11886 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11887 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11888 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11889 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11890 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11892 digest
[0] -= SHA512M_A
;
11893 digest
[1] -= SHA512M_B
;
11894 digest
[2] -= SHA512M_C
;
11895 digest
[3] -= SHA512M_D
;
11896 digest
[4] -= SHA512M_E
;
11897 digest
[5] -= SHA512M_F
;
11898 digest
[6] -= SHA512M_G
;
11899 digest
[7] -= SHA512M_H
;
11901 return (PARSER_OK
);
11904 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11906 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11908 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11912 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11915 u32
*digest
= (u32
*) hash_buf
->digest
;
11917 salt_t
*salt
= hash_buf
->salt
;
11919 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11920 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11924 digest
[0] = byte_swap_32 (digest
[0]);
11925 digest
[1] = byte_swap_32 (digest
[1]);
11927 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11929 uint salt_len
= input_len
- 16 - 1;
11931 char *salt_buf
= input_buf
+ 16 + 1;
11933 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11935 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11937 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11939 salt
->salt_len
= salt_len
;
11941 return (PARSER_OK
);
11944 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11946 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11948 u32
*digest
= (u32
*) hash_buf
->digest
;
11950 salt_t
*salt
= hash_buf
->salt
;
11952 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11953 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11954 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11955 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11956 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11958 digest
[0] -= SHA1M_A
;
11959 digest
[1] -= SHA1M_B
;
11960 digest
[2] -= SHA1M_C
;
11961 digest
[3] -= SHA1M_D
;
11962 digest
[4] -= SHA1M_E
;
11964 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11966 uint salt_len
= input_len
- 40 - 1;
11968 char *salt_buf
= input_buf
+ 40 + 1;
11970 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11972 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11974 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11976 salt
->salt_len
= salt_len
;
11978 return (PARSER_OK
);
11981 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11983 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11985 u32
*digest
= (u32
*) hash_buf
->digest
;
11987 salt_t
*salt
= hash_buf
->salt
;
11989 char *hash_pos
= input_buf
;
11991 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11992 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11993 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
11994 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
11995 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
11996 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
11997 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
11998 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
11999 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12000 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12001 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12002 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12003 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12004 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12005 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12006 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12008 char *salt_pos
= input_buf
+ 128;
12010 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12011 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12012 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12013 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12015 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12016 salt
->salt_len
= 16;
12018 return (PARSER_OK
);
12021 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12023 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12025 u32
*digest
= (u32
*) hash_buf
->digest
;
12027 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12028 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12029 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12030 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12031 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12032 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12033 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12034 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12036 digest
[0] -= SHA256M_A
;
12037 digest
[1] -= SHA256M_B
;
12038 digest
[2] -= SHA256M_C
;
12039 digest
[3] -= SHA256M_D
;
12040 digest
[4] -= SHA256M_E
;
12041 digest
[5] -= SHA256M_F
;
12042 digest
[6] -= SHA256M_G
;
12043 digest
[7] -= SHA256M_H
;
12045 return (PARSER_OK
);
12048 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12050 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12052 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12056 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12059 u32
*digest
= (u32
*) hash_buf
->digest
;
12061 salt_t
*salt
= hash_buf
->salt
;
12063 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12064 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12065 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12066 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12067 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12068 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12069 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12070 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12072 digest
[0] -= SHA256M_A
;
12073 digest
[1] -= SHA256M_B
;
12074 digest
[2] -= SHA256M_C
;
12075 digest
[3] -= SHA256M_D
;
12076 digest
[4] -= SHA256M_E
;
12077 digest
[5] -= SHA256M_F
;
12078 digest
[6] -= SHA256M_G
;
12079 digest
[7] -= SHA256M_H
;
12081 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12083 uint salt_len
= input_len
- 64 - 1;
12085 char *salt_buf
= input_buf
+ 64 + 1;
12087 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12089 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12091 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12093 salt
->salt_len
= salt_len
;
12095 return (PARSER_OK
);
12098 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12100 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12102 u64
*digest
= (u64
*) hash_buf
->digest
;
12104 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12105 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12106 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12107 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12108 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12109 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12113 digest
[0] -= SHA384M_A
;
12114 digest
[1] -= SHA384M_B
;
12115 digest
[2] -= SHA384M_C
;
12116 digest
[3] -= SHA384M_D
;
12117 digest
[4] -= SHA384M_E
;
12118 digest
[5] -= SHA384M_F
;
12122 return (PARSER_OK
);
12125 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12127 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12129 u64
*digest
= (u64
*) hash_buf
->digest
;
12131 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12132 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12133 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12134 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12135 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12136 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12137 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12138 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12140 digest
[0] -= SHA512M_A
;
12141 digest
[1] -= SHA512M_B
;
12142 digest
[2] -= SHA512M_C
;
12143 digest
[3] -= SHA512M_D
;
12144 digest
[4] -= SHA512M_E
;
12145 digest
[5] -= SHA512M_F
;
12146 digest
[6] -= SHA512M_G
;
12147 digest
[7] -= SHA512M_H
;
12149 return (PARSER_OK
);
12152 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12154 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12156 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12160 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12163 u64
*digest
= (u64
*) hash_buf
->digest
;
12165 salt_t
*salt
= hash_buf
->salt
;
12167 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12168 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12169 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12170 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12171 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12172 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12173 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12174 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12176 digest
[0] -= SHA512M_A
;
12177 digest
[1] -= SHA512M_B
;
12178 digest
[2] -= SHA512M_C
;
12179 digest
[3] -= SHA512M_D
;
12180 digest
[4] -= SHA512M_E
;
12181 digest
[5] -= SHA512M_F
;
12182 digest
[6] -= SHA512M_G
;
12183 digest
[7] -= SHA512M_H
;
12185 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12187 uint salt_len
= input_len
- 128 - 1;
12189 char *salt_buf
= input_buf
+ 128 + 1;
12191 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12193 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12195 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12197 salt
->salt_len
= salt_len
;
12199 return (PARSER_OK
);
12202 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12204 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12206 u64
*digest
= (u64
*) hash_buf
->digest
;
12208 salt_t
*salt
= hash_buf
->salt
;
12210 char *salt_pos
= input_buf
+ 3;
12212 uint iterations_len
= 0;
12214 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12218 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12220 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12221 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12225 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12229 iterations_len
+= 8;
12233 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12236 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12238 char *hash_pos
= strchr (salt_pos
, '$');
12240 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12242 uint salt_len
= hash_pos
- salt_pos
;
12244 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12246 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12248 salt
->salt_len
= salt_len
;
12252 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12254 return (PARSER_OK
);
12257 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12259 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12261 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12263 u64
*digest
= (u64
*) hash_buf
->digest
;
12265 salt_t
*salt
= hash_buf
->salt
;
12267 uint keccak_mdlen
= input_len
/ 2;
12269 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12271 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12273 digest
[i
] = byte_swap_64 (digest
[i
]);
12276 salt
->keccak_mdlen
= keccak_mdlen
;
12278 return (PARSER_OK
);
12281 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12283 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12285 u32
*digest
= (u32
*) hash_buf
->digest
;
12287 salt_t
*salt
= hash_buf
->salt
;
12289 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12292 * Parse that strange long line
12297 size_t in_len
[9] = { 0 };
12299 in_off
[0] = strtok (input_buf
, ":");
12301 in_len
[0] = strlen (in_off
[0]);
12305 for (i
= 1; i
< 9; i
++)
12307 in_off
[i
] = strtok (NULL
, ":");
12309 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12311 in_len
[i
] = strlen (in_off
[i
]);
12314 char *ptr
= (char *) ikepsk
->msg_buf
;
12316 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12317 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12318 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12319 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12320 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12321 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12325 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12327 ptr
= (char *) ikepsk
->nr_buf
;
12329 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12330 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12334 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12337 * Store to database
12342 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12343 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12344 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12345 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12347 digest
[0] = byte_swap_32 (digest
[0]);
12348 digest
[1] = byte_swap_32 (digest
[1]);
12349 digest
[2] = byte_swap_32 (digest
[2]);
12350 digest
[3] = byte_swap_32 (digest
[3]);
12352 salt
->salt_len
= 32;
12354 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12355 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12356 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12357 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12358 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12359 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12360 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12361 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12363 return (PARSER_OK
);
12366 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12368 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12370 u32
*digest
= (u32
*) hash_buf
->digest
;
12372 salt_t
*salt
= hash_buf
->salt
;
12374 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12377 * Parse that strange long line
12382 size_t in_len
[9] = { 0 };
12384 in_off
[0] = strtok (input_buf
, ":");
12386 in_len
[0] = strlen (in_off
[0]);
12390 for (i
= 1; i
< 9; i
++)
12392 in_off
[i
] = strtok (NULL
, ":");
12394 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12396 in_len
[i
] = strlen (in_off
[i
]);
12399 char *ptr
= (char *) ikepsk
->msg_buf
;
12401 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12402 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12403 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12404 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12405 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12406 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12410 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12412 ptr
= (char *) ikepsk
->nr_buf
;
12414 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12415 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12419 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12422 * Store to database
12427 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12428 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12429 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12430 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12431 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12433 salt
->salt_len
= 32;
12435 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12436 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12437 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12438 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12439 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12440 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12441 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12442 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12444 return (PARSER_OK
);
12447 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12449 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12451 u32
*digest
= (u32
*) hash_buf
->digest
;
12453 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12454 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12455 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12456 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12457 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12459 digest
[0] = byte_swap_32 (digest
[0]);
12460 digest
[1] = byte_swap_32 (digest
[1]);
12461 digest
[2] = byte_swap_32 (digest
[2]);
12462 digest
[3] = byte_swap_32 (digest
[3]);
12463 digest
[4] = byte_swap_32 (digest
[4]);
12465 return (PARSER_OK
);
12468 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12470 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12472 u32
*digest
= (u32
*) hash_buf
->digest
;
12474 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12475 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12476 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12477 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12478 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12479 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12480 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12481 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12482 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12483 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12484 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12485 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12486 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12487 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12488 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12489 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12491 return (PARSER_OK
);
12494 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12496 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12498 u32
*digest
= (u32
*) hash_buf
->digest
;
12500 salt_t
*salt
= hash_buf
->salt
;
12502 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12503 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12504 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12505 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12506 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12508 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12510 uint salt_len
= input_len
- 40 - 1;
12512 char *salt_buf
= input_buf
+ 40 + 1;
12514 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12516 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12518 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12520 salt
->salt_len
= salt_len
;
12522 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12524 return (PARSER_OK
);
12527 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12529 u32
*digest
= (u32
*) hash_buf
->digest
;
12531 salt_t
*salt
= hash_buf
->salt
;
12533 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12535 if (input_len
== 0)
12537 log_error ("TrueCrypt container not specified");
12542 FILE *fp
= fopen (input_buf
, "rb");
12546 log_error ("%s: %s", input_buf
, strerror (errno
));
12551 char buf
[512] = { 0 };
12553 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12557 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12559 memcpy (tc
->salt_buf
, buf
, 64);
12561 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12563 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12565 salt
->salt_len
= 4;
12567 salt
->salt_iter
= 1000 - 1;
12569 digest
[0] = tc
->data_buf
[0];
12571 return (PARSER_OK
);
12574 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12576 u32
*digest
= (u32
*) hash_buf
->digest
;
12578 salt_t
*salt
= hash_buf
->salt
;
12580 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12582 if (input_len
== 0)
12584 log_error ("TrueCrypt container not specified");
12589 FILE *fp
= fopen (input_buf
, "rb");
12593 log_error ("%s: %s", input_buf
, strerror (errno
));
12598 char buf
[512] = { 0 };
12600 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12604 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12606 memcpy (tc
->salt_buf
, buf
, 64);
12608 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12610 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12612 salt
->salt_len
= 4;
12614 salt
->salt_iter
= 2000 - 1;
12616 digest
[0] = tc
->data_buf
[0];
12618 return (PARSER_OK
);
12621 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12623 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12625 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12627 u32
*digest
= (u32
*) hash_buf
->digest
;
12629 salt_t
*salt
= hash_buf
->salt
;
12631 char *salt_pos
= input_buf
+ 6;
12633 char *hash_pos
= strchr (salt_pos
, '$');
12635 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12637 uint salt_len
= hash_pos
- salt_pos
;
12639 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12641 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12643 salt
->salt_len
= salt_len
;
12645 salt
->salt_iter
= 1000;
12649 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12651 return (PARSER_OK
);
12654 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12656 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12658 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12660 u32
*digest
= (u32
*) hash_buf
->digest
;
12662 salt_t
*salt
= hash_buf
->salt
;
12664 char *iter_pos
= input_buf
+ 7;
12666 char *salt_pos
= strchr (iter_pos
, '$');
12668 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12672 char *hash_pos
= strchr (salt_pos
, '$');
12674 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12676 uint salt_len
= hash_pos
- salt_pos
;
12678 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12680 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12682 salt
->salt_len
= salt_len
;
12684 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12686 salt
->salt_sign
[0] = atoi (salt_iter
);
12688 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12692 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12694 digest
[0] = byte_swap_32 (digest
[0]);
12695 digest
[1] = byte_swap_32 (digest
[1]);
12696 digest
[2] = byte_swap_32 (digest
[2]);
12697 digest
[3] = byte_swap_32 (digest
[3]);
12698 digest
[4] = byte_swap_32 (digest
[4]);
12700 return (PARSER_OK
);
12703 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12705 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12707 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12709 u32
*digest
= (u32
*) hash_buf
->digest
;
12711 salt_t
*salt
= hash_buf
->salt
;
12713 char *iter_pos
= input_buf
+ 9;
12715 char *salt_pos
= strchr (iter_pos
, '$');
12717 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12721 char *hash_pos
= strchr (salt_pos
, '$');
12723 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12725 uint salt_len
= hash_pos
- salt_pos
;
12727 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12729 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12731 salt
->salt_len
= salt_len
;
12733 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12735 salt
->salt_sign
[0] = atoi (salt_iter
);
12737 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12741 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12743 digest
[0] = byte_swap_32 (digest
[0]);
12744 digest
[1] = byte_swap_32 (digest
[1]);
12745 digest
[2] = byte_swap_32 (digest
[2]);
12746 digest
[3] = byte_swap_32 (digest
[3]);
12747 digest
[4] = byte_swap_32 (digest
[4]);
12748 digest
[5] = byte_swap_32 (digest
[5]);
12749 digest
[6] = byte_swap_32 (digest
[6]);
12750 digest
[7] = byte_swap_32 (digest
[7]);
12752 return (PARSER_OK
);
12755 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12757 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12759 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12761 u64
*digest
= (u64
*) hash_buf
->digest
;
12763 salt_t
*salt
= hash_buf
->salt
;
12765 char *iter_pos
= input_buf
+ 9;
12767 char *salt_pos
= strchr (iter_pos
, '$');
12769 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12773 char *hash_pos
= strchr (salt_pos
, '$');
12775 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12777 uint salt_len
= hash_pos
- salt_pos
;
12779 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12781 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12783 salt
->salt_len
= salt_len
;
12785 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12787 salt
->salt_sign
[0] = atoi (salt_iter
);
12789 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12793 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12795 digest
[0] = byte_swap_64 (digest
[0]);
12796 digest
[1] = byte_swap_64 (digest
[1]);
12797 digest
[2] = byte_swap_64 (digest
[2]);
12798 digest
[3] = byte_swap_64 (digest
[3]);
12799 digest
[4] = byte_swap_64 (digest
[4]);
12800 digest
[5] = byte_swap_64 (digest
[5]);
12801 digest
[6] = byte_swap_64 (digest
[6]);
12802 digest
[7] = byte_swap_64 (digest
[7]);
12804 return (PARSER_OK
);
12807 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12809 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12811 u32
*digest
= (u32
*) hash_buf
->digest
;
12813 salt_t
*salt
= hash_buf
->salt
;
12815 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12821 char *iterations_pos
= input_buf
;
12823 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12825 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12827 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12829 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12833 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12835 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12837 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12839 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12841 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12843 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12848 * pbkdf2 iterations
12851 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12854 * handle salt encoding
12857 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12859 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12861 const char p0
= saltbuf_pos
[i
+ 0];
12862 const char p1
= saltbuf_pos
[i
+ 1];
12864 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12865 | hex_convert (p0
) << 4;
12868 salt
->salt_len
= saltbuf_len
/ 2;
12871 * handle cipher encoding
12874 uint
*tmp
= (uint
*) mymalloc (32);
12876 char *cipherbuf_ptr
= (char *) tmp
;
12878 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12880 const char p0
= cipherbuf_pos
[i
+ 0];
12881 const char p1
= cipherbuf_pos
[i
+ 1];
12883 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12884 | hex_convert (p0
) << 4;
12887 // iv is stored at salt_buf 4 (length 16)
12888 // data is stored at salt_buf 8 (length 16)
12890 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12891 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12892 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12893 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12895 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12896 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12897 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12898 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12902 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12904 const char p0
= cipherbuf_pos
[j
+ 0];
12905 const char p1
= cipherbuf_pos
[j
+ 1];
12907 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12908 | hex_convert (p0
) << 4;
12915 digest
[0] = 0x10101010;
12916 digest
[1] = 0x10101010;
12917 digest
[2] = 0x10101010;
12918 digest
[3] = 0x10101010;
12920 return (PARSER_OK
);
12923 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12925 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12927 u32
*digest
= (u32
*) hash_buf
->digest
;
12929 salt_t
*salt
= hash_buf
->salt
;
12931 char *hashbuf_pos
= input_buf
;
12933 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12935 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12937 uint hash_len
= iterations_pos
- hashbuf_pos
;
12939 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12943 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12945 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12947 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12951 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12953 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12955 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12957 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12959 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12961 salt
->salt_len
= salt_len
;
12963 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12965 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
12966 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
12967 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
12968 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
12970 return (PARSER_OK
);
12973 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12975 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12977 u32
*digest
= (u32
*) hash_buf
->digest
;
12979 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12980 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12981 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12982 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12983 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12984 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12985 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12986 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12988 digest
[0] = byte_swap_32 (digest
[0]);
12989 digest
[1] = byte_swap_32 (digest
[1]);
12990 digest
[2] = byte_swap_32 (digest
[2]);
12991 digest
[3] = byte_swap_32 (digest
[3]);
12992 digest
[4] = byte_swap_32 (digest
[4]);
12993 digest
[5] = byte_swap_32 (digest
[5]);
12994 digest
[6] = byte_swap_32 (digest
[6]);
12995 digest
[7] = byte_swap_32 (digest
[7]);
12997 return (PARSER_OK
);
13000 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13002 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13004 u32
*digest
= (u32
*) hash_buf
->digest
;
13006 salt_t
*salt
= hash_buf
->salt
;
13008 char *salt_pos
= input_buf
+ 3;
13010 uint iterations_len
= 0;
13012 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13016 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13018 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13019 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13023 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13027 iterations_len
+= 8;
13031 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13034 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13036 char *hash_pos
= strchr (salt_pos
, '$');
13038 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13040 uint salt_len
= hash_pos
- salt_pos
;
13042 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13044 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13046 salt
->salt_len
= salt_len
;
13050 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13052 return (PARSER_OK
);
13055 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13057 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13059 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13061 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13063 u64
*digest
= (u64
*) hash_buf
->digest
;
13065 salt_t
*salt
= hash_buf
->salt
;
13067 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13069 char *iter_pos
= input_buf
+ 4;
13071 char *salt_pos
= strchr (iter_pos
, '$');
13073 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13077 char *hash_pos
= strchr (salt_pos
, '$');
13079 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13081 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13085 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13086 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13087 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13088 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13089 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13090 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13091 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13092 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13094 uint salt_len
= hash_pos
- salt_pos
- 1;
13096 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13098 salt
->salt_len
= salt_len
/ 2;
13100 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13101 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13102 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13103 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13104 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13105 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13106 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13107 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13109 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13110 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13111 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13112 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13113 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13114 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13115 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13116 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13117 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13118 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13120 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13122 salt
->salt_iter
= atoi (iter_pos
) - 1;
13124 return (PARSER_OK
);
13127 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13129 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13131 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13133 u32
*digest
= (u32
*) hash_buf
->digest
;
13135 salt_t
*salt
= hash_buf
->salt
;
13137 char *salt_pos
= input_buf
+ 14;
13139 char *hash_pos
= strchr (salt_pos
, '*');
13141 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13145 uint salt_len
= hash_pos
- salt_pos
- 1;
13147 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13149 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13151 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13153 salt
->salt_len
= salt_len
;
13155 u8 tmp_buf
[100] = { 0 };
13157 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13159 memcpy (digest
, tmp_buf
, 32);
13161 digest
[0] = byte_swap_32 (digest
[0]);
13162 digest
[1] = byte_swap_32 (digest
[1]);
13163 digest
[2] = byte_swap_32 (digest
[2]);
13164 digest
[3] = byte_swap_32 (digest
[3]);
13165 digest
[4] = byte_swap_32 (digest
[4]);
13166 digest
[5] = byte_swap_32 (digest
[5]);
13167 digest
[6] = byte_swap_32 (digest
[6]);
13168 digest
[7] = byte_swap_32 (digest
[7]);
13170 digest
[0] -= SHA256M_A
;
13171 digest
[1] -= SHA256M_B
;
13172 digest
[2] -= SHA256M_C
;
13173 digest
[3] -= SHA256M_D
;
13174 digest
[4] -= SHA256M_E
;
13175 digest
[5] -= SHA256M_F
;
13176 digest
[6] -= SHA256M_G
;
13177 digest
[7] -= SHA256M_H
;
13179 return (PARSER_OK
);
13182 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13184 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13186 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13188 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13190 u64
*digest
= (u64
*) hash_buf
->digest
;
13192 salt_t
*salt
= hash_buf
->salt
;
13194 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13196 char *iter_pos
= input_buf
+ 19;
13198 char *salt_pos
= strchr (iter_pos
, '.');
13200 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13204 char *hash_pos
= strchr (salt_pos
, '.');
13206 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13208 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13212 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13213 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13214 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13215 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13216 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13217 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13218 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13219 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13221 uint salt_len
= hash_pos
- salt_pos
- 1;
13225 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13229 for (i
= 0; i
< salt_len
; i
++)
13231 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13234 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13235 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13237 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13239 salt
->salt_len
= salt_len
;
13241 salt
->salt_iter
= atoi (iter_pos
) - 1;
13243 return (PARSER_OK
);
13246 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13248 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13250 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13252 u64
*digest
= (u64
*) hash_buf
->digest
;
13254 salt_t
*salt
= hash_buf
->salt
;
13256 u8 tmp_buf
[120] = { 0 };
13258 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13260 memcpy (digest
, tmp_buf
, 64);
13262 digest
[0] = byte_swap_64 (digest
[0]);
13263 digest
[1] = byte_swap_64 (digest
[1]);
13264 digest
[2] = byte_swap_64 (digest
[2]);
13265 digest
[3] = byte_swap_64 (digest
[3]);
13266 digest
[4] = byte_swap_64 (digest
[4]);
13267 digest
[5] = byte_swap_64 (digest
[5]);
13268 digest
[6] = byte_swap_64 (digest
[6]);
13269 digest
[7] = byte_swap_64 (digest
[7]);
13271 digest
[0] -= SHA512M_A
;
13272 digest
[1] -= SHA512M_B
;
13273 digest
[2] -= SHA512M_C
;
13274 digest
[3] -= SHA512M_D
;
13275 digest
[4] -= SHA512M_E
;
13276 digest
[5] -= SHA512M_F
;
13277 digest
[6] -= SHA512M_G
;
13278 digest
[7] -= SHA512M_H
;
13280 salt
->salt_len
= tmp_len
- 64;
13282 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13284 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13286 char *ptr
= (char *) salt
->salt_buf
;
13288 ptr
[salt
->salt_len
] = 0x80;
13291 return (PARSER_OK
);
13294 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13296 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13298 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13302 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13305 u32
*digest
= (u32
*) hash_buf
->digest
;
13307 salt_t
*salt
= hash_buf
->salt
;
13309 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13310 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13311 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13312 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13314 digest
[0] = byte_swap_32 (digest
[0]);
13315 digest
[1] = byte_swap_32 (digest
[1]);
13316 digest
[2] = byte_swap_32 (digest
[2]);
13317 digest
[3] = byte_swap_32 (digest
[3]);
13319 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13321 uint salt_len
= input_len
- 32 - 1;
13323 char *salt_buf
= input_buf
+ 32 + 1;
13325 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13327 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13329 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13331 salt
->salt_len
= salt_len
;
13333 return (PARSER_OK
);
13336 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13338 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13340 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13344 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13347 u32
*digest
= (u32
*) hash_buf
->digest
;
13349 salt_t
*salt
= hash_buf
->salt
;
13351 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13352 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13353 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13354 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13355 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13357 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13359 uint salt_len
= input_len
- 40 - 1;
13361 char *salt_buf
= input_buf
+ 40 + 1;
13363 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13365 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13367 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13369 salt
->salt_len
= salt_len
;
13371 return (PARSER_OK
);
13374 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13376 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13378 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13382 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13385 u32
*digest
= (u32
*) hash_buf
->digest
;
13387 salt_t
*salt
= hash_buf
->salt
;
13389 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13390 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13391 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13392 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13393 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13394 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13395 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13396 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13398 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13400 uint salt_len
= input_len
- 64 - 1;
13402 char *salt_buf
= input_buf
+ 64 + 1;
13404 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13406 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13408 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13410 salt
->salt_len
= salt_len
;
13412 return (PARSER_OK
);
13415 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13417 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13419 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13423 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13426 u64
*digest
= (u64
*) hash_buf
->digest
;
13428 salt_t
*salt
= hash_buf
->salt
;
13430 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13431 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13432 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13433 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13434 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13435 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13436 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13437 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13439 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13441 uint salt_len
= input_len
- 128 - 1;
13443 char *salt_buf
= input_buf
+ 128 + 1;
13445 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13447 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13449 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13451 salt
->salt_len
= salt_len
;
13453 return (PARSER_OK
);
13456 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13458 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13460 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13462 u32
*digest
= (u32
*) hash_buf
->digest
;
13464 salt_t
*salt
= hash_buf
->salt
;
13466 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13472 char *user_pos
= input_buf
+ 10 + 1;
13474 char *realm_pos
= strchr (user_pos
, '$');
13476 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13478 uint user_len
= realm_pos
- user_pos
;
13480 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13484 char *salt_pos
= strchr (realm_pos
, '$');
13486 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13488 uint realm_len
= salt_pos
- realm_pos
;
13490 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13494 char *data_pos
= strchr (salt_pos
, '$');
13496 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13498 uint salt_len
= data_pos
- salt_pos
;
13500 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13504 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13506 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13512 memcpy (krb5pa
->user
, user_pos
, user_len
);
13513 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13514 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13516 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13518 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13520 const char p0
= data_pos
[i
+ 0];
13521 const char p1
= data_pos
[i
+ 1];
13523 *timestamp_ptr
++ = hex_convert (p1
) << 0
13524 | hex_convert (p0
) << 4;
13527 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13529 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13531 const char p0
= data_pos
[i
+ 0];
13532 const char p1
= data_pos
[i
+ 1];
13534 *checksum_ptr
++ = hex_convert (p1
) << 0
13535 | hex_convert (p0
) << 4;
13539 * copy some data to generic buffers to make sorting happy
13542 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13543 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13544 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13545 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13546 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13547 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13548 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13549 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13550 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13552 salt
->salt_len
= 36;
13554 digest
[0] = krb5pa
->checksum
[0];
13555 digest
[1] = krb5pa
->checksum
[1];
13556 digest
[2] = krb5pa
->checksum
[2];
13557 digest
[3] = krb5pa
->checksum
[3];
13559 return (PARSER_OK
);
13562 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13564 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13566 u32
*digest
= (u32
*) hash_buf
->digest
;
13568 salt_t
*salt
= hash_buf
->salt
;
13574 char *salt_pos
= input_buf
;
13576 char *hash_pos
= strchr (salt_pos
, '$');
13578 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13580 uint salt_len
= hash_pos
- salt_pos
;
13582 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13586 uint hash_len
= input_len
- 1 - salt_len
;
13588 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13596 for (uint i
= 0; i
< salt_len
; i
++)
13598 if (salt_pos
[i
] == ' ') continue;
13603 // SAP user names cannot be longer than 12 characters
13604 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13606 // SAP user name cannot start with ! or ?
13607 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13613 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13615 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13617 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13619 salt
->salt_len
= salt_len
;
13621 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13622 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13626 digest
[0] = byte_swap_32 (digest
[0]);
13627 digest
[1] = byte_swap_32 (digest
[1]);
13629 return (PARSER_OK
);
13632 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13634 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13636 u32
*digest
= (u32
*) hash_buf
->digest
;
13638 salt_t
*salt
= hash_buf
->salt
;
13644 char *salt_pos
= input_buf
;
13646 char *hash_pos
= strchr (salt_pos
, '$');
13648 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13650 uint salt_len
= hash_pos
- salt_pos
;
13652 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13656 uint hash_len
= input_len
- 1 - salt_len
;
13658 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13666 for (uint i
= 0; i
< salt_len
; i
++)
13668 if (salt_pos
[i
] == ' ') continue;
13673 // SAP user names cannot be longer than 12 characters
13674 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13675 // so far nobody complained so we stay with this because it helps in optimization
13676 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13678 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13680 // SAP user name cannot start with ! or ?
13681 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13687 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13689 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13691 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13693 salt
->salt_len
= salt_len
;
13695 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13696 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13697 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13698 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13699 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13701 return (PARSER_OK
);
13704 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13706 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13708 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13710 u64
*digest
= (u64
*) hash_buf
->digest
;
13712 salt_t
*salt
= hash_buf
->salt
;
13714 char *iter_pos
= input_buf
+ 3;
13716 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13718 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13720 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13722 salt
->salt_iter
= salt_iter
;
13724 char *salt_pos
= iter_pos
+ 1;
13728 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13730 salt
->salt_len
= salt_len
;
13732 char *hash_pos
= salt_pos
+ salt_len
;
13734 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13738 char *tmp
= (char *) salt
->salt_buf_pc
;
13740 tmp
[0] = hash_pos
[42];
13744 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13745 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13746 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13747 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13753 return (PARSER_OK
);
13756 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13758 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13760 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13762 u32
*digest
= (u32
*) hash_buf
->digest
;
13764 salt_t
*salt
= hash_buf
->salt
;
13766 char *salt_buf
= input_buf
+ 6;
13768 uint salt_len
= 16;
13770 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13772 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13774 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13776 salt
->salt_len
= salt_len
;
13778 char *hash_pos
= input_buf
+ 6 + 16;
13780 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13781 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13782 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13783 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13784 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13785 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13786 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13787 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13789 return (PARSER_OK
);
13792 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13794 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13796 u32
*digest
= (u32
*) hash_buf
->digest
;
13798 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13799 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13803 return (PARSER_OK
);
13806 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13808 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13810 u32
*digest
= (u32
*) hash_buf
->digest
;
13812 salt_t
*salt
= hash_buf
->salt
;
13814 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13816 char *saltbuf_pos
= input_buf
;
13818 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13820 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13822 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13824 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13825 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13827 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13831 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13833 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13835 char *salt_ptr
= (char *) saltbuf_pos
;
13836 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13841 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13843 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13846 rakp_ptr
[j
] = 0x80;
13848 rakp
->salt_len
= j
;
13850 for (i
= 0; i
< 64; i
++)
13852 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13855 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13856 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13857 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13858 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13859 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13860 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13861 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13862 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13864 salt
->salt_len
= 32; // muss min. 32 haben
13866 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13867 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13868 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13869 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13870 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13872 return (PARSER_OK
);
13875 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13877 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13879 u32
*digest
= (u32
*) hash_buf
->digest
;
13881 salt_t
*salt
= hash_buf
->salt
;
13883 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13885 char *salt_pos
= input_buf
+ 1;
13887 memcpy (salt
->salt_buf
, salt_pos
, 8);
13889 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13890 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13892 salt
->salt_len
= 8;
13894 char *hash_pos
= salt_pos
+ 8;
13896 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13897 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13898 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13899 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13900 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13902 digest
[0] -= SHA1M_A
;
13903 digest
[1] -= SHA1M_B
;
13904 digest
[2] -= SHA1M_C
;
13905 digest
[3] -= SHA1M_D
;
13906 digest
[4] -= SHA1M_E
;
13908 return (PARSER_OK
);
13911 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13913 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13915 u32
*digest
= (u32
*) hash_buf
->digest
;
13917 salt_t
*salt
= hash_buf
->salt
;
13919 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13920 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13921 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13922 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13924 digest
[0] = byte_swap_32 (digest
[0]);
13925 digest
[1] = byte_swap_32 (digest
[1]);
13926 digest
[2] = byte_swap_32 (digest
[2]);
13927 digest
[3] = byte_swap_32 (digest
[3]);
13929 digest
[0] -= MD5M_A
;
13930 digest
[1] -= MD5M_B
;
13931 digest
[2] -= MD5M_C
;
13932 digest
[3] -= MD5M_D
;
13934 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13936 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13938 u32
*salt_buf
= salt
->salt_buf
;
13940 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
13941 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
13942 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
13943 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
13945 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13946 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13947 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13948 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13950 salt
->salt_len
= 16 + 1;
13952 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13954 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13956 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
13958 return (PARSER_OK
);
13961 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13963 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13965 u32
*digest
= (u32
*) hash_buf
->digest
;
13967 salt_t
*salt
= hash_buf
->salt
;
13969 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13975 char *hashbuf_pos
= input_buf
;
13977 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13979 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13981 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13983 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13987 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13989 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13991 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13993 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13997 char *databuf_pos
= strchr (iteration_pos
, ':');
13999 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14001 const uint iteration_len
= databuf_pos
- iteration_pos
;
14003 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14004 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14006 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14008 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14009 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14015 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14016 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14017 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14018 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14019 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14020 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14021 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14022 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14026 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14028 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14030 const char p0
= saltbuf_pos
[i
+ 0];
14031 const char p1
= saltbuf_pos
[i
+ 1];
14033 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14034 | hex_convert (p0
) << 4;
14037 salt
->salt_buf
[4] = 0x01000000;
14038 salt
->salt_buf
[5] = 0x80;
14040 salt
->salt_len
= saltbuf_len
/ 2;
14044 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14048 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14050 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14052 const char p0
= databuf_pos
[i
+ 0];
14053 const char p1
= databuf_pos
[i
+ 1];
14055 *databuf_ptr
++ = hex_convert (p1
) << 0
14056 | hex_convert (p0
) << 4;
14059 *databuf_ptr
++ = 0x80;
14061 for (uint i
= 0; i
< 512; i
++)
14063 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14066 cloudkey
->data_len
= databuf_len
/ 2;
14068 return (PARSER_OK
);
14071 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14073 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14075 u32
*digest
= (u32
*) hash_buf
->digest
;
14077 salt_t
*salt
= hash_buf
->salt
;
14083 char *hashbuf_pos
= input_buf
;
14085 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14087 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14089 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14091 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14095 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14097 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14099 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14101 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14103 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14107 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14109 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14111 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14113 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14115 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14119 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14121 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14122 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14124 // ok, the plan for this algorithm is the following:
14125 // we have 2 salts here, the domain-name and a random salt
14126 // while both are used in the initial transformation,
14127 // only the random salt is used in the following iterations
14128 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14129 // and one that includes only the real salt (stored into salt_buf[]).
14130 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14132 u8 tmp_buf
[100] = { 0 };
14134 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14136 memcpy (digest
, tmp_buf
, 20);
14138 digest
[0] = byte_swap_32 (digest
[0]);
14139 digest
[1] = byte_swap_32 (digest
[1]);
14140 digest
[2] = byte_swap_32 (digest
[2]);
14141 digest
[3] = byte_swap_32 (digest
[3]);
14142 digest
[4] = byte_swap_32 (digest
[4]);
14146 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14148 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14150 char *len_ptr
= NULL
;
14152 for (uint i
= 0; i
< domainbuf_len
; i
++)
14154 if (salt_buf_pc_ptr
[i
] == '.')
14156 len_ptr
= &salt_buf_pc_ptr
[i
];
14166 salt
->salt_buf_pc
[7] = domainbuf_len
;
14170 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14172 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14174 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14176 salt
->salt_len
= salt_len
;
14180 salt
->salt_iter
= atoi (iteration_pos
);
14182 return (PARSER_OK
);
14185 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14187 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14189 u32
*digest
= (u32
*) hash_buf
->digest
;
14191 salt_t
*salt
= hash_buf
->salt
;
14193 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14194 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14195 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14196 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14197 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14199 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14201 uint salt_len
= input_len
- 40 - 1;
14203 char *salt_buf
= input_buf
+ 40 + 1;
14205 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14207 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14209 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14211 salt
->salt_len
= salt_len
;
14213 return (PARSER_OK
);
14216 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14218 const u8 ascii_to_ebcdic
[] =
14220 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14221 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14222 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14223 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14224 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14225 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14226 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14227 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14228 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14229 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14230 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14231 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14232 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14233 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14234 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14235 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14238 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14240 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14242 u32
*digest
= (u32
*) hash_buf
->digest
;
14244 salt_t
*salt
= hash_buf
->salt
;
14246 char *salt_pos
= input_buf
+ 6 + 1;
14248 char *digest_pos
= strchr (salt_pos
, '*');
14250 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14252 uint salt_len
= digest_pos
- salt_pos
;
14254 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14256 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14258 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14262 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14263 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14265 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14267 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14269 salt
->salt_len
= salt_len
;
14271 for (uint i
= 0; i
< salt_len
; i
++)
14273 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14275 for (uint i
= salt_len
; i
< 8; i
++)
14277 salt_buf_pc_ptr
[i
] = 0x40;
14282 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14284 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14285 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14287 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14288 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14290 digest
[0] = byte_swap_32 (digest
[0]);
14291 digest
[1] = byte_swap_32 (digest
[1]);
14293 IP (digest
[0], digest
[1], tt
);
14295 digest
[0] = rotr32 (digest
[0], 29);
14296 digest
[1] = rotr32 (digest
[1], 29);
14300 return (PARSER_OK
);
14303 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14305 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14307 u32
*digest
= (u32
*) hash_buf
->digest
;
14309 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14310 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14311 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14312 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14314 digest
[0] = byte_swap_32 (digest
[0]);
14315 digest
[1] = byte_swap_32 (digest
[1]);
14316 digest
[2] = byte_swap_32 (digest
[2]);
14317 digest
[3] = byte_swap_32 (digest
[3]);
14319 return (PARSER_OK
);
14322 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14324 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14326 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14328 u32
*digest
= (u32
*) hash_buf
->digest
;
14330 salt_t
*salt
= hash_buf
->salt
;
14332 u8 tmp_buf
[120] = { 0 };
14334 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14336 tmp_buf
[3] += -4; // dont ask!
14338 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14340 salt
->salt_len
= 5;
14342 memcpy (digest
, tmp_buf
+ 5, 9);
14344 // yes, only 9 byte are needed to crack, but 10 to display
14346 salt
->salt_buf_pc
[7] = input_buf
[20];
14348 return (PARSER_OK
);
14351 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14353 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14355 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14357 u32
*digest
= (u32
*) hash_buf
->digest
;
14359 salt_t
*salt
= hash_buf
->salt
;
14361 u8 tmp_buf
[120] = { 0 };
14363 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14365 tmp_buf
[3] += -4; // dont ask!
14369 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14371 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)
14375 char tmp_iter_buf
[11] = { 0 };
14377 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14379 tmp_iter_buf
[10] = 0;
14381 salt
->salt_iter
= atoi (tmp_iter_buf
);
14383 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14385 return (PARSER_SALT_ITERATION
);
14388 salt
->salt_iter
--; // first round in init
14390 // 2 additional bytes for display only
14392 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14393 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14397 memcpy (digest
, tmp_buf
+ 28, 8);
14399 digest
[0] = byte_swap_32 (digest
[0]);
14400 digest
[1] = byte_swap_32 (digest
[1]);
14404 return (PARSER_OK
);
14407 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14409 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14411 u32
*digest
= (u32
*) hash_buf
->digest
;
14413 salt_t
*salt
= hash_buf
->salt
;
14415 char *salt_buf_pos
= input_buf
;
14417 char *hash_buf_pos
= salt_buf_pos
+ 6;
14419 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14420 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14421 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14422 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14423 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14424 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14425 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14426 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14428 digest
[0] -= SHA256M_A
;
14429 digest
[1] -= SHA256M_B
;
14430 digest
[2] -= SHA256M_C
;
14431 digest
[3] -= SHA256M_D
;
14432 digest
[4] -= SHA256M_E
;
14433 digest
[5] -= SHA256M_F
;
14434 digest
[6] -= SHA256M_G
;
14435 digest
[7] -= SHA256M_H
;
14437 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14439 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14441 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14443 salt
->salt_len
= salt_len
;
14445 return (PARSER_OK
);
14448 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14450 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14452 u32
*digest
= (u32
*) hash_buf
->digest
;
14454 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14456 salt_t
*salt
= hash_buf
->salt
;
14458 char *salt_buf
= input_buf
+ 6;
14460 char *digest_buf
= strchr (salt_buf
, '$');
14462 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14464 uint salt_len
= digest_buf
- salt_buf
;
14466 digest_buf
++; // skip the '$' symbol
14468 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14470 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14472 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14474 salt
->salt_len
= salt_len
;
14476 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14477 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14478 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14479 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14481 digest
[0] = byte_swap_32 (digest
[0]);
14482 digest
[1] = byte_swap_32 (digest
[1]);
14483 digest
[2] = byte_swap_32 (digest
[2]);
14484 digest
[3] = byte_swap_32 (digest
[3]);
14486 digest
[0] -= MD5M_A
;
14487 digest
[1] -= MD5M_B
;
14488 digest
[2] -= MD5M_C
;
14489 digest
[3] -= MD5M_D
;
14491 return (PARSER_OK
);
14494 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14496 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14498 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14500 u32
*digest
= (u32
*) hash_buf
->digest
;
14502 salt_t
*salt
= hash_buf
->salt
;
14504 char *salt_buf
= input_buf
+ 3;
14506 char *digest_buf
= strchr (salt_buf
, '$');
14508 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14510 uint salt_len
= digest_buf
- salt_buf
;
14512 digest_buf
++; // skip the '$' symbol
14514 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14516 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14518 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14520 salt_buf_ptr
[salt_len
] = 0x2d;
14522 salt
->salt_len
= salt_len
+ 1;
14524 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14525 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14526 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14527 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14529 digest
[0] = byte_swap_32 (digest
[0]);
14530 digest
[1] = byte_swap_32 (digest
[1]);
14531 digest
[2] = byte_swap_32 (digest
[2]);
14532 digest
[3] = byte_swap_32 (digest
[3]);
14534 digest
[0] -= MD5M_A
;
14535 digest
[1] -= MD5M_B
;
14536 digest
[2] -= MD5M_C
;
14537 digest
[3] -= MD5M_D
;
14539 return (PARSER_OK
);
14542 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14544 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14546 u32
*digest
= (u32
*) hash_buf
->digest
;
14548 u8 tmp_buf
[100] = { 0 };
14550 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14552 memcpy (digest
, tmp_buf
, 20);
14554 digest
[0] = byte_swap_32 (digest
[0]);
14555 digest
[1] = byte_swap_32 (digest
[1]);
14556 digest
[2] = byte_swap_32 (digest
[2]);
14557 digest
[3] = byte_swap_32 (digest
[3]);
14558 digest
[4] = byte_swap_32 (digest
[4]);
14560 digest
[0] -= SHA1M_A
;
14561 digest
[1] -= SHA1M_B
;
14562 digest
[2] -= SHA1M_C
;
14563 digest
[3] -= SHA1M_D
;
14564 digest
[4] -= SHA1M_E
;
14566 return (PARSER_OK
);
14569 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14571 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14573 u32
*digest
= (u32
*) hash_buf
->digest
;
14575 salt_t
*salt
= hash_buf
->salt
;
14577 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14578 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14579 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14580 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14582 digest
[0] = byte_swap_32 (digest
[0]);
14583 digest
[1] = byte_swap_32 (digest
[1]);
14584 digest
[2] = byte_swap_32 (digest
[2]);
14585 digest
[3] = byte_swap_32 (digest
[3]);
14587 digest
[0] -= MD5M_A
;
14588 digest
[1] -= MD5M_B
;
14589 digest
[2] -= MD5M_C
;
14590 digest
[3] -= MD5M_D
;
14592 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14594 uint salt_len
= input_len
- 32 - 1;
14596 char *salt_buf
= input_buf
+ 32 + 1;
14598 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14600 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14602 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14605 * add static "salt" part
14608 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14612 salt
->salt_len
= salt_len
;
14614 return (PARSER_OK
);
14617 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14619 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14621 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14623 u32
*digest
= (u32
*) hash_buf
->digest
;
14625 salt_t
*salt
= hash_buf
->salt
;
14627 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14633 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14635 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14637 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14639 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14641 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14645 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14647 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14649 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14651 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14655 char *keybuf_pos
= strchr (keylen_pos
, '$');
14657 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14659 uint keylen_len
= keybuf_pos
- keylen_pos
;
14661 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14665 char *databuf_pos
= strchr (keybuf_pos
, '$');
14667 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14669 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14671 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14675 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14677 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14683 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14684 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14685 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14686 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14688 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14689 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14690 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14691 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14693 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14694 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14695 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14696 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14698 salt
->salt_len
= 16;
14699 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14701 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14703 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14706 return (PARSER_OK
);
14709 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14711 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14713 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14715 u32
*digest
= (u32
*) hash_buf
->digest
;
14717 salt_t
*salt
= hash_buf
->salt
;
14723 // first is the N salt parameter
14725 char *N_pos
= input_buf
+ 6;
14727 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14731 salt
->scrypt_N
= atoi (N_pos
);
14735 char *r_pos
= strchr (N_pos
, ':');
14737 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14741 salt
->scrypt_r
= atoi (r_pos
);
14745 char *p_pos
= strchr (r_pos
, ':');
14747 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14751 salt
->scrypt_p
= atoi (p_pos
);
14755 char *saltbuf_pos
= strchr (p_pos
, ':');
14757 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14761 char *hash_pos
= strchr (saltbuf_pos
, ':');
14763 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14769 u8 tmp_buf
[33] = { 0 };
14771 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14773 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14775 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14777 salt
->salt_len
= tmp_len
;
14778 salt
->salt_iter
= 1;
14780 // digest - base64 decode
14782 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14784 tmp_len
= input_len
- (hash_pos
- input_buf
);
14786 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14788 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14790 memcpy (digest
, tmp_buf
, 32);
14792 return (PARSER_OK
);
14795 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14797 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14799 u32
*digest
= (u32
*) hash_buf
->digest
;
14801 salt_t
*salt
= hash_buf
->salt
;
14807 char decrypted
[76] = { 0 }; // iv + hash
14809 juniper_decrypt_hash (input_buf
, decrypted
);
14811 char *md5crypt_hash
= decrypted
+ 12;
14813 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14815 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14817 char *salt_pos
= md5crypt_hash
+ 3;
14819 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14821 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14823 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14827 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14829 return (PARSER_OK
);
14832 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14834 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14836 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14838 u32
*digest
= (u32
*) hash_buf
->digest
;
14840 salt_t
*salt
= hash_buf
->salt
;
14842 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14848 // first is *raw* salt
14850 char *salt_pos
= input_buf
+ 3;
14852 char *hash_pos
= strchr (salt_pos
, '$');
14854 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14856 uint salt_len
= hash_pos
- salt_pos
;
14858 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14862 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14864 memcpy (salt_buf_ptr
, salt_pos
, 14);
14866 salt_buf_ptr
[17] = 0x01;
14867 salt_buf_ptr
[18] = 0x80;
14869 // add some stuff to normal salt to make sorted happy
14871 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14872 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14873 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14874 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14876 salt
->salt_len
= salt_len
;
14877 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14879 // base64 decode hash
14881 u8 tmp_buf
[100] = { 0 };
14883 uint hash_len
= input_len
- 3 - salt_len
- 1;
14885 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14887 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14889 memcpy (digest
, tmp_buf
, 32);
14891 digest
[0] = byte_swap_32 (digest
[0]);
14892 digest
[1] = byte_swap_32 (digest
[1]);
14893 digest
[2] = byte_swap_32 (digest
[2]);
14894 digest
[3] = byte_swap_32 (digest
[3]);
14895 digest
[4] = byte_swap_32 (digest
[4]);
14896 digest
[5] = byte_swap_32 (digest
[5]);
14897 digest
[6] = byte_swap_32 (digest
[6]);
14898 digest
[7] = byte_swap_32 (digest
[7]);
14900 return (PARSER_OK
);
14903 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14905 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14907 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14909 u32
*digest
= (u32
*) hash_buf
->digest
;
14911 salt_t
*salt
= hash_buf
->salt
;
14917 // first is *raw* salt
14919 char *salt_pos
= input_buf
+ 3;
14921 char *hash_pos
= strchr (salt_pos
, '$');
14923 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14925 uint salt_len
= hash_pos
- salt_pos
;
14927 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14929 salt
->salt_len
= salt_len
;
14932 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14934 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14935 salt_buf_ptr
[salt_len
] = 0;
14937 // base64 decode hash
14939 u8 tmp_buf
[100] = { 0 };
14941 uint hash_len
= input_len
- 3 - salt_len
- 1;
14943 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14945 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14947 memcpy (digest
, tmp_buf
, 32);
14950 salt
->scrypt_N
= 16384;
14951 salt
->scrypt_r
= 1;
14952 salt
->scrypt_p
= 1;
14953 salt
->salt_iter
= 1;
14955 return (PARSER_OK
);
14958 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14960 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14962 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14964 u32
*digest
= (u32
*) hash_buf
->digest
;
14966 salt_t
*salt
= hash_buf
->salt
;
14968 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14974 char *version_pos
= input_buf
+ 8 + 1;
14976 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14978 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14980 u32 version_len
= verifierHashSize_pos
- version_pos
;
14982 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14984 verifierHashSize_pos
++;
14986 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14988 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14990 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14992 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14996 char *saltSize_pos
= strchr (keySize_pos
, '*');
14998 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15000 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15002 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15006 char *osalt_pos
= strchr (saltSize_pos
, '*');
15008 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15010 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15012 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15016 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15018 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15020 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15022 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15024 encryptedVerifier_pos
++;
15026 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15028 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15030 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15032 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15034 encryptedVerifierHash_pos
++;
15036 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;
15038 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15040 const uint version
= atoi (version_pos
);
15042 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15044 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15046 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15048 const uint keySize
= atoi (keySize_pos
);
15050 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15052 office2007
->keySize
= keySize
;
15054 const uint saltSize
= atoi (saltSize_pos
);
15056 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15062 salt
->salt_len
= 16;
15063 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15065 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15066 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15067 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15068 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15074 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15075 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15076 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15077 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15079 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15080 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15081 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15082 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15083 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15089 digest
[0] = office2007
->encryptedVerifierHash
[0];
15090 digest
[1] = office2007
->encryptedVerifierHash
[1];
15091 digest
[2] = office2007
->encryptedVerifierHash
[2];
15092 digest
[3] = office2007
->encryptedVerifierHash
[3];
15094 return (PARSER_OK
);
15097 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15099 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15101 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15103 u32
*digest
= (u32
*) hash_buf
->digest
;
15105 salt_t
*salt
= hash_buf
->salt
;
15107 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15113 char *version_pos
= input_buf
+ 8 + 1;
15115 char *spinCount_pos
= strchr (version_pos
, '*');
15117 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15119 u32 version_len
= spinCount_pos
- version_pos
;
15121 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15125 char *keySize_pos
= strchr (spinCount_pos
, '*');
15127 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15129 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15131 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15135 char *saltSize_pos
= strchr (keySize_pos
, '*');
15137 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15139 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15141 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15145 char *osalt_pos
= strchr (saltSize_pos
, '*');
15147 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15149 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15151 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15155 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15157 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15159 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15161 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15163 encryptedVerifier_pos
++;
15165 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15167 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15169 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15171 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15173 encryptedVerifierHash_pos
++;
15175 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;
15177 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15179 const uint version
= atoi (version_pos
);
15181 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15183 const uint spinCount
= atoi (spinCount_pos
);
15185 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15187 const uint keySize
= atoi (keySize_pos
);
15189 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15191 const uint saltSize
= atoi (saltSize_pos
);
15193 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15199 salt
->salt_len
= 16;
15200 salt
->salt_iter
= spinCount
;
15202 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15203 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15204 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15205 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15211 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15212 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15213 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15214 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15216 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15217 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15218 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15219 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15220 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15221 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15222 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15223 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15229 digest
[0] = office2010
->encryptedVerifierHash
[0];
15230 digest
[1] = office2010
->encryptedVerifierHash
[1];
15231 digest
[2] = office2010
->encryptedVerifierHash
[2];
15232 digest
[3] = office2010
->encryptedVerifierHash
[3];
15234 return (PARSER_OK
);
15237 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15239 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15241 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15243 u32
*digest
= (u32
*) hash_buf
->digest
;
15245 salt_t
*salt
= hash_buf
->salt
;
15247 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15253 char *version_pos
= input_buf
+ 8 + 1;
15255 char *spinCount_pos
= strchr (version_pos
, '*');
15257 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15259 u32 version_len
= spinCount_pos
- version_pos
;
15261 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15265 char *keySize_pos
= strchr (spinCount_pos
, '*');
15267 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15269 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15271 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15275 char *saltSize_pos
= strchr (keySize_pos
, '*');
15277 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15279 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15281 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15285 char *osalt_pos
= strchr (saltSize_pos
, '*');
15287 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15289 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15291 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15295 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15297 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15299 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15301 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15303 encryptedVerifier_pos
++;
15305 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15307 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15309 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15311 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15313 encryptedVerifierHash_pos
++;
15315 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;
15317 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15319 const uint version
= atoi (version_pos
);
15321 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15323 const uint spinCount
= atoi (spinCount_pos
);
15325 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15327 const uint keySize
= atoi (keySize_pos
);
15329 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15331 const uint saltSize
= atoi (saltSize_pos
);
15333 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15339 salt
->salt_len
= 16;
15340 salt
->salt_iter
= spinCount
;
15342 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15343 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15344 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15345 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15351 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15352 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15353 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15354 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15356 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15357 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15358 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15359 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15360 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15361 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15362 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15363 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15369 digest
[0] = office2013
->encryptedVerifierHash
[0];
15370 digest
[1] = office2013
->encryptedVerifierHash
[1];
15371 digest
[2] = office2013
->encryptedVerifierHash
[2];
15372 digest
[3] = office2013
->encryptedVerifierHash
[3];
15374 return (PARSER_OK
);
15377 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15379 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15381 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15383 u32
*digest
= (u32
*) hash_buf
->digest
;
15385 salt_t
*salt
= hash_buf
->salt
;
15387 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15393 char *version_pos
= input_buf
+ 11;
15395 char *osalt_pos
= strchr (version_pos
, '*');
15397 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15399 u32 version_len
= osalt_pos
- version_pos
;
15401 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15405 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15407 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15409 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15411 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15413 encryptedVerifier_pos
++;
15415 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15417 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15419 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15421 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15423 encryptedVerifierHash_pos
++;
15425 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15427 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15429 const uint version
= *version_pos
- 0x30;
15431 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15437 oldoffice01
->version
= version
;
15439 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15440 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15441 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15442 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15444 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15445 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15446 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15447 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15449 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15450 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15451 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15452 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15454 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15455 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15456 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15457 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15463 salt
->salt_len
= 16;
15465 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15466 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15467 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15468 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15470 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15471 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15472 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15473 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15475 // this is a workaround as office produces multiple documents with the same salt
15477 salt
->salt_len
+= 32;
15479 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15480 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15481 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15482 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15483 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15484 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15485 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15486 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15492 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15493 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15494 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15495 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15497 return (PARSER_OK
);
15500 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15502 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15505 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15507 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15509 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15511 u32
*digest
= (u32
*) hash_buf
->digest
;
15513 salt_t
*salt
= hash_buf
->salt
;
15515 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15521 char *version_pos
= input_buf
+ 11;
15523 char *osalt_pos
= strchr (version_pos
, '*');
15525 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15527 u32 version_len
= osalt_pos
- version_pos
;
15529 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15533 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15535 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15537 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15539 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15541 encryptedVerifier_pos
++;
15543 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15545 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15547 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15549 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15551 encryptedVerifierHash_pos
++;
15553 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15555 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15557 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15559 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15563 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15565 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15567 const uint version
= *version_pos
- 0x30;
15569 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15575 oldoffice01
->version
= version
;
15577 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15578 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15579 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15580 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15582 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15583 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15584 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15585 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15587 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15588 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15589 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15590 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15592 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15593 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15594 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15595 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15597 oldoffice01
->rc4key
[1] = 0;
15598 oldoffice01
->rc4key
[0] = 0;
15600 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15601 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15602 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15603 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15604 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15605 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15606 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15607 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15608 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15609 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15611 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15612 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15618 salt
->salt_len
= 16;
15620 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15621 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15622 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15623 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15625 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15626 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15627 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15628 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15630 // this is a workaround as office produces multiple documents with the same salt
15632 salt
->salt_len
+= 32;
15634 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15635 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15636 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15637 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15638 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15639 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15640 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15641 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15647 digest
[0] = oldoffice01
->rc4key
[0];
15648 digest
[1] = oldoffice01
->rc4key
[1];
15652 return (PARSER_OK
);
15655 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15657 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15659 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15661 u32
*digest
= (u32
*) hash_buf
->digest
;
15663 salt_t
*salt
= hash_buf
->salt
;
15665 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15671 char *version_pos
= input_buf
+ 11;
15673 char *osalt_pos
= strchr (version_pos
, '*');
15675 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15677 u32 version_len
= osalt_pos
- version_pos
;
15679 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15683 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15685 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15687 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15689 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15691 encryptedVerifier_pos
++;
15693 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15695 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15697 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15699 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15701 encryptedVerifierHash_pos
++;
15703 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15705 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15707 const uint version
= *version_pos
- 0x30;
15709 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15715 oldoffice34
->version
= version
;
15717 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15718 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15719 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15720 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15722 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15723 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15724 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15725 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15727 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15728 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15729 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15730 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15731 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15733 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15734 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15735 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15736 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15737 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15743 salt
->salt_len
= 16;
15745 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15746 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15747 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15748 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15750 // this is a workaround as office produces multiple documents with the same salt
15752 salt
->salt_len
+= 32;
15754 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15755 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15756 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15757 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15758 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15759 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15760 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15761 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15767 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15768 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15769 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15770 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15772 return (PARSER_OK
);
15775 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15777 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15779 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15782 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15784 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15786 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15788 u32
*digest
= (u32
*) hash_buf
->digest
;
15790 salt_t
*salt
= hash_buf
->salt
;
15792 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15798 char *version_pos
= input_buf
+ 11;
15800 char *osalt_pos
= strchr (version_pos
, '*');
15802 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15804 u32 version_len
= osalt_pos
- version_pos
;
15806 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15810 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15812 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15814 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15816 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15818 encryptedVerifier_pos
++;
15820 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15822 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15824 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15826 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15828 encryptedVerifierHash_pos
++;
15830 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15832 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15834 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15836 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15840 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15842 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15844 const uint version
= *version_pos
- 0x30;
15846 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15852 oldoffice34
->version
= version
;
15854 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15855 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15856 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15857 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15859 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15860 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15861 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15862 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15864 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15865 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15866 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15867 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15868 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15870 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15871 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15872 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15873 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15874 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15876 oldoffice34
->rc4key
[1] = 0;
15877 oldoffice34
->rc4key
[0] = 0;
15879 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15880 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15881 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15882 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15883 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15884 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15885 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15886 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15887 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15888 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15890 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15891 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15897 salt
->salt_len
= 16;
15899 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15900 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15901 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15902 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15904 // this is a workaround as office produces multiple documents with the same salt
15906 salt
->salt_len
+= 32;
15908 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15909 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15910 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15911 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15912 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15913 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15914 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15915 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15921 digest
[0] = oldoffice34
->rc4key
[0];
15922 digest
[1] = oldoffice34
->rc4key
[1];
15926 return (PARSER_OK
);
15929 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15931 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15933 u32
*digest
= (u32
*) hash_buf
->digest
;
15935 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15936 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15937 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15938 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15940 digest
[0] = byte_swap_32 (digest
[0]);
15941 digest
[1] = byte_swap_32 (digest
[1]);
15942 digest
[2] = byte_swap_32 (digest
[2]);
15943 digest
[3] = byte_swap_32 (digest
[3]);
15945 return (PARSER_OK
);
15948 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15950 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15952 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15954 u32
*digest
= (u32
*) hash_buf
->digest
;
15956 salt_t
*salt
= hash_buf
->salt
;
15958 char *signature_pos
= input_buf
;
15960 char *salt_pos
= strchr (signature_pos
, '$');
15962 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15964 u32 signature_len
= salt_pos
- signature_pos
;
15966 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15970 char *hash_pos
= strchr (salt_pos
, '$');
15972 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15974 u32 salt_len
= hash_pos
- salt_pos
;
15976 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15980 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15982 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15984 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
15985 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
15986 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
15987 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
15988 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
15990 digest
[0] -= SHA1M_A
;
15991 digest
[1] -= SHA1M_B
;
15992 digest
[2] -= SHA1M_C
;
15993 digest
[3] -= SHA1M_D
;
15994 digest
[4] -= SHA1M_E
;
15996 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15998 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16000 salt
->salt_len
= salt_len
;
16002 return (PARSER_OK
);
16005 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16007 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16009 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16011 u32
*digest
= (u32
*) hash_buf
->digest
;
16013 salt_t
*salt
= hash_buf
->salt
;
16015 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16021 char *iter_pos
= input_buf
+ 14;
16023 const int iter
= atoi (iter_pos
);
16025 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16027 salt
->salt_iter
= iter
- 1;
16029 char *salt_pos
= strchr (iter_pos
, '$');
16031 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16035 char *hash_pos
= strchr (salt_pos
, '$');
16037 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16039 const uint salt_len
= hash_pos
- salt_pos
;
16043 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16045 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16047 salt
->salt_len
= salt_len
;
16049 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16050 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16052 // add some stuff to normal salt to make sorted happy
16054 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16055 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16056 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16057 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16058 salt
->salt_buf
[4] = salt
->salt_iter
;
16060 // base64 decode hash
16062 u8 tmp_buf
[100] = { 0 };
16064 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16066 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16068 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16070 memcpy (digest
, tmp_buf
, 32);
16072 digest
[0] = byte_swap_32 (digest
[0]);
16073 digest
[1] = byte_swap_32 (digest
[1]);
16074 digest
[2] = byte_swap_32 (digest
[2]);
16075 digest
[3] = byte_swap_32 (digest
[3]);
16076 digest
[4] = byte_swap_32 (digest
[4]);
16077 digest
[5] = byte_swap_32 (digest
[5]);
16078 digest
[6] = byte_swap_32 (digest
[6]);
16079 digest
[7] = byte_swap_32 (digest
[7]);
16081 return (PARSER_OK
);
16084 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16086 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16088 u32
*digest
= (u32
*) hash_buf
->digest
;
16090 salt_t
*salt
= hash_buf
->salt
;
16092 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16093 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16097 digest
[0] = byte_swap_32 (digest
[0]);
16098 digest
[1] = byte_swap_32 (digest
[1]);
16100 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16101 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16102 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16104 char iter_c
= input_buf
[17];
16105 char iter_d
= input_buf
[19];
16107 // atm only defaults, let's see if there's more request
16108 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16109 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16111 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16113 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16114 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16115 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16116 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16118 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16119 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16120 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16121 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16123 salt
->salt_len
= 16;
16125 return (PARSER_OK
);
16128 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16130 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16132 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16134 u32
*digest
= (u32
*) hash_buf
->digest
;
16136 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16138 salt_t
*salt
= hash_buf
->salt
;
16140 char *salt_pos
= input_buf
+ 10;
16142 char *hash_pos
= strchr (salt_pos
, '$');
16144 uint salt_len
= hash_pos
- salt_pos
;
16146 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16150 uint hash_len
= input_len
- 10 - salt_len
- 1;
16152 // base64 decode salt
16154 u8 tmp_buf
[100] = { 0 };
16156 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16158 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16160 tmp_buf
[salt_len
] = 0x80;
16162 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16164 salt
->salt_len
= salt_len
;
16166 // base64 decode salt
16168 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16170 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16172 uint user_len
= hash_len
- 32;
16174 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16176 user_len
--; // skip the trailing space
16178 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16179 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16180 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16181 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16183 digest
[0] = byte_swap_32 (digest
[0]);
16184 digest
[1] = byte_swap_32 (digest
[1]);
16185 digest
[2] = byte_swap_32 (digest
[2]);
16186 digest
[3] = byte_swap_32 (digest
[3]);
16188 // store username for host only (output hash if cracked)
16190 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16191 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16193 return (PARSER_OK
);
16196 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16198 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16200 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16202 u32
*digest
= (u32
*) hash_buf
->digest
;
16204 salt_t
*salt
= hash_buf
->salt
;
16206 char *iter_pos
= input_buf
+ 10;
16208 u32 iter
= atoi (iter_pos
);
16212 return (PARSER_SALT_ITERATION
);
16215 iter
--; // first iteration is special
16217 salt
->salt_iter
= iter
;
16219 char *base64_pos
= strchr (iter_pos
, '}');
16221 if (base64_pos
== NULL
)
16223 return (PARSER_SIGNATURE_UNMATCHED
);
16228 // base64 decode salt
16230 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16232 u8 tmp_buf
[100] = { 0 };
16234 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16236 if (decoded_len
< 24)
16238 return (PARSER_SALT_LENGTH
);
16243 uint salt_len
= decoded_len
- 20;
16245 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16246 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16248 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16250 salt
->salt_len
= salt_len
;
16254 u32
*digest_ptr
= (u32
*) tmp_buf
;
16256 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16257 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16258 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16259 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16260 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16262 return (PARSER_OK
);
16265 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16267 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16269 u32
*digest
= (u32
*) hash_buf
->digest
;
16271 salt_t
*salt
= hash_buf
->salt
;
16273 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16274 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16275 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16276 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16277 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16279 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16281 uint salt_len
= input_len
- 40 - 1;
16283 char *salt_buf
= input_buf
+ 40 + 1;
16285 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16287 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16289 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16291 salt
->salt_len
= salt_len
;
16293 return (PARSER_OK
);
16296 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16298 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16300 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16302 u32
*digest
= (u32
*) hash_buf
->digest
;
16304 salt_t
*salt
= hash_buf
->salt
;
16306 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16312 char *V_pos
= input_buf
+ 5;
16314 char *R_pos
= strchr (V_pos
, '*');
16316 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16318 u32 V_len
= R_pos
- V_pos
;
16322 char *bits_pos
= strchr (R_pos
, '*');
16324 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16326 u32 R_len
= bits_pos
- R_pos
;
16330 char *P_pos
= strchr (bits_pos
, '*');
16332 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16334 u32 bits_len
= P_pos
- bits_pos
;
16338 char *enc_md_pos
= strchr (P_pos
, '*');
16340 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16342 u32 P_len
= enc_md_pos
- P_pos
;
16346 char *id_len_pos
= strchr (enc_md_pos
, '*');
16348 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16350 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16354 char *id_buf_pos
= strchr (id_len_pos
, '*');
16356 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16358 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16362 char *u_len_pos
= strchr (id_buf_pos
, '*');
16364 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16366 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16368 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16372 char *u_buf_pos
= strchr (u_len_pos
, '*');
16374 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16376 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16380 char *o_len_pos
= strchr (u_buf_pos
, '*');
16382 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16384 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16386 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16390 char *o_buf_pos
= strchr (o_len_pos
, '*');
16392 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16394 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16398 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;
16400 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16404 const int V
= atoi (V_pos
);
16405 const int R
= atoi (R_pos
);
16406 const int P
= atoi (P_pos
);
16408 if (V
!= 1) return (PARSER_SALT_VALUE
);
16409 if (R
!= 2) return (PARSER_SALT_VALUE
);
16411 const int enc_md
= atoi (enc_md_pos
);
16413 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16415 const int id_len
= atoi (id_len_pos
);
16416 const int u_len
= atoi (u_len_pos
);
16417 const int o_len
= atoi (o_len_pos
);
16419 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16420 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16421 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16423 const int bits
= atoi (bits_pos
);
16425 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16427 // copy data to esalt
16433 pdf
->enc_md
= enc_md
;
16435 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16436 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16437 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16438 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16439 pdf
->id_len
= id_len
;
16441 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16442 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16443 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16444 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16445 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16446 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16447 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16448 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16449 pdf
->u_len
= u_len
;
16451 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16452 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16453 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16454 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16455 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16456 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16457 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16458 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16459 pdf
->o_len
= o_len
;
16461 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16462 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16463 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16464 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16466 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16467 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16468 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16469 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16470 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16471 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16472 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16473 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16475 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16476 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16477 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16478 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16479 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16480 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16481 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16482 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16484 // we use ID for salt, maybe needs to change, we will see...
16486 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16487 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16488 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16489 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16490 salt
->salt_len
= pdf
->id_len
;
16492 digest
[0] = pdf
->u_buf
[0];
16493 digest
[1] = pdf
->u_buf
[1];
16494 digest
[2] = pdf
->u_buf
[2];
16495 digest
[3] = pdf
->u_buf
[3];
16497 return (PARSER_OK
);
16500 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16502 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16505 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16507 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16509 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16511 u32
*digest
= (u32
*) hash_buf
->digest
;
16513 salt_t
*salt
= hash_buf
->salt
;
16515 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16521 char *V_pos
= input_buf
+ 5;
16523 char *R_pos
= strchr (V_pos
, '*');
16525 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16527 u32 V_len
= R_pos
- V_pos
;
16531 char *bits_pos
= strchr (R_pos
, '*');
16533 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16535 u32 R_len
= bits_pos
- R_pos
;
16539 char *P_pos
= strchr (bits_pos
, '*');
16541 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16543 u32 bits_len
= P_pos
- bits_pos
;
16547 char *enc_md_pos
= strchr (P_pos
, '*');
16549 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16551 u32 P_len
= enc_md_pos
- P_pos
;
16555 char *id_len_pos
= strchr (enc_md_pos
, '*');
16557 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16559 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16563 char *id_buf_pos
= strchr (id_len_pos
, '*');
16565 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16567 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16571 char *u_len_pos
= strchr (id_buf_pos
, '*');
16573 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16575 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16577 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16581 char *u_buf_pos
= strchr (u_len_pos
, '*');
16583 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16585 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16589 char *o_len_pos
= strchr (u_buf_pos
, '*');
16591 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16593 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16595 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16599 char *o_buf_pos
= strchr (o_len_pos
, '*');
16601 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16603 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16607 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16609 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16611 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16613 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16617 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;
16619 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16623 const int V
= atoi (V_pos
);
16624 const int R
= atoi (R_pos
);
16625 const int P
= atoi (P_pos
);
16627 if (V
!= 1) return (PARSER_SALT_VALUE
);
16628 if (R
!= 2) return (PARSER_SALT_VALUE
);
16630 const int enc_md
= atoi (enc_md_pos
);
16632 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16634 const int id_len
= atoi (id_len_pos
);
16635 const int u_len
= atoi (u_len_pos
);
16636 const int o_len
= atoi (o_len_pos
);
16638 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16639 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16640 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16642 const int bits
= atoi (bits_pos
);
16644 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16646 // copy data to esalt
16652 pdf
->enc_md
= enc_md
;
16654 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16655 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16656 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16657 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16658 pdf
->id_len
= id_len
;
16660 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16661 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16662 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16663 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16664 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16665 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16666 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16667 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16668 pdf
->u_len
= u_len
;
16670 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16671 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16672 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16673 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16674 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16675 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16676 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16677 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16678 pdf
->o_len
= o_len
;
16680 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16681 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16682 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16683 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16685 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16686 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16687 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16688 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16689 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16690 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16691 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16692 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16694 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16695 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16696 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16697 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16698 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16699 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16700 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16701 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16703 pdf
->rc4key
[1] = 0;
16704 pdf
->rc4key
[0] = 0;
16706 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16707 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16708 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16709 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16710 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16711 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16712 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16713 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16714 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16715 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16717 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16718 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16720 // we use ID for salt, maybe needs to change, we will see...
16722 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16723 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16724 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16725 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16726 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16727 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16728 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16729 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16730 salt
->salt_len
= pdf
->id_len
+ 16;
16732 digest
[0] = pdf
->rc4key
[0];
16733 digest
[1] = pdf
->rc4key
[1];
16737 return (PARSER_OK
);
16740 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16742 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16744 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16746 u32
*digest
= (u32
*) hash_buf
->digest
;
16748 salt_t
*salt
= hash_buf
->salt
;
16750 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16756 char *V_pos
= input_buf
+ 5;
16758 char *R_pos
= strchr (V_pos
, '*');
16760 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16762 u32 V_len
= R_pos
- V_pos
;
16766 char *bits_pos
= strchr (R_pos
, '*');
16768 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16770 u32 R_len
= bits_pos
- R_pos
;
16774 char *P_pos
= strchr (bits_pos
, '*');
16776 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16778 u32 bits_len
= P_pos
- bits_pos
;
16782 char *enc_md_pos
= strchr (P_pos
, '*');
16784 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16786 u32 P_len
= enc_md_pos
- P_pos
;
16790 char *id_len_pos
= strchr (enc_md_pos
, '*');
16792 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16794 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16798 char *id_buf_pos
= strchr (id_len_pos
, '*');
16800 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16802 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16806 char *u_len_pos
= strchr (id_buf_pos
, '*');
16808 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16810 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16812 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16816 char *u_buf_pos
= strchr (u_len_pos
, '*');
16818 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16820 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16824 char *o_len_pos
= strchr (u_buf_pos
, '*');
16826 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16828 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16830 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16834 char *o_buf_pos
= strchr (o_len_pos
, '*');
16836 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16838 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16842 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;
16844 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16848 const int V
= atoi (V_pos
);
16849 const int R
= atoi (R_pos
);
16850 const int P
= atoi (P_pos
);
16854 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16855 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16857 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16859 const int id_len
= atoi (id_len_pos
);
16860 const int u_len
= atoi (u_len_pos
);
16861 const int o_len
= atoi (o_len_pos
);
16863 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16865 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16866 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16868 const int bits
= atoi (bits_pos
);
16870 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16876 enc_md
= atoi (enc_md_pos
);
16879 // copy data to esalt
16885 pdf
->enc_md
= enc_md
;
16887 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16888 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16889 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16890 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16894 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
16895 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
16896 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
16897 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
16900 pdf
->id_len
= id_len
;
16902 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16903 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16904 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16905 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16906 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16907 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16908 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16909 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16910 pdf
->u_len
= u_len
;
16912 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16913 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16914 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16915 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16916 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16917 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16918 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16919 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16920 pdf
->o_len
= o_len
;
16922 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16923 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16924 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16925 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16929 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16930 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16931 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16932 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16935 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16936 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16937 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16938 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16939 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16940 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16941 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16942 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16944 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16945 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16946 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16947 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16948 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16949 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16950 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16951 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16953 // precompute rc4 data for later use
16969 uint salt_pc_block
[32] = { 0 };
16971 char *salt_pc_ptr
= (char *) salt_pc_block
;
16973 memcpy (salt_pc_ptr
, padding
, 32);
16974 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16976 uint salt_pc_digest
[4] = { 0 };
16978 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16980 pdf
->rc4data
[0] = salt_pc_digest
[0];
16981 pdf
->rc4data
[1] = salt_pc_digest
[1];
16983 // we use ID for salt, maybe needs to change, we will see...
16985 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16986 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16987 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16988 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16989 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16990 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16991 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16992 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16993 salt
->salt_len
= pdf
->id_len
+ 16;
16995 salt
->salt_iter
= ROUNDS_PDF14
;
16997 digest
[0] = pdf
->u_buf
[0];
16998 digest
[1] = pdf
->u_buf
[1];
17002 return (PARSER_OK
);
17005 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17007 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17009 if (ret
!= PARSER_OK
)
17014 u32
*digest
= (u32
*) hash_buf
->digest
;
17016 salt_t
*salt
= hash_buf
->salt
;
17018 digest
[0] -= SHA256M_A
;
17019 digest
[1] -= SHA256M_B
;
17020 digest
[2] -= SHA256M_C
;
17021 digest
[3] -= SHA256M_D
;
17022 digest
[4] -= SHA256M_E
;
17023 digest
[5] -= SHA256M_F
;
17024 digest
[6] -= SHA256M_G
;
17025 digest
[7] -= SHA256M_H
;
17027 salt
->salt_buf
[2] = 0x80;
17029 return (PARSER_OK
);
17032 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17034 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17036 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17038 u32
*digest
= (u32
*) hash_buf
->digest
;
17040 salt_t
*salt
= hash_buf
->salt
;
17042 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17048 char *V_pos
= input_buf
+ 5;
17050 char *R_pos
= strchr (V_pos
, '*');
17052 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17054 u32 V_len
= R_pos
- V_pos
;
17058 char *bits_pos
= strchr (R_pos
, '*');
17060 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17062 u32 R_len
= bits_pos
- R_pos
;
17066 char *P_pos
= strchr (bits_pos
, '*');
17068 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17070 u32 bits_len
= P_pos
- bits_pos
;
17074 char *enc_md_pos
= strchr (P_pos
, '*');
17076 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17078 u32 P_len
= enc_md_pos
- P_pos
;
17082 char *id_len_pos
= strchr (enc_md_pos
, '*');
17084 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17086 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17090 char *id_buf_pos
= strchr (id_len_pos
, '*');
17092 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17094 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17098 char *u_len_pos
= strchr (id_buf_pos
, '*');
17100 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17102 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17106 char *u_buf_pos
= strchr (u_len_pos
, '*');
17108 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17110 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17114 char *o_len_pos
= strchr (u_buf_pos
, '*');
17116 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17118 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17122 char *o_buf_pos
= strchr (o_len_pos
, '*');
17124 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17126 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17130 char *last
= strchr (o_buf_pos
, '*');
17132 if (last
== NULL
) last
= input_buf
+ input_len
;
17134 u32 o_buf_len
= last
- o_buf_pos
;
17138 const int V
= atoi (V_pos
);
17139 const int R
= atoi (R_pos
);
17143 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17144 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17146 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17148 const int bits
= atoi (bits_pos
);
17150 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17152 int enc_md
= atoi (enc_md_pos
);
17154 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17156 const uint id_len
= atoi (id_len_pos
);
17157 const uint u_len
= atoi (u_len_pos
);
17158 const uint o_len
= atoi (o_len_pos
);
17160 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17161 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17162 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17163 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17164 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17165 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17166 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17167 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17169 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17170 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17171 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17173 // copy data to esalt
17175 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17177 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17179 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17182 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17183 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17185 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17186 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17188 salt
->salt_len
= 8;
17189 salt
->salt_iter
= ROUNDS_PDF17L8
;
17191 digest
[0] = pdf
->u_buf
[0];
17192 digest
[1] = pdf
->u_buf
[1];
17193 digest
[2] = pdf
->u_buf
[2];
17194 digest
[3] = pdf
->u_buf
[3];
17195 digest
[4] = pdf
->u_buf
[4];
17196 digest
[5] = pdf
->u_buf
[5];
17197 digest
[6] = pdf
->u_buf
[6];
17198 digest
[7] = pdf
->u_buf
[7];
17200 return (PARSER_OK
);
17203 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17205 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17207 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17209 u32
*digest
= (u32
*) hash_buf
->digest
;
17211 salt_t
*salt
= hash_buf
->salt
;
17213 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17221 char *iter_pos
= input_buf
+ 7;
17223 u32 iter
= atoi (iter_pos
);
17225 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17226 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17228 // first is *raw* salt
17230 char *salt_pos
= strchr (iter_pos
, ':');
17232 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17236 char *hash_pos
= strchr (salt_pos
, ':');
17238 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17240 u32 salt_len
= hash_pos
- salt_pos
;
17242 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17246 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17248 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17252 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17254 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17256 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17258 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17259 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17261 salt
->salt_len
= salt_len
;
17262 salt
->salt_iter
= iter
- 1;
17266 u8 tmp_buf
[100] = { 0 };
17268 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17270 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17272 memcpy (digest
, tmp_buf
, 16);
17274 digest
[0] = byte_swap_32 (digest
[0]);
17275 digest
[1] = byte_swap_32 (digest
[1]);
17276 digest
[2] = byte_swap_32 (digest
[2]);
17277 digest
[3] = byte_swap_32 (digest
[3]);
17279 // add some stuff to normal salt to make sorted happy
17281 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17282 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17283 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17284 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17285 salt
->salt_buf
[4] = salt
->salt_iter
;
17287 return (PARSER_OK
);
17290 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17292 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17294 u32
*digest
= (u32
*) hash_buf
->digest
;
17296 salt_t
*salt
= hash_buf
->salt
;
17298 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17299 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17300 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17301 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17303 digest
[0] = byte_swap_32 (digest
[0]);
17304 digest
[1] = byte_swap_32 (digest
[1]);
17305 digest
[2] = byte_swap_32 (digest
[2]);
17306 digest
[3] = byte_swap_32 (digest
[3]);
17308 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17310 uint salt_len
= input_len
- 32 - 1;
17312 char *salt_buf
= input_buf
+ 32 + 1;
17314 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17316 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17318 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17320 salt
->salt_len
= salt_len
;
17322 return (PARSER_OK
);
17325 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17327 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17329 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17331 u32
*digest
= (u32
*) hash_buf
->digest
;
17333 salt_t
*salt
= hash_buf
->salt
;
17335 char *user_pos
= input_buf
+ 10;
17337 char *salt_pos
= strchr (user_pos
, '*');
17339 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17343 char *hash_pos
= strchr (salt_pos
, '*');
17347 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17349 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17351 uint user_len
= salt_pos
- user_pos
- 1;
17353 uint salt_len
= hash_pos
- salt_pos
- 1;
17355 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17361 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17362 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17363 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17364 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17366 digest
[0] = byte_swap_32 (digest
[0]);
17367 digest
[1] = byte_swap_32 (digest
[1]);
17368 digest
[2] = byte_swap_32 (digest
[2]);
17369 digest
[3] = byte_swap_32 (digest
[3]);
17371 digest
[0] -= MD5M_A
;
17372 digest
[1] -= MD5M_B
;
17373 digest
[2] -= MD5M_C
;
17374 digest
[3] -= MD5M_D
;
17380 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17382 // first 4 bytes are the "challenge"
17384 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17385 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17386 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17387 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17389 // append the user name
17391 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17393 salt
->salt_len
= 4 + user_len
;
17395 return (PARSER_OK
);
17398 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17400 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17402 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17404 u32
*digest
= (u32
*) hash_buf
->digest
;
17406 salt_t
*salt
= hash_buf
->salt
;
17408 char *salt_pos
= input_buf
+ 9;
17410 char *hash_pos
= strchr (salt_pos
, '*');
17412 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17416 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17418 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17420 uint salt_len
= hash_pos
- salt_pos
- 1;
17422 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17428 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17429 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17430 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17431 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17432 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17438 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17440 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17442 salt
->salt_len
= salt_len
;
17444 return (PARSER_OK
);
17447 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17449 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17451 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17453 u32
*digest
= (u32
*) hash_buf
->digest
;
17455 salt_t
*salt
= hash_buf
->salt
;
17457 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17463 char *cry_master_len_pos
= input_buf
+ 9;
17465 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17467 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17469 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17471 cry_master_buf_pos
++;
17473 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17475 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17477 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17479 cry_salt_len_pos
++;
17481 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17483 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17485 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17487 cry_salt_buf_pos
++;
17489 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17491 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17493 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17497 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17499 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17501 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17505 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17507 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17509 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17513 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17515 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17517 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17519 public_key_len_pos
++;
17521 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17523 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17525 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17527 public_key_buf_pos
++;
17529 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;
17531 const uint cry_master_len
= atoi (cry_master_len_pos
);
17532 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17533 const uint ckey_len
= atoi (ckey_len_pos
);
17534 const uint public_key_len
= atoi (public_key_len_pos
);
17536 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17537 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17538 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17539 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17541 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17543 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17545 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17548 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17550 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17552 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17555 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17557 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17559 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17562 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17563 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17564 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17567 * store digest (should be unique enought, hopefully)
17570 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17571 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17572 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17573 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17579 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17581 const uint cry_rounds
= atoi (cry_rounds_pos
);
17583 salt
->salt_iter
= cry_rounds
- 1;
17585 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17587 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17589 salt
->salt_len
= salt_len
;
17591 return (PARSER_OK
);
17594 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17596 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17598 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17600 u32
*digest
= (u32
*) hash_buf
->digest
;
17602 salt_t
*salt
= hash_buf
->salt
;
17604 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17606 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17608 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17610 memcpy (temp_input_buf
, input_buf
, input_len
);
17614 char *URI_server_pos
= temp_input_buf
+ 6;
17616 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17618 if (URI_client_pos
== NULL
)
17620 myfree (temp_input_buf
);
17622 return (PARSER_SEPARATOR_UNMATCHED
);
17625 URI_client_pos
[0] = 0;
17628 uint URI_server_len
= strlen (URI_server_pos
);
17630 if (URI_server_len
> 512)
17632 myfree (temp_input_buf
);
17634 return (PARSER_SALT_LENGTH
);
17639 char *user_pos
= strchr (URI_client_pos
, '*');
17641 if (user_pos
== NULL
)
17643 myfree (temp_input_buf
);
17645 return (PARSER_SEPARATOR_UNMATCHED
);
17651 uint URI_client_len
= strlen (URI_client_pos
);
17653 if (URI_client_len
> 512)
17655 myfree (temp_input_buf
);
17657 return (PARSER_SALT_LENGTH
);
17662 char *realm_pos
= strchr (user_pos
, '*');
17664 if (realm_pos
== NULL
)
17666 myfree (temp_input_buf
);
17668 return (PARSER_SEPARATOR_UNMATCHED
);
17674 uint user_len
= strlen (user_pos
);
17676 if (user_len
> 116)
17678 myfree (temp_input_buf
);
17680 return (PARSER_SALT_LENGTH
);
17685 char *method_pos
= strchr (realm_pos
, '*');
17687 if (method_pos
== NULL
)
17689 myfree (temp_input_buf
);
17691 return (PARSER_SEPARATOR_UNMATCHED
);
17697 uint realm_len
= strlen (realm_pos
);
17699 if (realm_len
> 116)
17701 myfree (temp_input_buf
);
17703 return (PARSER_SALT_LENGTH
);
17708 char *URI_prefix_pos
= strchr (method_pos
, '*');
17710 if (URI_prefix_pos
== NULL
)
17712 myfree (temp_input_buf
);
17714 return (PARSER_SEPARATOR_UNMATCHED
);
17717 URI_prefix_pos
[0] = 0;
17720 uint method_len
= strlen (method_pos
);
17722 if (method_len
> 246)
17724 myfree (temp_input_buf
);
17726 return (PARSER_SALT_LENGTH
);
17731 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17733 if (URI_resource_pos
== NULL
)
17735 myfree (temp_input_buf
);
17737 return (PARSER_SEPARATOR_UNMATCHED
);
17740 URI_resource_pos
[0] = 0;
17741 URI_resource_pos
++;
17743 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17745 if (URI_prefix_len
> 245)
17747 myfree (temp_input_buf
);
17749 return (PARSER_SALT_LENGTH
);
17754 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17756 if (URI_suffix_pos
== NULL
)
17758 myfree (temp_input_buf
);
17760 return (PARSER_SEPARATOR_UNMATCHED
);
17763 URI_suffix_pos
[0] = 0;
17766 uint URI_resource_len
= strlen (URI_resource_pos
);
17768 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17770 myfree (temp_input_buf
);
17772 return (PARSER_SALT_LENGTH
);
17777 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17779 if (nonce_pos
== NULL
)
17781 myfree (temp_input_buf
);
17783 return (PARSER_SEPARATOR_UNMATCHED
);
17789 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17791 if (URI_suffix_len
> 245)
17793 myfree (temp_input_buf
);
17795 return (PARSER_SALT_LENGTH
);
17800 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17802 if (nonce_client_pos
== NULL
)
17804 myfree (temp_input_buf
);
17806 return (PARSER_SEPARATOR_UNMATCHED
);
17809 nonce_client_pos
[0] = 0;
17810 nonce_client_pos
++;
17812 uint nonce_len
= strlen (nonce_pos
);
17814 if (nonce_len
< 1 || nonce_len
> 50)
17816 myfree (temp_input_buf
);
17818 return (PARSER_SALT_LENGTH
);
17823 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17825 if (nonce_count_pos
== NULL
)
17827 myfree (temp_input_buf
);
17829 return (PARSER_SEPARATOR_UNMATCHED
);
17832 nonce_count_pos
[0] = 0;
17835 uint nonce_client_len
= strlen (nonce_client_pos
);
17837 if (nonce_client_len
> 50)
17839 myfree (temp_input_buf
);
17841 return (PARSER_SALT_LENGTH
);
17846 char *qop_pos
= strchr (nonce_count_pos
, '*');
17848 if (qop_pos
== NULL
)
17850 myfree (temp_input_buf
);
17852 return (PARSER_SEPARATOR_UNMATCHED
);
17858 uint nonce_count_len
= strlen (nonce_count_pos
);
17860 if (nonce_count_len
> 50)
17862 myfree (temp_input_buf
);
17864 return (PARSER_SALT_LENGTH
);
17869 char *directive_pos
= strchr (qop_pos
, '*');
17871 if (directive_pos
== NULL
)
17873 myfree (temp_input_buf
);
17875 return (PARSER_SEPARATOR_UNMATCHED
);
17878 directive_pos
[0] = 0;
17881 uint qop_len
= strlen (qop_pos
);
17885 myfree (temp_input_buf
);
17887 return (PARSER_SALT_LENGTH
);
17892 char *digest_pos
= strchr (directive_pos
, '*');
17894 if (digest_pos
== NULL
)
17896 myfree (temp_input_buf
);
17898 return (PARSER_SEPARATOR_UNMATCHED
);
17904 uint directive_len
= strlen (directive_pos
);
17906 if (directive_len
!= 3)
17908 myfree (temp_input_buf
);
17910 return (PARSER_SALT_LENGTH
);
17913 if (memcmp (directive_pos
, "MD5", 3))
17915 log_info ("ERROR: only the MD5 directive is currently supported\n");
17917 myfree (temp_input_buf
);
17919 return (PARSER_SIP_AUTH_DIRECTIVE
);
17923 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17928 uint md5_max_len
= 4 * 64;
17930 uint md5_remaining_len
= md5_max_len
;
17932 uint tmp_md5_buf
[64] = { 0 };
17934 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17936 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17938 md5_len
+= method_len
+ 1;
17939 tmp_md5_ptr
+= method_len
+ 1;
17941 if (URI_prefix_len
> 0)
17943 md5_remaining_len
= md5_max_len
- md5_len
;
17945 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17947 md5_len
+= URI_prefix_len
+ 1;
17948 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17951 md5_remaining_len
= md5_max_len
- md5_len
;
17953 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17955 md5_len
+= URI_resource_len
;
17956 tmp_md5_ptr
+= URI_resource_len
;
17958 if (URI_suffix_len
> 0)
17960 md5_remaining_len
= md5_max_len
- md5_len
;
17962 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17964 md5_len
+= 1 + URI_suffix_len
;
17967 uint tmp_digest
[4] = { 0 };
17969 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17971 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17972 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17973 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17974 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17980 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17982 uint esalt_len
= 0;
17984 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17986 // there are 2 possibilities for the esalt:
17988 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17990 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17992 if (esalt_len
> max_esalt_len
)
17994 myfree (temp_input_buf
);
17996 return (PARSER_SALT_LENGTH
);
17999 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18011 esalt_len
= 1 + nonce_len
+ 1 + 32;
18013 if (esalt_len
> max_esalt_len
)
18015 myfree (temp_input_buf
);
18017 return (PARSER_SALT_LENGTH
);
18020 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18028 // add 0x80 to esalt
18030 esalt_buf_ptr
[esalt_len
] = 0x80;
18032 sip
->esalt_len
= esalt_len
;
18038 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18040 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18042 uint max_salt_len
= 119;
18044 if (salt_len
> max_salt_len
)
18046 myfree (temp_input_buf
);
18048 return (PARSER_SALT_LENGTH
);
18051 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18053 sip
->salt_len
= salt_len
;
18056 * fake salt (for sorting)
18059 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18063 uint fake_salt_len
= salt_len
;
18065 if (fake_salt_len
> max_salt_len
)
18067 fake_salt_len
= max_salt_len
;
18070 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18072 salt
->salt_len
= fake_salt_len
;
18078 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18079 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18080 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18081 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18083 digest
[0] = byte_swap_32 (digest
[0]);
18084 digest
[1] = byte_swap_32 (digest
[1]);
18085 digest
[2] = byte_swap_32 (digest
[2]);
18086 digest
[3] = byte_swap_32 (digest
[3]);
18088 myfree (temp_input_buf
);
18090 return (PARSER_OK
);
18093 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18095 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18097 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18099 u32
*digest
= (u32
*) hash_buf
->digest
;
18101 salt_t
*salt
= hash_buf
->salt
;
18105 char *digest_pos
= input_buf
;
18107 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18114 char *salt_buf
= input_buf
+ 8 + 1;
18118 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18120 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18122 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18124 salt
->salt_len
= salt_len
;
18126 return (PARSER_OK
);
18129 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18131 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18133 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18135 u32
*digest
= (u32
*) hash_buf
->digest
;
18137 salt_t
*salt
= hash_buf
->salt
;
18139 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18145 char *p_buf_pos
= input_buf
+ 4;
18147 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18149 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18151 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18153 NumCyclesPower_pos
++;
18155 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18157 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18159 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18163 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18165 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18167 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18171 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18173 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18175 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18179 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18181 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18183 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18187 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18189 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18191 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18195 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18197 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18199 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18203 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18205 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18207 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18211 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18213 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18215 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18219 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;
18221 const uint iter
= atoi (NumCyclesPower_pos
);
18222 const uint crc
= atoi (crc_buf_pos
);
18223 const uint p_buf
= atoi (p_buf_pos
);
18224 const uint salt_len
= atoi (salt_len_pos
);
18225 const uint iv_len
= atoi (iv_len_pos
);
18226 const uint unpack_size
= atoi (unpack_size_pos
);
18227 const uint data_len
= atoi (data_len_pos
);
18233 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18234 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18236 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18238 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18240 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18246 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18247 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18248 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18249 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18251 seven_zip
->iv_len
= iv_len
;
18253 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18255 seven_zip
->salt_len
= 0;
18257 seven_zip
->crc
= crc
;
18259 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18261 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18263 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18266 seven_zip
->data_len
= data_len
;
18268 seven_zip
->unpack_size
= unpack_size
;
18272 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18273 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18274 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18275 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18277 salt
->salt_len
= 16;
18279 salt
->salt_sign
[0] = iter
;
18281 salt
->salt_iter
= 1 << iter
;
18292 return (PARSER_OK
);
18295 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18297 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18299 u32
*digest
= (u32
*) hash_buf
->digest
;
18301 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18302 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18303 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18304 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18305 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18306 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18307 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18308 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18310 digest
[0] = byte_swap_32 (digest
[0]);
18311 digest
[1] = byte_swap_32 (digest
[1]);
18312 digest
[2] = byte_swap_32 (digest
[2]);
18313 digest
[3] = byte_swap_32 (digest
[3]);
18314 digest
[4] = byte_swap_32 (digest
[4]);
18315 digest
[5] = byte_swap_32 (digest
[5]);
18316 digest
[6] = byte_swap_32 (digest
[6]);
18317 digest
[7] = byte_swap_32 (digest
[7]);
18319 return (PARSER_OK
);
18322 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18324 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18326 u32
*digest
= (u32
*) hash_buf
->digest
;
18328 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18329 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18330 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18331 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18332 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18333 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18334 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18335 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18336 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18337 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18338 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18339 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18340 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18341 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18342 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18343 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18345 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18346 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18347 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18348 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18349 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18350 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18351 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18352 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18353 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18354 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18355 digest
[10] = byte_swap_32 (digest
[10]);
18356 digest
[11] = byte_swap_32 (digest
[11]);
18357 digest
[12] = byte_swap_32 (digest
[12]);
18358 digest
[13] = byte_swap_32 (digest
[13]);
18359 digest
[14] = byte_swap_32 (digest
[14]);
18360 digest
[15] = byte_swap_32 (digest
[15]);
18362 return (PARSER_OK
);
18365 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18367 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18369 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18371 u32
*digest
= (u32
*) hash_buf
->digest
;
18373 salt_t
*salt
= hash_buf
->salt
;
18375 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18383 char *iter_pos
= input_buf
+ 4;
18385 u32 iter
= atoi (iter_pos
);
18387 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18388 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18390 // first is *raw* salt
18392 char *salt_pos
= strchr (iter_pos
, ':');
18394 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18398 char *hash_pos
= strchr (salt_pos
, ':');
18400 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18402 u32 salt_len
= hash_pos
- salt_pos
;
18404 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18408 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18410 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18414 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18416 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18418 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18420 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18421 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18423 salt
->salt_len
= salt_len
;
18424 salt
->salt_iter
= iter
- 1;
18428 u8 tmp_buf
[100] = { 0 };
18430 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18432 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18434 memcpy (digest
, tmp_buf
, 16);
18436 // add some stuff to normal salt to make sorted happy
18438 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18439 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18440 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18441 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18442 salt
->salt_buf
[4] = salt
->salt_iter
;
18444 return (PARSER_OK
);
18447 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18449 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18451 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18453 u32
*digest
= (u32
*) hash_buf
->digest
;
18455 salt_t
*salt
= hash_buf
->salt
;
18457 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18465 char *iter_pos
= input_buf
+ 5;
18467 u32 iter
= atoi (iter_pos
);
18469 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18470 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18472 // first is *raw* salt
18474 char *salt_pos
= strchr (iter_pos
, ':');
18476 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18480 char *hash_pos
= strchr (salt_pos
, ':');
18482 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18484 u32 salt_len
= hash_pos
- salt_pos
;
18486 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18490 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18492 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18496 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18498 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18500 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18502 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18503 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18505 salt
->salt_len
= salt_len
;
18506 salt
->salt_iter
= iter
- 1;
18510 u8 tmp_buf
[100] = { 0 };
18512 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18514 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18516 memcpy (digest
, tmp_buf
, 16);
18518 digest
[0] = byte_swap_32 (digest
[0]);
18519 digest
[1] = byte_swap_32 (digest
[1]);
18520 digest
[2] = byte_swap_32 (digest
[2]);
18521 digest
[3] = byte_swap_32 (digest
[3]);
18523 // add some stuff to normal salt to make sorted happy
18525 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18526 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18527 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18528 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18529 salt
->salt_buf
[4] = salt
->salt_iter
;
18531 return (PARSER_OK
);
18534 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18536 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18538 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18540 u64
*digest
= (u64
*) hash_buf
->digest
;
18542 salt_t
*salt
= hash_buf
->salt
;
18544 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18552 char *iter_pos
= input_buf
+ 7;
18554 u32 iter
= atoi (iter_pos
);
18556 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18557 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18559 // first is *raw* salt
18561 char *salt_pos
= strchr (iter_pos
, ':');
18563 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18567 char *hash_pos
= strchr (salt_pos
, ':');
18569 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18571 u32 salt_len
= hash_pos
- salt_pos
;
18573 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18577 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18579 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18583 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18585 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18587 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18589 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18590 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18592 salt
->salt_len
= salt_len
;
18593 salt
->salt_iter
= iter
- 1;
18597 u8 tmp_buf
[100] = { 0 };
18599 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18601 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18603 memcpy (digest
, tmp_buf
, 64);
18605 digest
[0] = byte_swap_64 (digest
[0]);
18606 digest
[1] = byte_swap_64 (digest
[1]);
18607 digest
[2] = byte_swap_64 (digest
[2]);
18608 digest
[3] = byte_swap_64 (digest
[3]);
18609 digest
[4] = byte_swap_64 (digest
[4]);
18610 digest
[5] = byte_swap_64 (digest
[5]);
18611 digest
[6] = byte_swap_64 (digest
[6]);
18612 digest
[7] = byte_swap_64 (digest
[7]);
18614 // add some stuff to normal salt to make sorted happy
18616 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18617 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18618 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18619 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18620 salt
->salt_buf
[4] = salt
->salt_iter
;
18622 return (PARSER_OK
);
18625 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18627 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18629 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18631 uint
*digest
= (uint
*) hash_buf
->digest
;
18633 salt_t
*salt
= hash_buf
->salt
;
18639 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18641 char *hash_pos
= strchr (salt_pos
, '$');
18643 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18645 u32 salt_len
= hash_pos
- salt_pos
;
18647 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18651 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18653 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18657 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18658 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18676 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18677 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18679 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18680 salt
->salt_len
= 8;
18682 return (PARSER_OK
);
18685 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18687 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18689 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18691 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18693 if (c19
& 3) return (PARSER_HASH_VALUE
);
18695 salt_t
*salt
= hash_buf
->salt
;
18697 u32
*digest
= (u32
*) hash_buf
->digest
;
18701 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18702 | itoa64_to_int (input_buf
[2]) << 6
18703 | itoa64_to_int (input_buf
[3]) << 12
18704 | itoa64_to_int (input_buf
[4]) << 18;
18708 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18709 | itoa64_to_int (input_buf
[6]) << 6
18710 | itoa64_to_int (input_buf
[7]) << 12
18711 | itoa64_to_int (input_buf
[8]) << 18;
18713 salt
->salt_len
= 4;
18715 u8 tmp_buf
[100] = { 0 };
18717 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18719 memcpy (digest
, tmp_buf
, 8);
18723 IP (digest
[0], digest
[1], tt
);
18725 digest
[0] = rotr32 (digest
[0], 31);
18726 digest
[1] = rotr32 (digest
[1], 31);
18730 return (PARSER_OK
);
18733 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18735 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18737 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18739 u32
*digest
= (u32
*) hash_buf
->digest
;
18741 salt_t
*salt
= hash_buf
->salt
;
18747 char *type_pos
= input_buf
+ 6 + 1;
18749 char *salt_pos
= strchr (type_pos
, '*');
18751 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18753 u32 type_len
= salt_pos
- type_pos
;
18755 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18759 char *crypted_pos
= strchr (salt_pos
, '*');
18761 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18763 u32 salt_len
= crypted_pos
- salt_pos
;
18765 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18769 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18771 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18777 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18778 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18780 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18781 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18783 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18784 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18785 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18786 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18788 salt
->salt_len
= 24;
18789 salt
->salt_iter
= ROUNDS_RAR3
;
18791 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18792 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18794 digest
[0] = 0xc43d7b00;
18795 digest
[1] = 0x40070000;
18799 return (PARSER_OK
);
18802 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18804 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18806 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18808 u32
*digest
= (u32
*) hash_buf
->digest
;
18810 salt_t
*salt
= hash_buf
->salt
;
18812 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18818 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18820 char *param1_pos
= strchr (param0_pos
, '$');
18822 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18824 u32 param0_len
= param1_pos
- param0_pos
;
18828 char *param2_pos
= strchr (param1_pos
, '$');
18830 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18832 u32 param1_len
= param2_pos
- param1_pos
;
18836 char *param3_pos
= strchr (param2_pos
, '$');
18838 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18840 u32 param2_len
= param3_pos
- param2_pos
;
18844 char *param4_pos
= strchr (param3_pos
, '$');
18846 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18848 u32 param3_len
= param4_pos
- param3_pos
;
18852 char *param5_pos
= strchr (param4_pos
, '$');
18854 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18856 u32 param4_len
= param5_pos
- param4_pos
;
18860 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18862 char *salt_buf
= param1_pos
;
18863 char *iv
= param3_pos
;
18864 char *pswcheck
= param5_pos
;
18866 const uint salt_len
= atoi (param0_pos
);
18867 const uint iterations
= atoi (param2_pos
);
18868 const uint pswcheck_len
= atoi (param4_pos
);
18874 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18875 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18876 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18878 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18879 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18880 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18886 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18887 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18888 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18889 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
18891 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
18892 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
18893 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
18894 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
18896 salt
->salt_len
= 16;
18898 salt
->salt_sign
[0] = iterations
;
18900 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18906 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
18907 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
18911 return (PARSER_OK
);
18914 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18916 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18918 u32
*digest
= (u32
*) hash_buf
->digest
;
18920 salt_t
*salt
= hash_buf
->salt
;
18922 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18923 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18924 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18925 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18926 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18927 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18928 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18929 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18931 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18933 uint salt_len
= input_len
- 64 - 1;
18935 char *salt_buf
= input_buf
+ 64 + 1;
18937 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18939 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18941 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18943 salt
->salt_len
= salt_len
;
18946 * we can precompute the first sha256 transform
18949 uint w
[16] = { 0 };
18951 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18952 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18953 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18954 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18955 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18956 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18957 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18958 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18959 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18960 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18961 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18962 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18963 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18964 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18965 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18966 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18968 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
18970 sha256_64 (w
, pc256
);
18972 salt
->salt_buf_pc
[0] = pc256
[0];
18973 salt
->salt_buf_pc
[1] = pc256
[1];
18974 salt
->salt_buf_pc
[2] = pc256
[2];
18975 salt
->salt_buf_pc
[3] = pc256
[3];
18976 salt
->salt_buf_pc
[4] = pc256
[4];
18977 salt
->salt_buf_pc
[5] = pc256
[5];
18978 salt
->salt_buf_pc
[6] = pc256
[6];
18979 salt
->salt_buf_pc
[7] = pc256
[7];
18981 digest
[0] -= pc256
[0];
18982 digest
[1] -= pc256
[1];
18983 digest
[2] -= pc256
[2];
18984 digest
[3] -= pc256
[3];
18985 digest
[4] -= pc256
[4];
18986 digest
[5] -= pc256
[5];
18987 digest
[6] -= pc256
[6];
18988 digest
[7] -= pc256
[7];
18990 return (PARSER_OK
);
18993 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18995 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18997 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18999 u32
*digest
= (u32
*) hash_buf
->digest
;
19001 salt_t
*salt
= hash_buf
->salt
;
19007 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
19009 char *data_buf_pos
= strchr (data_len_pos
, '$');
19011 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19013 u32 data_len_len
= data_buf_pos
- data_len_pos
;
19015 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
19016 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
19020 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
19022 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
19024 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
19026 u32 data_len
= atoi (data_len_pos
);
19028 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
19034 char *salt_pos
= data_buf_pos
;
19036 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19037 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19038 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
19039 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
19041 // this is actually the CT, which is also the hash later (if matched)
19043 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
19044 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
19045 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
19046 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
19048 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
19050 salt
->salt_iter
= 10 - 1;
19056 digest
[0] = salt
->salt_buf
[4];
19057 digest
[1] = salt
->salt_buf
[5];
19058 digest
[2] = salt
->salt_buf
[6];
19059 digest
[3] = salt
->salt_buf
[7];
19061 return (PARSER_OK
);
19064 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19066 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
19068 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19070 u32
*digest
= (u32
*) hash_buf
->digest
;
19072 salt_t
*salt
= hash_buf
->salt
;
19078 char *salt_pos
= input_buf
+ 11 + 1;
19080 char *iter_pos
= strchr (salt_pos
, ',');
19082 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19084 u32 salt_len
= iter_pos
- salt_pos
;
19086 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
19090 char *hash_pos
= strchr (iter_pos
, ',');
19092 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19094 u32 iter_len
= hash_pos
- iter_pos
;
19096 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
19100 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
19102 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
19108 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19109 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19110 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
19111 salt
->salt_buf
[3] = 0x00018000;
19113 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19114 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19115 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
19116 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
19118 salt
->salt_len
= salt_len
/ 2;
19120 salt
->salt_iter
= atoi (iter_pos
) - 1;
19126 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19127 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19128 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19129 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19130 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19131 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19132 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19133 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19135 return (PARSER_OK
);
19138 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19140 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
19142 u32
*digest
= (u32
*) hash_buf
->digest
;
19144 salt_t
*salt
= hash_buf
->salt
;
19150 char *hash_pos
= input_buf
+ 64;
19151 char *salt1_pos
= input_buf
+ 128;
19152 char *salt2_pos
= input_buf
;
19158 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
19159 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
19160 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
19161 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
19163 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
19164 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
19165 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
19166 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
19168 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
19169 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
19170 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
19171 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
19173 salt
->salt_len
= 48;
19175 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
19181 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19182 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19183 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19184 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19185 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19186 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19187 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19188 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19190 return (PARSER_OK
);
19194 * parallel running threads
19199 BOOL WINAPI
sigHandler_default (DWORD sig
)
19203 case CTRL_CLOSE_EVENT
:
19206 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
19207 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
19208 * function otherwise it is too late (e.g. after returning from this function)
19213 SetConsoleCtrlHandler (NULL
, TRUE
);
19220 case CTRL_LOGOFF_EVENT
:
19221 case CTRL_SHUTDOWN_EVENT
:
19225 SetConsoleCtrlHandler (NULL
, TRUE
);
19233 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19237 case CTRL_CLOSE_EVENT
:
19241 SetConsoleCtrlHandler (NULL
, TRUE
);
19248 case CTRL_LOGOFF_EVENT
:
19249 case CTRL_SHUTDOWN_EVENT
:
19253 SetConsoleCtrlHandler (NULL
, TRUE
);
19261 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19263 if (callback
== NULL
)
19265 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19269 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19275 void sigHandler_default (int sig
)
19279 signal (sig
, NULL
);
19282 void sigHandler_benchmark (int sig
)
19286 signal (sig
, NULL
);
19289 void hc_signal (void (callback
) (int))
19291 if (callback
== NULL
) callback
= SIG_DFL
;
19293 signal (SIGINT
, callback
);
19294 signal (SIGTERM
, callback
);
19295 signal (SIGABRT
, callback
);
19300 void status_display ();
19302 void *thread_keypress (void *p
)
19304 int benchmark
= *((int *) p
);
19306 uint quiet
= data
.quiet
;
19310 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19312 int ch
= tty_getchar();
19314 if (ch
== -1) break;
19316 if (ch
== 0) continue;
19322 hc_thread_mutex_lock (mux_display
);
19337 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19338 if (quiet
== 0) fflush (stdout
);
19350 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19351 if (quiet
== 0) fflush (stdout
);
19363 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19364 if (quiet
== 0) fflush (stdout
);
19376 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19377 if (quiet
== 0) fflush (stdout
);
19385 if (benchmark
== 1) break;
19387 stop_at_checkpoint ();
19391 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19392 if (quiet
== 0) fflush (stdout
);
19400 if (benchmark
== 1)
19412 hc_thread_mutex_unlock (mux_display
);
19424 bool class_num (const u8 c
)
19426 return ((c
>= '0') && (c
<= '9'));
19429 bool class_lower (const u8 c
)
19431 return ((c
>= 'a') && (c
<= 'z'));
19434 bool class_upper (const u8 c
)
19436 return ((c
>= 'A') && (c
<= 'Z'));
19439 bool class_alpha (const u8 c
)
19441 return (class_lower (c
) || class_upper (c
));
19444 int conv_ctoi (const u8 c
)
19450 else if (class_upper (c
))
19452 return c
- 'A' + 10;
19458 int conv_itoc (const u8 c
)
19466 return c
+ 'A' - 10;
19476 #define INCR_POS if (++rule_pos == rule_len) return (-1)
19477 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
19478 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
19479 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
19480 #define MAX_KERNEL_RULES 255
19481 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
19482 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19483 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19485 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
19486 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
19487 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19488 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19490 int cpu_rule_to_kernel_rule (char rule_buf
[BUFSIZ
], uint rule_len
, kernel_rule_t
*rule
)
19495 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19497 switch (rule_buf
[rule_pos
])
19503 case RULE_OP_MANGLE_NOOP
:
19504 SET_NAME (rule
, rule_buf
[rule_pos
]);
19507 case RULE_OP_MANGLE_LREST
:
19508 SET_NAME (rule
, rule_buf
[rule_pos
]);
19511 case RULE_OP_MANGLE_UREST
:
19512 SET_NAME (rule
, rule_buf
[rule_pos
]);
19515 case RULE_OP_MANGLE_LREST_UFIRST
:
19516 SET_NAME (rule
, rule_buf
[rule_pos
]);
19519 case RULE_OP_MANGLE_UREST_LFIRST
:
19520 SET_NAME (rule
, rule_buf
[rule_pos
]);
19523 case RULE_OP_MANGLE_TREST
:
19524 SET_NAME (rule
, rule_buf
[rule_pos
]);
19527 case RULE_OP_MANGLE_TOGGLE_AT
:
19528 SET_NAME (rule
, rule_buf
[rule_pos
]);
19529 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19532 case RULE_OP_MANGLE_REVERSE
:
19533 SET_NAME (rule
, rule_buf
[rule_pos
]);
19536 case RULE_OP_MANGLE_DUPEWORD
:
19537 SET_NAME (rule
, rule_buf
[rule_pos
]);
19540 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19541 SET_NAME (rule
, rule_buf
[rule_pos
]);
19542 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19545 case RULE_OP_MANGLE_REFLECT
:
19546 SET_NAME (rule
, rule_buf
[rule_pos
]);
19549 case RULE_OP_MANGLE_ROTATE_LEFT
:
19550 SET_NAME (rule
, rule_buf
[rule_pos
]);
19553 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19554 SET_NAME (rule
, rule_buf
[rule_pos
]);
19557 case RULE_OP_MANGLE_APPEND
:
19558 SET_NAME (rule
, rule_buf
[rule_pos
]);
19559 SET_P0 (rule
, rule_buf
[rule_pos
]);
19562 case RULE_OP_MANGLE_PREPEND
:
19563 SET_NAME (rule
, rule_buf
[rule_pos
]);
19564 SET_P0 (rule
, rule_buf
[rule_pos
]);
19567 case RULE_OP_MANGLE_DELETE_FIRST
:
19568 SET_NAME (rule
, rule_buf
[rule_pos
]);
19571 case RULE_OP_MANGLE_DELETE_LAST
:
19572 SET_NAME (rule
, rule_buf
[rule_pos
]);
19575 case RULE_OP_MANGLE_DELETE_AT
:
19576 SET_NAME (rule
, rule_buf
[rule_pos
]);
19577 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19580 case RULE_OP_MANGLE_EXTRACT
:
19581 SET_NAME (rule
, rule_buf
[rule_pos
]);
19582 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19583 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19586 case RULE_OP_MANGLE_OMIT
:
19587 SET_NAME (rule
, rule_buf
[rule_pos
]);
19588 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19589 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19592 case RULE_OP_MANGLE_INSERT
:
19593 SET_NAME (rule
, rule_buf
[rule_pos
]);
19594 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19595 SET_P1 (rule
, rule_buf
[rule_pos
]);
19598 case RULE_OP_MANGLE_OVERSTRIKE
:
19599 SET_NAME (rule
, rule_buf
[rule_pos
]);
19600 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19601 SET_P1 (rule
, rule_buf
[rule_pos
]);
19604 case RULE_OP_MANGLE_TRUNCATE_AT
:
19605 SET_NAME (rule
, rule_buf
[rule_pos
]);
19606 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19609 case RULE_OP_MANGLE_REPLACE
:
19610 SET_NAME (rule
, rule_buf
[rule_pos
]);
19611 SET_P0 (rule
, rule_buf
[rule_pos
]);
19612 SET_P1 (rule
, rule_buf
[rule_pos
]);
19615 case RULE_OP_MANGLE_PURGECHAR
:
19619 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19623 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19624 SET_NAME (rule
, rule_buf
[rule_pos
]);
19625 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19628 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19629 SET_NAME (rule
, rule_buf
[rule_pos
]);
19630 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19633 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19634 SET_NAME (rule
, rule_buf
[rule_pos
]);
19637 case RULE_OP_MANGLE_SWITCH_FIRST
:
19638 SET_NAME (rule
, rule_buf
[rule_pos
]);
19641 case RULE_OP_MANGLE_SWITCH_LAST
:
19642 SET_NAME (rule
, rule_buf
[rule_pos
]);
19645 case RULE_OP_MANGLE_SWITCH_AT
:
19646 SET_NAME (rule
, rule_buf
[rule_pos
]);
19647 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19648 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19651 case RULE_OP_MANGLE_CHR_SHIFTL
:
19652 SET_NAME (rule
, rule_buf
[rule_pos
]);
19653 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19656 case RULE_OP_MANGLE_CHR_SHIFTR
:
19657 SET_NAME (rule
, rule_buf
[rule_pos
]);
19658 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19661 case RULE_OP_MANGLE_CHR_INCR
:
19662 SET_NAME (rule
, rule_buf
[rule_pos
]);
19663 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19666 case RULE_OP_MANGLE_CHR_DECR
:
19667 SET_NAME (rule
, rule_buf
[rule_pos
]);
19668 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19671 case RULE_OP_MANGLE_REPLACE_NP1
:
19672 SET_NAME (rule
, rule_buf
[rule_pos
]);
19673 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19676 case RULE_OP_MANGLE_REPLACE_NM1
:
19677 SET_NAME (rule
, rule_buf
[rule_pos
]);
19678 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19681 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19682 SET_NAME (rule
, rule_buf
[rule_pos
]);
19683 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19686 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19687 SET_NAME (rule
, rule_buf
[rule_pos
]);
19688 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19691 case RULE_OP_MANGLE_TITLE
:
19692 SET_NAME (rule
, rule_buf
[rule_pos
]);
19701 if (rule_pos
< rule_len
) return (-1);
19706 int kernel_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], kernel_rule_t
*rule
)
19710 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19714 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19718 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19722 case RULE_OP_MANGLE_NOOP
:
19723 rule_buf
[rule_pos
] = rule_cmd
;
19726 case RULE_OP_MANGLE_LREST
:
19727 rule_buf
[rule_pos
] = rule_cmd
;
19730 case RULE_OP_MANGLE_UREST
:
19731 rule_buf
[rule_pos
] = rule_cmd
;
19734 case RULE_OP_MANGLE_LREST_UFIRST
:
19735 rule_buf
[rule_pos
] = rule_cmd
;
19738 case RULE_OP_MANGLE_UREST_LFIRST
:
19739 rule_buf
[rule_pos
] = rule_cmd
;
19742 case RULE_OP_MANGLE_TREST
:
19743 rule_buf
[rule_pos
] = rule_cmd
;
19746 case RULE_OP_MANGLE_TOGGLE_AT
:
19747 rule_buf
[rule_pos
] = rule_cmd
;
19748 GET_P0_CONV (rule
);
19751 case RULE_OP_MANGLE_REVERSE
:
19752 rule_buf
[rule_pos
] = rule_cmd
;
19755 case RULE_OP_MANGLE_DUPEWORD
:
19756 rule_buf
[rule_pos
] = rule_cmd
;
19759 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19760 rule_buf
[rule_pos
] = rule_cmd
;
19761 GET_P0_CONV (rule
);
19764 case RULE_OP_MANGLE_REFLECT
:
19765 rule_buf
[rule_pos
] = rule_cmd
;
19768 case RULE_OP_MANGLE_ROTATE_LEFT
:
19769 rule_buf
[rule_pos
] = rule_cmd
;
19772 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19773 rule_buf
[rule_pos
] = rule_cmd
;
19776 case RULE_OP_MANGLE_APPEND
:
19777 rule_buf
[rule_pos
] = rule_cmd
;
19781 case RULE_OP_MANGLE_PREPEND
:
19782 rule_buf
[rule_pos
] = rule_cmd
;
19786 case RULE_OP_MANGLE_DELETE_FIRST
:
19787 rule_buf
[rule_pos
] = rule_cmd
;
19790 case RULE_OP_MANGLE_DELETE_LAST
:
19791 rule_buf
[rule_pos
] = rule_cmd
;
19794 case RULE_OP_MANGLE_DELETE_AT
:
19795 rule_buf
[rule_pos
] = rule_cmd
;
19796 GET_P0_CONV (rule
);
19799 case RULE_OP_MANGLE_EXTRACT
:
19800 rule_buf
[rule_pos
] = rule_cmd
;
19801 GET_P0_CONV (rule
);
19802 GET_P1_CONV (rule
);
19805 case RULE_OP_MANGLE_OMIT
:
19806 rule_buf
[rule_pos
] = rule_cmd
;
19807 GET_P0_CONV (rule
);
19808 GET_P1_CONV (rule
);
19811 case RULE_OP_MANGLE_INSERT
:
19812 rule_buf
[rule_pos
] = rule_cmd
;
19813 GET_P0_CONV (rule
);
19817 case RULE_OP_MANGLE_OVERSTRIKE
:
19818 rule_buf
[rule_pos
] = rule_cmd
;
19819 GET_P0_CONV (rule
);
19823 case RULE_OP_MANGLE_TRUNCATE_AT
:
19824 rule_buf
[rule_pos
] = rule_cmd
;
19825 GET_P0_CONV (rule
);
19828 case RULE_OP_MANGLE_REPLACE
:
19829 rule_buf
[rule_pos
] = rule_cmd
;
19834 case RULE_OP_MANGLE_PURGECHAR
:
19838 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19842 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19843 rule_buf
[rule_pos
] = rule_cmd
;
19844 GET_P0_CONV (rule
);
19847 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19848 rule_buf
[rule_pos
] = rule_cmd
;
19849 GET_P0_CONV (rule
);
19852 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19853 rule_buf
[rule_pos
] = rule_cmd
;
19856 case RULE_OP_MANGLE_SWITCH_FIRST
:
19857 rule_buf
[rule_pos
] = rule_cmd
;
19860 case RULE_OP_MANGLE_SWITCH_LAST
:
19861 rule_buf
[rule_pos
] = rule_cmd
;
19864 case RULE_OP_MANGLE_SWITCH_AT
:
19865 rule_buf
[rule_pos
] = rule_cmd
;
19866 GET_P0_CONV (rule
);
19867 GET_P1_CONV (rule
);
19870 case RULE_OP_MANGLE_CHR_SHIFTL
:
19871 rule_buf
[rule_pos
] = rule_cmd
;
19872 GET_P0_CONV (rule
);
19875 case RULE_OP_MANGLE_CHR_SHIFTR
:
19876 rule_buf
[rule_pos
] = rule_cmd
;
19877 GET_P0_CONV (rule
);
19880 case RULE_OP_MANGLE_CHR_INCR
:
19881 rule_buf
[rule_pos
] = rule_cmd
;
19882 GET_P0_CONV (rule
);
19885 case RULE_OP_MANGLE_CHR_DECR
:
19886 rule_buf
[rule_pos
] = rule_cmd
;
19887 GET_P0_CONV (rule
);
19890 case RULE_OP_MANGLE_REPLACE_NP1
:
19891 rule_buf
[rule_pos
] = rule_cmd
;
19892 GET_P0_CONV (rule
);
19895 case RULE_OP_MANGLE_REPLACE_NM1
:
19896 rule_buf
[rule_pos
] = rule_cmd
;
19897 GET_P0_CONV (rule
);
19900 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19901 rule_buf
[rule_pos
] = rule_cmd
;
19902 GET_P0_CONV (rule
);
19905 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19906 rule_buf
[rule_pos
] = rule_cmd
;
19907 GET_P0_CONV (rule
);
19910 case RULE_OP_MANGLE_TITLE
:
19911 rule_buf
[rule_pos
] = rule_cmd
;
19915 return rule_pos
- 1;
19933 * CPU rules : this is from hashcat sources, cpu based rules
19936 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19937 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19939 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19940 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19941 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19943 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19944 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19945 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19947 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19951 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19956 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19960 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19965 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19969 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19974 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19979 for (l
= 0; l
< arr_len
; l
++)
19981 r
= arr_len
- 1 - l
;
19985 MANGLE_SWITCH (arr
, l
, r
);
19991 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19993 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19995 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19997 return (arr_len
* 2);
20000 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
20002 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20004 int orig_len
= arr_len
;
20008 for (i
= 0; i
< times
; i
++)
20010 memcpy (&arr
[arr_len
], arr
, orig_len
);
20012 arr_len
+= orig_len
;
20018 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
20020 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20022 mangle_double (arr
, arr_len
);
20024 mangle_reverse (arr
+ arr_len
, arr_len
);
20026 return (arr_len
* 2);
20029 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
20034 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
20036 MANGLE_SWITCH (arr
, l
, r
);
20042 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
20047 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
20049 MANGLE_SWITCH (arr
, l
, r
);
20055 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20057 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20061 return (arr_len
+ 1);
20064 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20066 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20070 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20072 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20077 return (arr_len
+ 1);
20080 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20082 if (upos
>= arr_len
) return (arr_len
);
20086 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
20088 arr
[arr_pos
] = arr
[arr_pos
+ 1];
20091 return (arr_len
- 1);
20094 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20096 if (upos
>= arr_len
) return (arr_len
);
20098 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
20102 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
20104 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
20110 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20112 if (upos
>= arr_len
) return (arr_len
);
20114 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
20118 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
20120 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
20123 return (arr_len
- ulen
);
20126 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20128 if (upos
>= arr_len
) return (arr_len
);
20130 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20134 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
20136 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20141 return (arr_len
+ 1);
20144 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
)
20146 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20148 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
20150 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
20152 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
20154 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
20156 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
20158 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
20160 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
20162 return (arr_len
+ arr2_cpy
);
20165 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20167 if (upos
>= arr_len
) return (arr_len
);
20174 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20176 if (upos
>= arr_len
) return (arr_len
);
20178 memset (arr
+ upos
, 0, arr_len
- upos
);
20183 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
20187 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20189 if (arr
[arr_pos
] != oldc
) continue;
20191 arr
[arr_pos
] = newc
;
20197 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20203 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20205 if (arr
[arr_pos
] == c
) continue;
20207 arr
[ret_len
] = arr
[arr_pos
];
20215 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20217 if (ulen
> arr_len
) return (arr_len
);
20219 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20221 char cs
[100] = { 0 };
20223 memcpy (cs
, arr
, ulen
);
20227 for (i
= 0; i
< ulen
; i
++)
20231 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20237 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20239 if (ulen
> arr_len
) return (arr_len
);
20241 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20243 int upos
= arr_len
- ulen
;
20247 for (i
= 0; i
< ulen
; i
++)
20249 char c
= arr
[upos
+ i
];
20251 arr_len
= mangle_append (arr
, arr_len
, c
);
20257 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20259 if ( arr_len
== 0) return (arr_len
);
20260 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20262 char c
= arr
[upos
];
20266 for (i
= 0; i
< ulen
; i
++)
20268 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20274 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20276 if ( arr_len
== 0) return (arr_len
);
20277 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20281 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20283 int new_pos
= arr_pos
* 2;
20285 arr
[new_pos
] = arr
[arr_pos
];
20287 arr
[new_pos
+ 1] = arr
[arr_pos
];
20290 return (arr_len
* 2);
20293 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20295 if (upos
>= arr_len
) return (arr_len
);
20296 if (upos2
>= arr_len
) return (arr_len
);
20298 MANGLE_SWITCH (arr
, upos
, upos2
);
20303 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20305 MANGLE_SWITCH (arr
, upos
, upos2
);
20310 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20312 if (upos
>= arr_len
) return (arr_len
);
20319 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20321 if (upos
>= arr_len
) return (arr_len
);
20328 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20330 if (upos
>= arr_len
) return (arr_len
);
20337 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20339 if (upos
>= arr_len
) return (arr_len
);
20346 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20348 int upper_next
= 1;
20352 for (pos
= 0; pos
< arr_len
; pos
++)
20354 if (arr
[pos
] == ' ')
20365 MANGLE_UPPER_AT (arr
, pos
);
20369 MANGLE_LOWER_AT (arr
, pos
);
20376 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20378 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20384 for (j
= 0; j
< rp_gen_num
; j
++)
20391 switch ((char) get_random_num (0, 9))
20394 r
= get_random_num (0, sizeof (grp_op_nop
));
20395 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20399 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20400 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20401 p1
= get_random_num (0, sizeof (grp_pos
));
20402 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20406 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20407 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20408 p1
= get_random_num (1, 6);
20409 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20413 r
= get_random_num (0, sizeof (grp_op_chr
));
20414 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20415 p1
= get_random_num (0x20, 0x7e);
20416 rule_buf
[rule_pos
++] = (char) p1
;
20420 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20421 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20422 p1
= get_random_num (0x20, 0x7e);
20423 rule_buf
[rule_pos
++] = (char) p1
;
20424 p2
= get_random_num (0x20, 0x7e);
20426 p2
= get_random_num (0x20, 0x7e);
20427 rule_buf
[rule_pos
++] = (char) p2
;
20431 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20432 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20433 p1
= get_random_num (0, sizeof (grp_pos
));
20434 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20435 p2
= get_random_num (0x20, 0x7e);
20436 rule_buf
[rule_pos
++] = (char) p2
;
20440 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20441 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20442 p1
= get_random_num (0, sizeof (grp_pos
));
20443 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20444 p2
= get_random_num (0, sizeof (grp_pos
));
20446 p2
= get_random_num (0, sizeof (grp_pos
));
20447 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20451 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20452 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
20453 p1
= get_random_num (0, sizeof (grp_pos
));
20454 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20455 p2
= get_random_num (1, sizeof (grp_pos
));
20457 p2
= get_random_num (1, sizeof (grp_pos
));
20458 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20462 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
20463 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
20464 p1
= get_random_num (0, sizeof (grp_pos
));
20465 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20466 p2
= get_random_num (1, sizeof (grp_pos
));
20467 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20468 p3
= get_random_num (0, sizeof (grp_pos
));
20469 rule_buf
[rule_pos
++] = grp_pos
[p3
];
20477 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
20479 char mem
[BLOCK_SIZE
] = { 0 };
20481 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
20483 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
20485 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20487 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
20489 int out_len
= in_len
;
20490 int mem_len
= in_len
;
20492 memcpy (out
, in
, out_len
);
20496 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
20501 switch (rule
[rule_pos
])
20506 case RULE_OP_MANGLE_NOOP
:
20509 case RULE_OP_MANGLE_LREST
:
20510 out_len
= mangle_lrest (out
, out_len
);
20513 case RULE_OP_MANGLE_UREST
:
20514 out_len
= mangle_urest (out
, out_len
);
20517 case RULE_OP_MANGLE_LREST_UFIRST
:
20518 out_len
= mangle_lrest (out
, out_len
);
20519 if (out_len
) MANGLE_UPPER_AT (out
, 0);
20522 case RULE_OP_MANGLE_UREST_LFIRST
:
20523 out_len
= mangle_urest (out
, out_len
);
20524 if (out_len
) MANGLE_LOWER_AT (out
, 0);
20527 case RULE_OP_MANGLE_TREST
:
20528 out_len
= mangle_trest (out
, out_len
);
20531 case RULE_OP_MANGLE_TOGGLE_AT
:
20532 NEXT_RULEPOS (rule_pos
);
20533 NEXT_RPTOI (rule
, rule_pos
, upos
);
20534 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
20537 case RULE_OP_MANGLE_REVERSE
:
20538 out_len
= mangle_reverse (out
, out_len
);
20541 case RULE_OP_MANGLE_DUPEWORD
:
20542 out_len
= mangle_double (out
, out_len
);
20545 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20546 NEXT_RULEPOS (rule_pos
);
20547 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20548 out_len
= mangle_double_times (out
, out_len
, ulen
);
20551 case RULE_OP_MANGLE_REFLECT
:
20552 out_len
= mangle_reflect (out
, out_len
);
20555 case RULE_OP_MANGLE_ROTATE_LEFT
:
20556 mangle_rotate_left (out
, out_len
);
20559 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20560 mangle_rotate_right (out
, out_len
);
20563 case RULE_OP_MANGLE_APPEND
:
20564 NEXT_RULEPOS (rule_pos
);
20565 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
20568 case RULE_OP_MANGLE_PREPEND
:
20569 NEXT_RULEPOS (rule_pos
);
20570 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
20573 case RULE_OP_MANGLE_DELETE_FIRST
:
20574 out_len
= mangle_delete_at (out
, out_len
, 0);
20577 case RULE_OP_MANGLE_DELETE_LAST
:
20578 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
20581 case RULE_OP_MANGLE_DELETE_AT
:
20582 NEXT_RULEPOS (rule_pos
);
20583 NEXT_RPTOI (rule
, rule_pos
, upos
);
20584 out_len
= mangle_delete_at (out
, out_len
, upos
);
20587 case RULE_OP_MANGLE_EXTRACT
:
20588 NEXT_RULEPOS (rule_pos
);
20589 NEXT_RPTOI (rule
, rule_pos
, upos
);
20590 NEXT_RULEPOS (rule_pos
);
20591 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20592 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
20595 case RULE_OP_MANGLE_OMIT
:
20596 NEXT_RULEPOS (rule_pos
);
20597 NEXT_RPTOI (rule
, rule_pos
, upos
);
20598 NEXT_RULEPOS (rule_pos
);
20599 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20600 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
20603 case RULE_OP_MANGLE_INSERT
:
20604 NEXT_RULEPOS (rule_pos
);
20605 NEXT_RPTOI (rule
, rule_pos
, upos
);
20606 NEXT_RULEPOS (rule_pos
);
20607 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
20610 case RULE_OP_MANGLE_OVERSTRIKE
:
20611 NEXT_RULEPOS (rule_pos
);
20612 NEXT_RPTOI (rule
, rule_pos
, upos
);
20613 NEXT_RULEPOS (rule_pos
);
20614 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20617 case RULE_OP_MANGLE_TRUNCATE_AT
:
20618 NEXT_RULEPOS (rule_pos
);
20619 NEXT_RPTOI (rule
, rule_pos
, upos
);
20620 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20623 case RULE_OP_MANGLE_REPLACE
:
20624 NEXT_RULEPOS (rule_pos
);
20625 NEXT_RULEPOS (rule_pos
);
20626 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20629 case RULE_OP_MANGLE_PURGECHAR
:
20630 NEXT_RULEPOS (rule_pos
);
20631 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20634 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20638 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20639 NEXT_RULEPOS (rule_pos
);
20640 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20641 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20644 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20645 NEXT_RULEPOS (rule_pos
);
20646 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20647 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20650 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20651 out_len
= mangle_dupechar (out
, out_len
);
20654 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20655 NEXT_RULEPOS (rule_pos
);
20656 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20657 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20660 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20661 NEXT_RULEPOS (rule_pos
);
20662 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20663 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20666 case RULE_OP_MANGLE_SWITCH_FIRST
:
20667 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20670 case RULE_OP_MANGLE_SWITCH_LAST
:
20671 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20674 case RULE_OP_MANGLE_SWITCH_AT
:
20675 NEXT_RULEPOS (rule_pos
);
20676 NEXT_RPTOI (rule
, rule_pos
, upos
);
20677 NEXT_RULEPOS (rule_pos
);
20678 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20679 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20682 case RULE_OP_MANGLE_CHR_SHIFTL
:
20683 NEXT_RULEPOS (rule_pos
);
20684 NEXT_RPTOI (rule
, rule_pos
, upos
);
20685 mangle_chr_shiftl (out
, out_len
, upos
);
20688 case RULE_OP_MANGLE_CHR_SHIFTR
:
20689 NEXT_RULEPOS (rule_pos
);
20690 NEXT_RPTOI (rule
, rule_pos
, upos
);
20691 mangle_chr_shiftr (out
, out_len
, upos
);
20694 case RULE_OP_MANGLE_CHR_INCR
:
20695 NEXT_RULEPOS (rule_pos
);
20696 NEXT_RPTOI (rule
, rule_pos
, upos
);
20697 mangle_chr_incr (out
, out_len
, upos
);
20700 case RULE_OP_MANGLE_CHR_DECR
:
20701 NEXT_RULEPOS (rule_pos
);
20702 NEXT_RPTOI (rule
, rule_pos
, upos
);
20703 mangle_chr_decr (out
, out_len
, upos
);
20706 case RULE_OP_MANGLE_REPLACE_NP1
:
20707 NEXT_RULEPOS (rule_pos
);
20708 NEXT_RPTOI (rule
, rule_pos
, upos
);
20709 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20712 case RULE_OP_MANGLE_REPLACE_NM1
:
20713 NEXT_RULEPOS (rule_pos
);
20714 NEXT_RPTOI (rule
, rule_pos
, upos
);
20715 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20718 case RULE_OP_MANGLE_TITLE
:
20719 out_len
= mangle_title (out
, out_len
);
20722 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20723 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20724 NEXT_RULEPOS (rule_pos
);
20725 NEXT_RPTOI (rule
, rule_pos
, upos
);
20726 NEXT_RULEPOS (rule_pos
);
20727 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20728 NEXT_RULEPOS (rule_pos
);
20729 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20730 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20733 case RULE_OP_MANGLE_APPEND_MEMORY
:
20734 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20735 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20736 memcpy (out
+ out_len
, mem
, mem_len
);
20737 out_len
+= mem_len
;
20740 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20741 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20742 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20743 memcpy (mem
+ mem_len
, out
, out_len
);
20744 out_len
+= mem_len
;
20745 memcpy (out
, mem
, out_len
);
20748 case RULE_OP_MEMORIZE_WORD
:
20749 memcpy (mem
, out
, out_len
);
20753 case RULE_OP_REJECT_LESS
:
20754 NEXT_RULEPOS (rule_pos
);
20755 NEXT_RPTOI (rule
, rule_pos
, upos
);
20756 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20759 case RULE_OP_REJECT_GREATER
:
20760 NEXT_RULEPOS (rule_pos
);
20761 NEXT_RPTOI (rule
, rule_pos
, upos
);
20762 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20765 case RULE_OP_REJECT_CONTAIN
:
20766 NEXT_RULEPOS (rule_pos
);
20767 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20770 case RULE_OP_REJECT_NOT_CONTAIN
:
20771 NEXT_RULEPOS (rule_pos
);
20772 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20775 case RULE_OP_REJECT_EQUAL_FIRST
:
20776 NEXT_RULEPOS (rule_pos
);
20777 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20780 case RULE_OP_REJECT_EQUAL_LAST
:
20781 NEXT_RULEPOS (rule_pos
);
20782 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20785 case RULE_OP_REJECT_EQUAL_AT
:
20786 NEXT_RULEPOS (rule_pos
);
20787 NEXT_RPTOI (rule
, rule_pos
, upos
);
20788 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20789 NEXT_RULEPOS (rule_pos
);
20790 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20793 case RULE_OP_REJECT_CONTAINS
:
20794 NEXT_RULEPOS (rule_pos
);
20795 NEXT_RPTOI (rule
, rule_pos
, upos
);
20796 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20797 NEXT_RULEPOS (rule_pos
);
20798 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20799 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20802 case RULE_OP_REJECT_MEMORY
:
20803 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20807 return (RULE_RC_SYNTAX_ERROR
);
20812 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);