2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
19 #define GET_ACCEL(x) KERNEL_ACCEL_ ## x
20 #define GET_LOOPS(x) KERNEL_LOOPS_ ## x
22 #define GET_LOOPS_OSX(x) KERNEL_LOOPS_OSX_ ## x
23 #define GET_ACCEL_OSX(x) KERNEL_ACCEL_OSX_ ## x
29 u32
rotl32 (const u32 a
, const u32 n
)
31 return ((a
<< n
) | (a
>> (32 - n
)));
34 u32
rotr32 (const u32 a
, const u32 n
)
36 return ((a
>> n
) | (a
<< (32 - n
)));
39 u64
rotl64 (const u64 a
, const u64 n
)
41 return ((a
<< n
) | (a
>> (64 - n
)));
44 u64
rotr64 (const u64 a
, const u64 n
)
46 return ((a
>> n
) | (a
<< (64 - n
)));
49 u32
byte_swap_32 (const u32 n
)
51 return (n
& 0xff000000) >> 24
52 | (n
& 0x00ff0000) >> 8
53 | (n
& 0x0000ff00) << 8
54 | (n
& 0x000000ff) << 24;
57 u64
byte_swap_64 (const u64 n
)
59 return (n
& 0xff00000000000000ULL
) >> 56
60 | (n
& 0x00ff000000000000ULL
) >> 40
61 | (n
& 0x0000ff0000000000ULL
) >> 24
62 | (n
& 0x000000ff00000000ULL
) >> 8
63 | (n
& 0x00000000ff000000ULL
) << 8
64 | (n
& 0x0000000000ff0000ULL
) << 24
65 | (n
& 0x000000000000ff00ULL
) << 40
66 | (n
& 0x00000000000000ffULL
) << 56;
70 * ciphers for use on cpu
77 * hashes for use on cpu
81 #include "cpu-sha256.c"
89 void log_final (FILE *fp
, const char *fmt
, va_list ap
)
95 for (int i
= 0; i
< last_len
; i
++)
103 char s
[4096] = { 0 };
105 int max_len
= (int) sizeof (s
);
107 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
109 if (len
> max_len
) len
= max_len
;
111 fwrite (s
, len
, 1, fp
);
118 void log_out_nn (FILE *fp
, const char *fmt
, ...)
120 if (SUPPRESS_OUTPUT
) return;
126 log_final (fp
, fmt
, ap
);
131 void log_info_nn (const char *fmt
, ...)
133 if (SUPPRESS_OUTPUT
) return;
139 log_final (stdout
, fmt
, ap
);
144 void log_error_nn (const char *fmt
, ...)
146 if (SUPPRESS_OUTPUT
) return;
152 log_final (stderr
, fmt
, ap
);
157 void log_out (FILE *fp
, const char *fmt
, ...)
159 if (SUPPRESS_OUTPUT
) return;
165 log_final (fp
, fmt
, ap
);
174 void log_info (const char *fmt
, ...)
176 if (SUPPRESS_OUTPUT
) return;
182 log_final (stdout
, fmt
, ap
);
186 fputc ('\n', stdout
);
191 void log_error (const char *fmt
, ...)
193 if (SUPPRESS_OUTPUT
) return;
195 fputc ('\n', stderr
);
196 fputc ('\n', stderr
);
202 log_final (stderr
, fmt
, ap
);
206 fputc ('\n', stderr
);
207 fputc ('\n', stderr
);
216 u8
int_to_base32 (const u8 c
)
218 static const u8 tbl
[0x20] =
220 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
221 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
227 u8
base32_to_int (const u8 c
)
229 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
230 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
235 u8
int_to_itoa32 (const u8 c
)
237 static const u8 tbl
[0x20] =
239 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
240 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
246 u8
itoa32_to_int (const u8 c
)
248 if ((c
>= '0') && (c
<= '9')) return c
- '0';
249 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
254 u8
int_to_itoa64 (const u8 c
)
256 static const u8 tbl
[0x40] =
258 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
259 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
260 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
261 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
267 u8
itoa64_to_int (const u8 c
)
269 static const u8 tbl
[0x100] =
271 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
272 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
273 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
274 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
275 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
276 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
277 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
278 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
279 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
280 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
281 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
282 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
283 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
284 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
285 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
286 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
292 u8
int_to_base64 (const u8 c
)
294 static const u8 tbl
[0x40] =
296 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
297 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
298 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
299 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
305 u8
base64_to_int (const u8 c
)
307 static const u8 tbl
[0x100] =
309 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
310 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
311 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
312 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
313 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
314 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
315 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
316 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
317 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
318 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
319 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
320 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
321 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
322 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
323 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
324 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
330 u8
int_to_bf64 (const u8 c
)
332 static const u8 tbl
[0x40] =
334 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
335 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
336 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
337 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
343 u8
bf64_to_int (const u8 c
)
345 static const u8 tbl
[0x100] =
347 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
348 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
349 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
350 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
351 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
352 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
353 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
354 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
355 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
356 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
357 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
358 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
359 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
360 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
361 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
362 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
368 u8
int_to_lotus64 (const u8 c
)
370 if (c
< 10) return '0' + c
;
371 else if (c
< 36) return 'A' + c
- 10;
372 else if (c
< 62) return 'a' + c
- 36;
373 else if (c
== 62) return '+';
374 else if (c
== 63) return '/';
379 u8
lotus64_to_int (const u8 c
)
381 if ((c
>= '0') && (c
<= '9')) return c
- '0';
382 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
383 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
384 else if (c
== '+') return 62;
385 else if (c
== '/') return 63;
391 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
393 const u8
*in_ptr
= in_buf
;
395 u8
*out_ptr
= out_buf
;
397 for (int i
= 0; i
< in_len
; i
+= 8)
399 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
400 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
401 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
402 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
403 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
404 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
405 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
406 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
408 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
409 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
410 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
411 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
412 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
418 for (int i
= 0; i
< in_len
; i
++)
420 if (in_buf
[i
] != '=') continue;
425 int out_len
= (in_len
* 5) / 8;
430 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
432 const u8
*in_ptr
= in_buf
;
434 u8
*out_ptr
= out_buf
;
436 for (int i
= 0; i
< in_len
; i
+= 5)
438 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
439 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
440 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
441 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
442 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
443 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
444 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
445 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
447 out_ptr
[0] = out_val0
& 0x7f;
448 out_ptr
[1] = out_val1
& 0x7f;
449 out_ptr
[2] = out_val2
& 0x7f;
450 out_ptr
[3] = out_val3
& 0x7f;
451 out_ptr
[4] = out_val4
& 0x7f;
452 out_ptr
[5] = out_val5
& 0x7f;
453 out_ptr
[6] = out_val6
& 0x7f;
454 out_ptr
[7] = out_val7
& 0x7f;
460 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
464 out_buf
[out_len
] = '=';
472 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
474 const u8
*in_ptr
= in_buf
;
476 u8
*out_ptr
= out_buf
;
478 for (int i
= 0; i
< in_len
; i
+= 4)
480 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
481 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
482 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
483 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
485 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
486 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
487 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
493 for (int i
= 0; i
< in_len
; i
++)
495 if (in_buf
[i
] != '=') continue;
500 int out_len
= (in_len
* 6) / 8;
505 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
507 const u8
*in_ptr
= in_buf
;
509 u8
*out_ptr
= out_buf
;
511 for (int i
= 0; i
< in_len
; i
+= 3)
513 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
514 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
515 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
516 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
518 out_ptr
[0] = out_val0
& 0x7f;
519 out_ptr
[1] = out_val1
& 0x7f;
520 out_ptr
[2] = out_val2
& 0x7f;
521 out_ptr
[3] = out_val3
& 0x7f;
527 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
531 out_buf
[out_len
] = '=';
539 int is_valid_hex_char (const u8 c
)
541 if ((c
>= '0') && (c
<= '9')) return 1;
542 if ((c
>= 'A') && (c
<= 'F')) return 1;
543 if ((c
>= 'a') && (c
<= 'f')) return 1;
548 u8
hex_convert (const u8 c
)
550 return (c
& 15) + (c
>> 6) * 9;
553 u8
hex_to_u8 (const u8 hex
[2])
557 v
|= (hex_convert (hex
[1]) << 0);
558 v
|= (hex_convert (hex
[0]) << 4);
563 u32
hex_to_u32 (const u8 hex
[8])
567 v
|= ((u32
) hex_convert (hex
[7])) << 0;
568 v
|= ((u32
) hex_convert (hex
[6])) << 4;
569 v
|= ((u32
) hex_convert (hex
[5])) << 8;
570 v
|= ((u32
) hex_convert (hex
[4])) << 12;
571 v
|= ((u32
) hex_convert (hex
[3])) << 16;
572 v
|= ((u32
) hex_convert (hex
[2])) << 20;
573 v
|= ((u32
) hex_convert (hex
[1])) << 24;
574 v
|= ((u32
) hex_convert (hex
[0])) << 28;
579 u64
hex_to_u64 (const u8 hex
[16])
583 v
|= ((u64
) hex_convert (hex
[15]) << 0);
584 v
|= ((u64
) hex_convert (hex
[14]) << 4);
585 v
|= ((u64
) hex_convert (hex
[13]) << 8);
586 v
|= ((u64
) hex_convert (hex
[12]) << 12);
587 v
|= ((u64
) hex_convert (hex
[11]) << 16);
588 v
|= ((u64
) hex_convert (hex
[10]) << 20);
589 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
590 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
591 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
592 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
593 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
594 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
595 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
596 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
597 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
598 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
603 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
605 hex
[0] = v
>> 28 & 15;
606 hex
[1] = v
>> 24 & 15;
607 hex
[2] = v
>> 20 & 15;
608 hex
[3] = v
>> 16 & 15;
609 hex
[4] = v
>> 12 & 15;
610 hex
[5] = v
>> 8 & 15;
611 hex
[6] = v
>> 4 & 15;
612 hex
[7] = v
>> 0 & 15;
616 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
617 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
618 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
619 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
620 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
621 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
622 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
623 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
630 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
634 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
643 for (int i
= 0; i
< 16; i
+= 4)
653 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
660 out
[i
+ 0] = _out
[0];
661 out
[i
+ 1] = _out
[1];
662 out
[i
+ 2] = _out
[2];
663 out
[i
+ 3] = _out
[3];
672 static void juniper_decrypt_hash (char *in
, char *out
)
676 u8 base64_buf
[100] = { 0 };
678 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
682 u32 juniper_iv
[4] = { 0 };
684 memcpy (juniper_iv
, base64_buf
, 12);
686 memcpy (out
, juniper_iv
, 12);
690 u32 juniper_key
[4] = { 0 };
692 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
693 juniper_key
[1] = byte_swap_32 (0x8df91059);
694 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
695 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
699 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
700 u32
*out_ptr
= (u32
*) (out
+ 12);
702 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
705 void phpass_decode (u8 digest
[16], u8 buf
[22])
709 l
= itoa64_to_int (buf
[ 0]) << 0;
710 l
|= itoa64_to_int (buf
[ 1]) << 6;
711 l
|= itoa64_to_int (buf
[ 2]) << 12;
712 l
|= itoa64_to_int (buf
[ 3]) << 18;
714 digest
[ 0] = (l
>> 0) & 0xff;
715 digest
[ 1] = (l
>> 8) & 0xff;
716 digest
[ 2] = (l
>> 16) & 0xff;
718 l
= itoa64_to_int (buf
[ 4]) << 0;
719 l
|= itoa64_to_int (buf
[ 5]) << 6;
720 l
|= itoa64_to_int (buf
[ 6]) << 12;
721 l
|= itoa64_to_int (buf
[ 7]) << 18;
723 digest
[ 3] = (l
>> 0) & 0xff;
724 digest
[ 4] = (l
>> 8) & 0xff;
725 digest
[ 5] = (l
>> 16) & 0xff;
727 l
= itoa64_to_int (buf
[ 8]) << 0;
728 l
|= itoa64_to_int (buf
[ 9]) << 6;
729 l
|= itoa64_to_int (buf
[10]) << 12;
730 l
|= itoa64_to_int (buf
[11]) << 18;
732 digest
[ 6] = (l
>> 0) & 0xff;
733 digest
[ 7] = (l
>> 8) & 0xff;
734 digest
[ 8] = (l
>> 16) & 0xff;
736 l
= itoa64_to_int (buf
[12]) << 0;
737 l
|= itoa64_to_int (buf
[13]) << 6;
738 l
|= itoa64_to_int (buf
[14]) << 12;
739 l
|= itoa64_to_int (buf
[15]) << 18;
741 digest
[ 9] = (l
>> 0) & 0xff;
742 digest
[10] = (l
>> 8) & 0xff;
743 digest
[11] = (l
>> 16) & 0xff;
745 l
= itoa64_to_int (buf
[16]) << 0;
746 l
|= itoa64_to_int (buf
[17]) << 6;
747 l
|= itoa64_to_int (buf
[18]) << 12;
748 l
|= itoa64_to_int (buf
[19]) << 18;
750 digest
[12] = (l
>> 0) & 0xff;
751 digest
[13] = (l
>> 8) & 0xff;
752 digest
[14] = (l
>> 16) & 0xff;
754 l
= itoa64_to_int (buf
[20]) << 0;
755 l
|= itoa64_to_int (buf
[21]) << 6;
757 digest
[15] = (l
>> 0) & 0xff;
760 void phpass_encode (u8 digest
[16], u8 buf
[22])
764 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
766 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
767 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
768 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
769 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
771 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
773 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
774 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
775 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
776 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
778 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
780 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
781 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
782 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
783 buf
[11] = int_to_itoa64 (l
& 0x3f);
785 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
787 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
788 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
789 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
790 buf
[15] = int_to_itoa64 (l
& 0x3f);
792 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
794 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
795 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
796 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
797 buf
[19] = int_to_itoa64 (l
& 0x3f);
799 l
= (digest
[15] << 0);
801 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
802 buf
[21] = int_to_itoa64 (l
& 0x3f);
805 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
809 l
= itoa64_to_int (buf
[ 0]) << 0;
810 l
|= itoa64_to_int (buf
[ 1]) << 6;
811 l
|= itoa64_to_int (buf
[ 2]) << 12;
812 l
|= itoa64_to_int (buf
[ 3]) << 18;
814 digest
[ 0] = (l
>> 16) & 0xff;
815 digest
[ 6] = (l
>> 8) & 0xff;
816 digest
[12] = (l
>> 0) & 0xff;
818 l
= itoa64_to_int (buf
[ 4]) << 0;
819 l
|= itoa64_to_int (buf
[ 5]) << 6;
820 l
|= itoa64_to_int (buf
[ 6]) << 12;
821 l
|= itoa64_to_int (buf
[ 7]) << 18;
823 digest
[ 1] = (l
>> 16) & 0xff;
824 digest
[ 7] = (l
>> 8) & 0xff;
825 digest
[13] = (l
>> 0) & 0xff;
827 l
= itoa64_to_int (buf
[ 8]) << 0;
828 l
|= itoa64_to_int (buf
[ 9]) << 6;
829 l
|= itoa64_to_int (buf
[10]) << 12;
830 l
|= itoa64_to_int (buf
[11]) << 18;
832 digest
[ 2] = (l
>> 16) & 0xff;
833 digest
[ 8] = (l
>> 8) & 0xff;
834 digest
[14] = (l
>> 0) & 0xff;
836 l
= itoa64_to_int (buf
[12]) << 0;
837 l
|= itoa64_to_int (buf
[13]) << 6;
838 l
|= itoa64_to_int (buf
[14]) << 12;
839 l
|= itoa64_to_int (buf
[15]) << 18;
841 digest
[ 3] = (l
>> 16) & 0xff;
842 digest
[ 9] = (l
>> 8) & 0xff;
843 digest
[15] = (l
>> 0) & 0xff;
845 l
= itoa64_to_int (buf
[16]) << 0;
846 l
|= itoa64_to_int (buf
[17]) << 6;
847 l
|= itoa64_to_int (buf
[18]) << 12;
848 l
|= itoa64_to_int (buf
[19]) << 18;
850 digest
[ 4] = (l
>> 16) & 0xff;
851 digest
[10] = (l
>> 8) & 0xff;
852 digest
[ 5] = (l
>> 0) & 0xff;
854 l
= itoa64_to_int (buf
[20]) << 0;
855 l
|= itoa64_to_int (buf
[21]) << 6;
857 digest
[11] = (l
>> 0) & 0xff;
860 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
864 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
866 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
867 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
868 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
869 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
871 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
873 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
874 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
875 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
876 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
880 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
881 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
882 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
883 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
887 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
888 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
889 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
890 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
894 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
895 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
896 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
897 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
899 l
= (digest
[11] << 0);
901 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
902 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
905 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
909 l
= itoa64_to_int (buf
[ 0]) << 0;
910 l
|= itoa64_to_int (buf
[ 1]) << 6;
911 l
|= itoa64_to_int (buf
[ 2]) << 12;
912 l
|= itoa64_to_int (buf
[ 3]) << 18;
914 digest
[ 0] = (l
>> 16) & 0xff;
915 digest
[21] = (l
>> 8) & 0xff;
916 digest
[42] = (l
>> 0) & 0xff;
918 l
= itoa64_to_int (buf
[ 4]) << 0;
919 l
|= itoa64_to_int (buf
[ 5]) << 6;
920 l
|= itoa64_to_int (buf
[ 6]) << 12;
921 l
|= itoa64_to_int (buf
[ 7]) << 18;
923 digest
[22] = (l
>> 16) & 0xff;
924 digest
[43] = (l
>> 8) & 0xff;
925 digest
[ 1] = (l
>> 0) & 0xff;
927 l
= itoa64_to_int (buf
[ 8]) << 0;
928 l
|= itoa64_to_int (buf
[ 9]) << 6;
929 l
|= itoa64_to_int (buf
[10]) << 12;
930 l
|= itoa64_to_int (buf
[11]) << 18;
932 digest
[44] = (l
>> 16) & 0xff;
933 digest
[ 2] = (l
>> 8) & 0xff;
934 digest
[23] = (l
>> 0) & 0xff;
936 l
= itoa64_to_int (buf
[12]) << 0;
937 l
|= itoa64_to_int (buf
[13]) << 6;
938 l
|= itoa64_to_int (buf
[14]) << 12;
939 l
|= itoa64_to_int (buf
[15]) << 18;
941 digest
[ 3] = (l
>> 16) & 0xff;
942 digest
[24] = (l
>> 8) & 0xff;
943 digest
[45] = (l
>> 0) & 0xff;
945 l
= itoa64_to_int (buf
[16]) << 0;
946 l
|= itoa64_to_int (buf
[17]) << 6;
947 l
|= itoa64_to_int (buf
[18]) << 12;
948 l
|= itoa64_to_int (buf
[19]) << 18;
950 digest
[25] = (l
>> 16) & 0xff;
951 digest
[46] = (l
>> 8) & 0xff;
952 digest
[ 4] = (l
>> 0) & 0xff;
954 l
= itoa64_to_int (buf
[20]) << 0;
955 l
|= itoa64_to_int (buf
[21]) << 6;
956 l
|= itoa64_to_int (buf
[22]) << 12;
957 l
|= itoa64_to_int (buf
[23]) << 18;
959 digest
[47] = (l
>> 16) & 0xff;
960 digest
[ 5] = (l
>> 8) & 0xff;
961 digest
[26] = (l
>> 0) & 0xff;
963 l
= itoa64_to_int (buf
[24]) << 0;
964 l
|= itoa64_to_int (buf
[25]) << 6;
965 l
|= itoa64_to_int (buf
[26]) << 12;
966 l
|= itoa64_to_int (buf
[27]) << 18;
968 digest
[ 6] = (l
>> 16) & 0xff;
969 digest
[27] = (l
>> 8) & 0xff;
970 digest
[48] = (l
>> 0) & 0xff;
972 l
= itoa64_to_int (buf
[28]) << 0;
973 l
|= itoa64_to_int (buf
[29]) << 6;
974 l
|= itoa64_to_int (buf
[30]) << 12;
975 l
|= itoa64_to_int (buf
[31]) << 18;
977 digest
[28] = (l
>> 16) & 0xff;
978 digest
[49] = (l
>> 8) & 0xff;
979 digest
[ 7] = (l
>> 0) & 0xff;
981 l
= itoa64_to_int (buf
[32]) << 0;
982 l
|= itoa64_to_int (buf
[33]) << 6;
983 l
|= itoa64_to_int (buf
[34]) << 12;
984 l
|= itoa64_to_int (buf
[35]) << 18;
986 digest
[50] = (l
>> 16) & 0xff;
987 digest
[ 8] = (l
>> 8) & 0xff;
988 digest
[29] = (l
>> 0) & 0xff;
990 l
= itoa64_to_int (buf
[36]) << 0;
991 l
|= itoa64_to_int (buf
[37]) << 6;
992 l
|= itoa64_to_int (buf
[38]) << 12;
993 l
|= itoa64_to_int (buf
[39]) << 18;
995 digest
[ 9] = (l
>> 16) & 0xff;
996 digest
[30] = (l
>> 8) & 0xff;
997 digest
[51] = (l
>> 0) & 0xff;
999 l
= itoa64_to_int (buf
[40]) << 0;
1000 l
|= itoa64_to_int (buf
[41]) << 6;
1001 l
|= itoa64_to_int (buf
[42]) << 12;
1002 l
|= itoa64_to_int (buf
[43]) << 18;
1004 digest
[31] = (l
>> 16) & 0xff;
1005 digest
[52] = (l
>> 8) & 0xff;
1006 digest
[10] = (l
>> 0) & 0xff;
1008 l
= itoa64_to_int (buf
[44]) << 0;
1009 l
|= itoa64_to_int (buf
[45]) << 6;
1010 l
|= itoa64_to_int (buf
[46]) << 12;
1011 l
|= itoa64_to_int (buf
[47]) << 18;
1013 digest
[53] = (l
>> 16) & 0xff;
1014 digest
[11] = (l
>> 8) & 0xff;
1015 digest
[32] = (l
>> 0) & 0xff;
1017 l
= itoa64_to_int (buf
[48]) << 0;
1018 l
|= itoa64_to_int (buf
[49]) << 6;
1019 l
|= itoa64_to_int (buf
[50]) << 12;
1020 l
|= itoa64_to_int (buf
[51]) << 18;
1022 digest
[12] = (l
>> 16) & 0xff;
1023 digest
[33] = (l
>> 8) & 0xff;
1024 digest
[54] = (l
>> 0) & 0xff;
1026 l
= itoa64_to_int (buf
[52]) << 0;
1027 l
|= itoa64_to_int (buf
[53]) << 6;
1028 l
|= itoa64_to_int (buf
[54]) << 12;
1029 l
|= itoa64_to_int (buf
[55]) << 18;
1031 digest
[34] = (l
>> 16) & 0xff;
1032 digest
[55] = (l
>> 8) & 0xff;
1033 digest
[13] = (l
>> 0) & 0xff;
1035 l
= itoa64_to_int (buf
[56]) << 0;
1036 l
|= itoa64_to_int (buf
[57]) << 6;
1037 l
|= itoa64_to_int (buf
[58]) << 12;
1038 l
|= itoa64_to_int (buf
[59]) << 18;
1040 digest
[56] = (l
>> 16) & 0xff;
1041 digest
[14] = (l
>> 8) & 0xff;
1042 digest
[35] = (l
>> 0) & 0xff;
1044 l
= itoa64_to_int (buf
[60]) << 0;
1045 l
|= itoa64_to_int (buf
[61]) << 6;
1046 l
|= itoa64_to_int (buf
[62]) << 12;
1047 l
|= itoa64_to_int (buf
[63]) << 18;
1049 digest
[15] = (l
>> 16) & 0xff;
1050 digest
[36] = (l
>> 8) & 0xff;
1051 digest
[57] = (l
>> 0) & 0xff;
1053 l
= itoa64_to_int (buf
[64]) << 0;
1054 l
|= itoa64_to_int (buf
[65]) << 6;
1055 l
|= itoa64_to_int (buf
[66]) << 12;
1056 l
|= itoa64_to_int (buf
[67]) << 18;
1058 digest
[37] = (l
>> 16) & 0xff;
1059 digest
[58] = (l
>> 8) & 0xff;
1060 digest
[16] = (l
>> 0) & 0xff;
1062 l
= itoa64_to_int (buf
[68]) << 0;
1063 l
|= itoa64_to_int (buf
[69]) << 6;
1064 l
|= itoa64_to_int (buf
[70]) << 12;
1065 l
|= itoa64_to_int (buf
[71]) << 18;
1067 digest
[59] = (l
>> 16) & 0xff;
1068 digest
[17] = (l
>> 8) & 0xff;
1069 digest
[38] = (l
>> 0) & 0xff;
1071 l
= itoa64_to_int (buf
[72]) << 0;
1072 l
|= itoa64_to_int (buf
[73]) << 6;
1073 l
|= itoa64_to_int (buf
[74]) << 12;
1074 l
|= itoa64_to_int (buf
[75]) << 18;
1076 digest
[18] = (l
>> 16) & 0xff;
1077 digest
[39] = (l
>> 8) & 0xff;
1078 digest
[60] = (l
>> 0) & 0xff;
1080 l
= itoa64_to_int (buf
[76]) << 0;
1081 l
|= itoa64_to_int (buf
[77]) << 6;
1082 l
|= itoa64_to_int (buf
[78]) << 12;
1083 l
|= itoa64_to_int (buf
[79]) << 18;
1085 digest
[40] = (l
>> 16) & 0xff;
1086 digest
[61] = (l
>> 8) & 0xff;
1087 digest
[19] = (l
>> 0) & 0xff;
1089 l
= itoa64_to_int (buf
[80]) << 0;
1090 l
|= itoa64_to_int (buf
[81]) << 6;
1091 l
|= itoa64_to_int (buf
[82]) << 12;
1092 l
|= itoa64_to_int (buf
[83]) << 18;
1094 digest
[62] = (l
>> 16) & 0xff;
1095 digest
[20] = (l
>> 8) & 0xff;
1096 digest
[41] = (l
>> 0) & 0xff;
1098 l
= itoa64_to_int (buf
[84]) << 0;
1099 l
|= itoa64_to_int (buf
[85]) << 6;
1101 digest
[63] = (l
>> 0) & 0xff;
1104 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1108 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1110 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1111 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1112 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1113 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1115 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1117 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1118 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1119 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1120 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1124 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1125 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1126 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1127 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1131 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1132 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1133 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1134 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1138 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1139 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1140 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1141 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1145 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1146 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1147 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1148 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1152 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1153 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1154 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1155 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1159 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1160 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1161 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1162 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1166 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1167 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1168 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1169 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1173 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1174 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1175 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1176 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1180 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1181 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1182 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1183 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1187 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1188 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1189 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1190 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1194 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1195 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1196 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1197 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1201 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1202 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1203 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1204 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1208 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1209 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1210 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1211 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1215 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1216 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1217 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1218 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1222 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1223 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1224 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1225 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1229 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1230 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1231 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1232 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1236 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1237 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1238 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1239 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1243 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1244 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1245 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1246 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1250 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1251 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1252 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1253 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1255 l
= 0 | 0 | (digest
[63] << 0);
1257 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1258 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1261 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1265 l
= itoa64_to_int (buf
[ 0]) << 0;
1266 l
|= itoa64_to_int (buf
[ 1]) << 6;
1267 l
|= itoa64_to_int (buf
[ 2]) << 12;
1268 l
|= itoa64_to_int (buf
[ 3]) << 18;
1270 digest
[ 2] = (l
>> 0) & 0xff;
1271 digest
[ 1] = (l
>> 8) & 0xff;
1272 digest
[ 0] = (l
>> 16) & 0xff;
1274 l
= itoa64_to_int (buf
[ 4]) << 0;
1275 l
|= itoa64_to_int (buf
[ 5]) << 6;
1276 l
|= itoa64_to_int (buf
[ 6]) << 12;
1277 l
|= itoa64_to_int (buf
[ 7]) << 18;
1279 digest
[ 5] = (l
>> 0) & 0xff;
1280 digest
[ 4] = (l
>> 8) & 0xff;
1281 digest
[ 3] = (l
>> 16) & 0xff;
1283 l
= itoa64_to_int (buf
[ 8]) << 0;
1284 l
|= itoa64_to_int (buf
[ 9]) << 6;
1285 l
|= itoa64_to_int (buf
[10]) << 12;
1286 l
|= itoa64_to_int (buf
[11]) << 18;
1288 digest
[ 8] = (l
>> 0) & 0xff;
1289 digest
[ 7] = (l
>> 8) & 0xff;
1290 digest
[ 6] = (l
>> 16) & 0xff;
1292 l
= itoa64_to_int (buf
[12]) << 0;
1293 l
|= itoa64_to_int (buf
[13]) << 6;
1294 l
|= itoa64_to_int (buf
[14]) << 12;
1295 l
|= itoa64_to_int (buf
[15]) << 18;
1297 digest
[11] = (l
>> 0) & 0xff;
1298 digest
[10] = (l
>> 8) & 0xff;
1299 digest
[ 9] = (l
>> 16) & 0xff;
1301 l
= itoa64_to_int (buf
[16]) << 0;
1302 l
|= itoa64_to_int (buf
[17]) << 6;
1303 l
|= itoa64_to_int (buf
[18]) << 12;
1304 l
|= itoa64_to_int (buf
[19]) << 18;
1306 digest
[14] = (l
>> 0) & 0xff;
1307 digest
[13] = (l
>> 8) & 0xff;
1308 digest
[12] = (l
>> 16) & 0xff;
1310 l
= itoa64_to_int (buf
[20]) << 0;
1311 l
|= itoa64_to_int (buf
[21]) << 6;
1312 l
|= itoa64_to_int (buf
[22]) << 12;
1313 l
|= itoa64_to_int (buf
[23]) << 18;
1315 digest
[17] = (l
>> 0) & 0xff;
1316 digest
[16] = (l
>> 8) & 0xff;
1317 digest
[15] = (l
>> 16) & 0xff;
1319 l
= itoa64_to_int (buf
[24]) << 0;
1320 l
|= itoa64_to_int (buf
[25]) << 6;
1321 l
|= itoa64_to_int (buf
[26]) << 12;
1323 digest
[19] = (l
>> 8) & 0xff;
1324 digest
[18] = (l
>> 16) & 0xff;
1327 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1331 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1333 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1334 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1335 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1336 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1338 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1340 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1341 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1342 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1343 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1345 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1347 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1348 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1349 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1350 buf
[11] = int_to_itoa64 (l
& 0x3f);
1352 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1354 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1355 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1356 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1357 buf
[15] = int_to_itoa64 (l
& 0x3f);
1359 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1361 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1362 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1363 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1364 buf
[19] = int_to_itoa64 (l
& 0x3f);
1366 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1368 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1369 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1370 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1371 buf
[23] = int_to_itoa64 (l
& 0x3f);
1373 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1375 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1376 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1377 buf
[26] = int_to_itoa64 (l
& 0x3f);
1380 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1384 l
= itoa64_to_int (buf
[ 0]) << 0;
1385 l
|= itoa64_to_int (buf
[ 1]) << 6;
1386 l
|= itoa64_to_int (buf
[ 2]) << 12;
1387 l
|= itoa64_to_int (buf
[ 3]) << 18;
1389 digest
[ 2] = (l
>> 0) & 0xff;
1390 digest
[ 1] = (l
>> 8) & 0xff;
1391 digest
[ 0] = (l
>> 16) & 0xff;
1393 l
= itoa64_to_int (buf
[ 4]) << 0;
1394 l
|= itoa64_to_int (buf
[ 5]) << 6;
1395 l
|= itoa64_to_int (buf
[ 6]) << 12;
1396 l
|= itoa64_to_int (buf
[ 7]) << 18;
1398 digest
[ 5] = (l
>> 0) & 0xff;
1399 digest
[ 4] = (l
>> 8) & 0xff;
1400 digest
[ 3] = (l
>> 16) & 0xff;
1402 l
= itoa64_to_int (buf
[ 8]) << 0;
1403 l
|= itoa64_to_int (buf
[ 9]) << 6;
1404 l
|= itoa64_to_int (buf
[10]) << 12;
1405 l
|= itoa64_to_int (buf
[11]) << 18;
1407 digest
[ 8] = (l
>> 0) & 0xff;
1408 digest
[ 7] = (l
>> 8) & 0xff;
1409 digest
[ 6] = (l
>> 16) & 0xff;
1411 l
= itoa64_to_int (buf
[12]) << 0;
1412 l
|= itoa64_to_int (buf
[13]) << 6;
1413 l
|= itoa64_to_int (buf
[14]) << 12;
1414 l
|= itoa64_to_int (buf
[15]) << 18;
1416 digest
[11] = (l
>> 0) & 0xff;
1417 digest
[10] = (l
>> 8) & 0xff;
1418 digest
[ 9] = (l
>> 16) & 0xff;
1420 l
= itoa64_to_int (buf
[16]) << 0;
1421 l
|= itoa64_to_int (buf
[17]) << 6;
1422 l
|= itoa64_to_int (buf
[18]) << 12;
1423 l
|= itoa64_to_int (buf
[19]) << 18;
1425 digest
[14] = (l
>> 0) & 0xff;
1426 digest
[13] = (l
>> 8) & 0xff;
1427 digest
[12] = (l
>> 16) & 0xff;
1429 l
= itoa64_to_int (buf
[20]) << 0;
1430 l
|= itoa64_to_int (buf
[21]) << 6;
1431 l
|= itoa64_to_int (buf
[22]) << 12;
1432 l
|= itoa64_to_int (buf
[23]) << 18;
1434 digest
[17] = (l
>> 0) & 0xff;
1435 digest
[16] = (l
>> 8) & 0xff;
1436 digest
[15] = (l
>> 16) & 0xff;
1438 l
= itoa64_to_int (buf
[24]) << 0;
1439 l
|= itoa64_to_int (buf
[25]) << 6;
1440 l
|= itoa64_to_int (buf
[26]) << 12;
1441 l
|= itoa64_to_int (buf
[27]) << 18;
1443 digest
[20] = (l
>> 0) & 0xff;
1444 digest
[19] = (l
>> 8) & 0xff;
1445 digest
[18] = (l
>> 16) & 0xff;
1447 l
= itoa64_to_int (buf
[28]) << 0;
1448 l
|= itoa64_to_int (buf
[29]) << 6;
1449 l
|= itoa64_to_int (buf
[30]) << 12;
1450 l
|= itoa64_to_int (buf
[31]) << 18;
1452 digest
[23] = (l
>> 0) & 0xff;
1453 digest
[22] = (l
>> 8) & 0xff;
1454 digest
[21] = (l
>> 16) & 0xff;
1456 l
= itoa64_to_int (buf
[32]) << 0;
1457 l
|= itoa64_to_int (buf
[33]) << 6;
1458 l
|= itoa64_to_int (buf
[34]) << 12;
1459 l
|= itoa64_to_int (buf
[35]) << 18;
1461 digest
[26] = (l
>> 0) & 0xff;
1462 digest
[25] = (l
>> 8) & 0xff;
1463 digest
[24] = (l
>> 16) & 0xff;
1465 l
= itoa64_to_int (buf
[36]) << 0;
1466 l
|= itoa64_to_int (buf
[37]) << 6;
1467 l
|= itoa64_to_int (buf
[38]) << 12;
1468 l
|= itoa64_to_int (buf
[39]) << 18;
1470 digest
[29] = (l
>> 0) & 0xff;
1471 digest
[28] = (l
>> 8) & 0xff;
1472 digest
[27] = (l
>> 16) & 0xff;
1474 l
= itoa64_to_int (buf
[40]) << 0;
1475 l
|= itoa64_to_int (buf
[41]) << 6;
1476 l
|= itoa64_to_int (buf
[42]) << 12;
1478 //digest[32] = (l >> 0) & 0xff;
1479 digest
[31] = (l
>> 8) & 0xff;
1480 digest
[30] = (l
>> 16) & 0xff;
1483 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1487 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1489 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1490 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1491 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1492 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1494 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1496 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1497 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1498 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1499 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1501 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1503 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1504 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1505 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1506 buf
[11] = int_to_itoa64 (l
& 0x3f);
1508 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1510 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1511 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1512 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1513 buf
[15] = int_to_itoa64 (l
& 0x3f);
1515 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1517 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1518 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1519 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1520 buf
[19] = int_to_itoa64 (l
& 0x3f);
1522 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1524 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1525 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1526 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1527 buf
[23] = int_to_itoa64 (l
& 0x3f);
1529 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1531 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1532 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1533 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1534 buf
[27] = int_to_itoa64 (l
& 0x3f);
1536 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1538 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1539 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1540 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1541 buf
[31] = int_to_itoa64 (l
& 0x3f);
1543 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1545 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1546 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1547 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1548 buf
[35] = int_to_itoa64 (l
& 0x3f);
1550 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1552 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1553 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1554 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1555 buf
[39] = int_to_itoa64 (l
& 0x3f);
1557 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1559 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1560 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1561 buf
[42] = int_to_itoa64 (l
& 0x3f);
1564 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1568 l
= itoa64_to_int (buf
[ 0]) << 0;
1569 l
|= itoa64_to_int (buf
[ 1]) << 6;
1570 l
|= itoa64_to_int (buf
[ 2]) << 12;
1571 l
|= itoa64_to_int (buf
[ 3]) << 18;
1573 digest
[ 2] = (l
>> 0) & 0xff;
1574 digest
[ 1] = (l
>> 8) & 0xff;
1575 digest
[ 0] = (l
>> 16) & 0xff;
1577 l
= itoa64_to_int (buf
[ 4]) << 0;
1578 l
|= itoa64_to_int (buf
[ 5]) << 6;
1579 l
|= itoa64_to_int (buf
[ 6]) << 12;
1580 l
|= itoa64_to_int (buf
[ 7]) << 18;
1582 digest
[ 5] = (l
>> 0) & 0xff;
1583 digest
[ 4] = (l
>> 8) & 0xff;
1584 digest
[ 3] = (l
>> 16) & 0xff;
1586 l
= itoa64_to_int (buf
[ 8]) << 0;
1587 l
|= itoa64_to_int (buf
[ 9]) << 6;
1588 l
|= itoa64_to_int (buf
[10]) << 12;
1589 l
|= itoa64_to_int (buf
[11]) << 18;
1591 digest
[ 8] = (l
>> 0) & 0xff;
1592 digest
[ 7] = (l
>> 8) & 0xff;
1593 digest
[ 6] = (l
>> 16) & 0xff;
1595 l
= itoa64_to_int (buf
[12]) << 0;
1596 l
|= itoa64_to_int (buf
[13]) << 6;
1597 l
|= itoa64_to_int (buf
[14]) << 12;
1598 l
|= itoa64_to_int (buf
[15]) << 18;
1600 digest
[11] = (l
>> 0) & 0xff;
1601 digest
[10] = (l
>> 8) & 0xff;
1602 digest
[ 9] = (l
>> 16) & 0xff;
1604 l
= itoa64_to_int (buf
[16]) << 0;
1605 l
|= itoa64_to_int (buf
[17]) << 6;
1606 l
|= itoa64_to_int (buf
[18]) << 12;
1607 l
|= itoa64_to_int (buf
[19]) << 18;
1609 digest
[14] = (l
>> 0) & 0xff;
1610 digest
[13] = (l
>> 8) & 0xff;
1611 digest
[12] = (l
>> 16) & 0xff;
1613 l
= itoa64_to_int (buf
[20]) << 0;
1614 l
|= itoa64_to_int (buf
[21]) << 6;
1615 l
|= itoa64_to_int (buf
[22]) << 12;
1616 l
|= itoa64_to_int (buf
[23]) << 18;
1618 digest
[17] = (l
>> 0) & 0xff;
1619 digest
[16] = (l
>> 8) & 0xff;
1620 digest
[15] = (l
>> 16) & 0xff;
1622 l
= itoa64_to_int (buf
[24]) << 0;
1623 l
|= itoa64_to_int (buf
[25]) << 6;
1624 l
|= itoa64_to_int (buf
[26]) << 12;
1625 l
|= itoa64_to_int (buf
[27]) << 18;
1627 digest
[20] = (l
>> 0) & 0xff;
1628 digest
[19] = (l
>> 8) & 0xff;
1629 digest
[18] = (l
>> 16) & 0xff;
1631 l
= itoa64_to_int (buf
[28]) << 0;
1632 l
|= itoa64_to_int (buf
[29]) << 6;
1633 l
|= itoa64_to_int (buf
[30]) << 12;
1634 l
|= itoa64_to_int (buf
[31]) << 18;
1636 digest
[23] = (l
>> 0) & 0xff;
1637 digest
[22] = (l
>> 8) & 0xff;
1638 digest
[21] = (l
>> 16) & 0xff;
1640 l
= itoa64_to_int (buf
[32]) << 0;
1641 l
|= itoa64_to_int (buf
[33]) << 6;
1642 l
|= itoa64_to_int (buf
[34]) << 12;
1643 l
|= itoa64_to_int (buf
[35]) << 18;
1645 digest
[26] = (l
>> 0) & 0xff;
1646 digest
[25] = (l
>> 8) & 0xff;
1647 digest
[24] = (l
>> 16) & 0xff;
1649 l
= itoa64_to_int (buf
[36]) << 0;
1650 l
|= itoa64_to_int (buf
[37]) << 6;
1651 l
|= itoa64_to_int (buf
[38]) << 12;
1652 l
|= itoa64_to_int (buf
[39]) << 18;
1654 digest
[29] = (l
>> 0) & 0xff;
1655 digest
[28] = (l
>> 8) & 0xff;
1656 digest
[27] = (l
>> 16) & 0xff;
1658 l
= itoa64_to_int (buf
[40]) << 0;
1659 l
|= itoa64_to_int (buf
[41]) << 6;
1660 l
|= itoa64_to_int (buf
[42]) << 12;
1661 l
|= itoa64_to_int (buf
[43]) << 18;
1663 digest
[32] = (l
>> 0) & 0xff;
1664 digest
[31] = (l
>> 8) & 0xff;
1665 digest
[30] = (l
>> 16) & 0xff;
1667 l
= itoa64_to_int (buf
[44]) << 0;
1668 l
|= itoa64_to_int (buf
[45]) << 6;
1669 l
|= itoa64_to_int (buf
[46]) << 12;
1670 l
|= itoa64_to_int (buf
[47]) << 18;
1672 digest
[35] = (l
>> 0) & 0xff;
1673 digest
[34] = (l
>> 8) & 0xff;
1674 digest
[33] = (l
>> 16) & 0xff;
1676 l
= itoa64_to_int (buf
[48]) << 0;
1677 l
|= itoa64_to_int (buf
[49]) << 6;
1678 l
|= itoa64_to_int (buf
[50]) << 12;
1679 l
|= itoa64_to_int (buf
[51]) << 18;
1681 digest
[38] = (l
>> 0) & 0xff;
1682 digest
[37] = (l
>> 8) & 0xff;
1683 digest
[36] = (l
>> 16) & 0xff;
1685 l
= itoa64_to_int (buf
[52]) << 0;
1686 l
|= itoa64_to_int (buf
[53]) << 6;
1687 l
|= itoa64_to_int (buf
[54]) << 12;
1688 l
|= itoa64_to_int (buf
[55]) << 18;
1690 digest
[41] = (l
>> 0) & 0xff;
1691 digest
[40] = (l
>> 8) & 0xff;
1692 digest
[39] = (l
>> 16) & 0xff;
1694 l
= itoa64_to_int (buf
[56]) << 0;
1695 l
|= itoa64_to_int (buf
[57]) << 6;
1696 l
|= itoa64_to_int (buf
[58]) << 12;
1697 l
|= itoa64_to_int (buf
[59]) << 18;
1699 digest
[44] = (l
>> 0) & 0xff;
1700 digest
[43] = (l
>> 8) & 0xff;
1701 digest
[42] = (l
>> 16) & 0xff;
1703 l
= itoa64_to_int (buf
[60]) << 0;
1704 l
|= itoa64_to_int (buf
[61]) << 6;
1705 l
|= itoa64_to_int (buf
[62]) << 12;
1706 l
|= itoa64_to_int (buf
[63]) << 18;
1708 digest
[47] = (l
>> 0) & 0xff;
1709 digest
[46] = (l
>> 8) & 0xff;
1710 digest
[45] = (l
>> 16) & 0xff;
1712 l
= itoa64_to_int (buf
[64]) << 0;
1713 l
|= itoa64_to_int (buf
[65]) << 6;
1714 l
|= itoa64_to_int (buf
[66]) << 12;
1715 l
|= itoa64_to_int (buf
[67]) << 18;
1717 digest
[50] = (l
>> 0) & 0xff;
1718 digest
[49] = (l
>> 8) & 0xff;
1719 digest
[48] = (l
>> 16) & 0xff;
1721 l
= itoa64_to_int (buf
[68]) << 0;
1722 l
|= itoa64_to_int (buf
[69]) << 6;
1723 l
|= itoa64_to_int (buf
[70]) << 12;
1724 l
|= itoa64_to_int (buf
[71]) << 18;
1726 digest
[53] = (l
>> 0) & 0xff;
1727 digest
[52] = (l
>> 8) & 0xff;
1728 digest
[51] = (l
>> 16) & 0xff;
1730 l
= itoa64_to_int (buf
[72]) << 0;
1731 l
|= itoa64_to_int (buf
[73]) << 6;
1732 l
|= itoa64_to_int (buf
[74]) << 12;
1733 l
|= itoa64_to_int (buf
[75]) << 18;
1735 digest
[56] = (l
>> 0) & 0xff;
1736 digest
[55] = (l
>> 8) & 0xff;
1737 digest
[54] = (l
>> 16) & 0xff;
1739 l
= itoa64_to_int (buf
[76]) << 0;
1740 l
|= itoa64_to_int (buf
[77]) << 6;
1741 l
|= itoa64_to_int (buf
[78]) << 12;
1742 l
|= itoa64_to_int (buf
[79]) << 18;
1744 digest
[59] = (l
>> 0) & 0xff;
1745 digest
[58] = (l
>> 8) & 0xff;
1746 digest
[57] = (l
>> 16) & 0xff;
1748 l
= itoa64_to_int (buf
[80]) << 0;
1749 l
|= itoa64_to_int (buf
[81]) << 6;
1750 l
|= itoa64_to_int (buf
[82]) << 12;
1751 l
|= itoa64_to_int (buf
[83]) << 18;
1753 digest
[62] = (l
>> 0) & 0xff;
1754 digest
[61] = (l
>> 8) & 0xff;
1755 digest
[60] = (l
>> 16) & 0xff;
1757 l
= itoa64_to_int (buf
[84]) << 0;
1758 l
|= itoa64_to_int (buf
[85]) << 6;
1760 digest
[63] = (l
>> 16) & 0xff;
1763 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1767 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1769 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1770 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1771 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1772 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1774 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1776 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1777 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1778 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1779 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1781 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1783 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1784 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1785 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1786 buf
[11] = int_to_itoa64 (l
& 0x3f);
1788 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1790 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1791 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1792 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1793 buf
[15] = int_to_itoa64 (l
& 0x3f);
1795 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1797 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1798 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1799 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1800 buf
[19] = int_to_itoa64 (l
& 0x3f);
1802 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1804 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1805 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1806 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1807 buf
[23] = int_to_itoa64 (l
& 0x3f);
1809 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1811 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1812 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1813 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1814 buf
[27] = int_to_itoa64 (l
& 0x3f);
1816 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1818 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1819 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1820 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1821 buf
[31] = int_to_itoa64 (l
& 0x3f);
1823 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1825 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1826 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1827 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1828 buf
[35] = int_to_itoa64 (l
& 0x3f);
1830 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1832 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1833 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1834 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1835 buf
[39] = int_to_itoa64 (l
& 0x3f);
1837 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1839 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1840 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1841 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1842 buf
[43] = int_to_itoa64 (l
& 0x3f);
1844 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1846 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1847 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1848 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1849 buf
[47] = int_to_itoa64 (l
& 0x3f);
1851 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1853 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1854 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1855 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1856 buf
[51] = int_to_itoa64 (l
& 0x3f);
1858 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1860 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1861 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1862 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1863 buf
[55] = int_to_itoa64 (l
& 0x3f);
1865 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1867 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1868 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1869 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1870 buf
[59] = int_to_itoa64 (l
& 0x3f);
1872 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1874 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1875 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1876 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1877 buf
[63] = int_to_itoa64 (l
& 0x3f);
1879 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1881 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1882 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1883 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1884 buf
[67] = int_to_itoa64 (l
& 0x3f);
1886 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1888 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1889 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1890 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1891 buf
[71] = int_to_itoa64 (l
& 0x3f);
1893 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1895 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1896 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1897 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1898 buf
[75] = int_to_itoa64 (l
& 0x3f);
1900 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1902 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1903 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1904 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1905 buf
[79] = int_to_itoa64 (l
& 0x3f);
1907 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1909 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1910 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1911 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1912 buf
[83] = int_to_itoa64 (l
& 0x3f);
1914 l
= 0 | 0 | (digest
[63] << 16);
1916 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1917 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1920 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1924 l
= itoa64_to_int (buf
[ 0]) << 0;
1925 l
|= itoa64_to_int (buf
[ 1]) << 6;
1926 l
|= itoa64_to_int (buf
[ 2]) << 12;
1927 l
|= itoa64_to_int (buf
[ 3]) << 18;
1929 digest
[ 0] = (l
>> 16) & 0xff;
1930 digest
[10] = (l
>> 8) & 0xff;
1931 digest
[20] = (l
>> 0) & 0xff;
1933 l
= itoa64_to_int (buf
[ 4]) << 0;
1934 l
|= itoa64_to_int (buf
[ 5]) << 6;
1935 l
|= itoa64_to_int (buf
[ 6]) << 12;
1936 l
|= itoa64_to_int (buf
[ 7]) << 18;
1938 digest
[21] = (l
>> 16) & 0xff;
1939 digest
[ 1] = (l
>> 8) & 0xff;
1940 digest
[11] = (l
>> 0) & 0xff;
1942 l
= itoa64_to_int (buf
[ 8]) << 0;
1943 l
|= itoa64_to_int (buf
[ 9]) << 6;
1944 l
|= itoa64_to_int (buf
[10]) << 12;
1945 l
|= itoa64_to_int (buf
[11]) << 18;
1947 digest
[12] = (l
>> 16) & 0xff;
1948 digest
[22] = (l
>> 8) & 0xff;
1949 digest
[ 2] = (l
>> 0) & 0xff;
1951 l
= itoa64_to_int (buf
[12]) << 0;
1952 l
|= itoa64_to_int (buf
[13]) << 6;
1953 l
|= itoa64_to_int (buf
[14]) << 12;
1954 l
|= itoa64_to_int (buf
[15]) << 18;
1956 digest
[ 3] = (l
>> 16) & 0xff;
1957 digest
[13] = (l
>> 8) & 0xff;
1958 digest
[23] = (l
>> 0) & 0xff;
1960 l
= itoa64_to_int (buf
[16]) << 0;
1961 l
|= itoa64_to_int (buf
[17]) << 6;
1962 l
|= itoa64_to_int (buf
[18]) << 12;
1963 l
|= itoa64_to_int (buf
[19]) << 18;
1965 digest
[24] = (l
>> 16) & 0xff;
1966 digest
[ 4] = (l
>> 8) & 0xff;
1967 digest
[14] = (l
>> 0) & 0xff;
1969 l
= itoa64_to_int (buf
[20]) << 0;
1970 l
|= itoa64_to_int (buf
[21]) << 6;
1971 l
|= itoa64_to_int (buf
[22]) << 12;
1972 l
|= itoa64_to_int (buf
[23]) << 18;
1974 digest
[15] = (l
>> 16) & 0xff;
1975 digest
[25] = (l
>> 8) & 0xff;
1976 digest
[ 5] = (l
>> 0) & 0xff;
1978 l
= itoa64_to_int (buf
[24]) << 0;
1979 l
|= itoa64_to_int (buf
[25]) << 6;
1980 l
|= itoa64_to_int (buf
[26]) << 12;
1981 l
|= itoa64_to_int (buf
[27]) << 18;
1983 digest
[ 6] = (l
>> 16) & 0xff;
1984 digest
[16] = (l
>> 8) & 0xff;
1985 digest
[26] = (l
>> 0) & 0xff;
1987 l
= itoa64_to_int (buf
[28]) << 0;
1988 l
|= itoa64_to_int (buf
[29]) << 6;
1989 l
|= itoa64_to_int (buf
[30]) << 12;
1990 l
|= itoa64_to_int (buf
[31]) << 18;
1992 digest
[27] = (l
>> 16) & 0xff;
1993 digest
[ 7] = (l
>> 8) & 0xff;
1994 digest
[17] = (l
>> 0) & 0xff;
1996 l
= itoa64_to_int (buf
[32]) << 0;
1997 l
|= itoa64_to_int (buf
[33]) << 6;
1998 l
|= itoa64_to_int (buf
[34]) << 12;
1999 l
|= itoa64_to_int (buf
[35]) << 18;
2001 digest
[18] = (l
>> 16) & 0xff;
2002 digest
[28] = (l
>> 8) & 0xff;
2003 digest
[ 8] = (l
>> 0) & 0xff;
2005 l
= itoa64_to_int (buf
[36]) << 0;
2006 l
|= itoa64_to_int (buf
[37]) << 6;
2007 l
|= itoa64_to_int (buf
[38]) << 12;
2008 l
|= itoa64_to_int (buf
[39]) << 18;
2010 digest
[ 9] = (l
>> 16) & 0xff;
2011 digest
[19] = (l
>> 8) & 0xff;
2012 digest
[29] = (l
>> 0) & 0xff;
2014 l
= itoa64_to_int (buf
[40]) << 0;
2015 l
|= itoa64_to_int (buf
[41]) << 6;
2016 l
|= itoa64_to_int (buf
[42]) << 12;
2018 digest
[31] = (l
>> 8) & 0xff;
2019 digest
[30] = (l
>> 0) & 0xff;
2022 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2026 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2028 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2029 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2030 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2031 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2033 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2035 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2036 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2037 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2038 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2042 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2043 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2044 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2045 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2049 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2050 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2051 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2052 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2056 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2057 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2058 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2059 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2063 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2064 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2065 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2066 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2070 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2071 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2072 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2073 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2077 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2078 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2079 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2080 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2084 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2085 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2086 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2087 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2091 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2092 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2093 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2094 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2096 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2098 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2099 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2100 buf
[42] = int_to_itoa64 (l
& 0x3f);
2103 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2107 l
= itoa64_to_int (buf
[ 0]) << 0;
2108 l
|= itoa64_to_int (buf
[ 1]) << 6;
2109 l
|= itoa64_to_int (buf
[ 2]) << 12;
2110 l
|= itoa64_to_int (buf
[ 3]) << 18;
2112 digest
[ 0] = (l
>> 0) & 0xff;
2113 digest
[ 1] = (l
>> 8) & 0xff;
2114 digest
[ 2] = (l
>> 16) & 0xff;
2116 l
= itoa64_to_int (buf
[ 4]) << 0;
2117 l
|= itoa64_to_int (buf
[ 5]) << 6;
2118 l
|= itoa64_to_int (buf
[ 6]) << 12;
2119 l
|= itoa64_to_int (buf
[ 7]) << 18;
2121 digest
[ 3] = (l
>> 0) & 0xff;
2122 digest
[ 4] = (l
>> 8) & 0xff;
2123 digest
[ 5] = (l
>> 16) & 0xff;
2125 l
= itoa64_to_int (buf
[ 8]) << 0;
2126 l
|= itoa64_to_int (buf
[ 9]) << 6;
2127 l
|= itoa64_to_int (buf
[10]) << 12;
2128 l
|= itoa64_to_int (buf
[11]) << 18;
2130 digest
[ 6] = (l
>> 0) & 0xff;
2131 digest
[ 7] = (l
>> 8) & 0xff;
2132 digest
[ 8] = (l
>> 16) & 0xff;
2134 l
= itoa64_to_int (buf
[12]) << 0;
2135 l
|= itoa64_to_int (buf
[13]) << 6;
2136 l
|= itoa64_to_int (buf
[14]) << 12;
2137 l
|= itoa64_to_int (buf
[15]) << 18;
2139 digest
[ 9] = (l
>> 0) & 0xff;
2140 digest
[10] = (l
>> 8) & 0xff;
2141 digest
[11] = (l
>> 16) & 0xff;
2143 l
= itoa64_to_int (buf
[16]) << 0;
2144 l
|= itoa64_to_int (buf
[17]) << 6;
2145 l
|= itoa64_to_int (buf
[18]) << 12;
2146 l
|= itoa64_to_int (buf
[19]) << 18;
2148 digest
[12] = (l
>> 0) & 0xff;
2149 digest
[13] = (l
>> 8) & 0xff;
2150 digest
[14] = (l
>> 16) & 0xff;
2152 l
= itoa64_to_int (buf
[20]) << 0;
2153 l
|= itoa64_to_int (buf
[21]) << 6;
2154 l
|= itoa64_to_int (buf
[22]) << 12;
2155 l
|= itoa64_to_int (buf
[23]) << 18;
2157 digest
[15] = (l
>> 0) & 0xff;
2158 digest
[16] = (l
>> 8) & 0xff;
2159 digest
[17] = (l
>> 16) & 0xff;
2161 l
= itoa64_to_int (buf
[24]) << 0;
2162 l
|= itoa64_to_int (buf
[25]) << 6;
2163 l
|= itoa64_to_int (buf
[26]) << 12;
2164 l
|= itoa64_to_int (buf
[27]) << 18;
2166 digest
[18] = (l
>> 0) & 0xff;
2167 digest
[19] = (l
>> 8) & 0xff;
2168 digest
[20] = (l
>> 16) & 0xff;
2170 l
= itoa64_to_int (buf
[28]) << 0;
2171 l
|= itoa64_to_int (buf
[29]) << 6;
2172 l
|= itoa64_to_int (buf
[30]) << 12;
2173 l
|= itoa64_to_int (buf
[31]) << 18;
2175 digest
[21] = (l
>> 0) & 0xff;
2176 digest
[22] = (l
>> 8) & 0xff;
2177 digest
[23] = (l
>> 16) & 0xff;
2179 l
= itoa64_to_int (buf
[32]) << 0;
2180 l
|= itoa64_to_int (buf
[33]) << 6;
2181 l
|= itoa64_to_int (buf
[34]) << 12;
2182 l
|= itoa64_to_int (buf
[35]) << 18;
2184 digest
[24] = (l
>> 0) & 0xff;
2185 digest
[25] = (l
>> 8) & 0xff;
2186 digest
[26] = (l
>> 16) & 0xff;
2188 l
= itoa64_to_int (buf
[36]) << 0;
2189 l
|= itoa64_to_int (buf
[37]) << 6;
2190 l
|= itoa64_to_int (buf
[38]) << 12;
2191 l
|= itoa64_to_int (buf
[39]) << 18;
2193 digest
[27] = (l
>> 0) & 0xff;
2194 digest
[28] = (l
>> 8) & 0xff;
2195 digest
[29] = (l
>> 16) & 0xff;
2197 l
= itoa64_to_int (buf
[40]) << 0;
2198 l
|= itoa64_to_int (buf
[41]) << 6;
2199 l
|= itoa64_to_int (buf
[42]) << 12;
2200 l
|= itoa64_to_int (buf
[43]) << 18;
2202 digest
[30] = (l
>> 0) & 0xff;
2203 digest
[31] = (l
>> 8) & 0xff;
2204 digest
[32] = (l
>> 16) & 0xff;
2239 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2243 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2245 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2246 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2247 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2248 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2250 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2252 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2253 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2254 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2255 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2257 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2259 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2260 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2261 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2262 buf
[11] = int_to_itoa64 (l
& 0x3f);
2264 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2266 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2267 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2268 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2269 buf
[15] = int_to_itoa64 (l
& 0x3f);
2271 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2273 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2274 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2275 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2276 buf
[19] = int_to_itoa64 (l
& 0x3f);
2278 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2280 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2281 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2282 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2283 buf
[23] = int_to_itoa64 (l
& 0x3f);
2285 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2287 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2288 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2289 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2290 buf
[27] = int_to_itoa64 (l
& 0x3f);
2292 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2294 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2295 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2296 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2297 buf
[31] = int_to_itoa64 (l
& 0x3f);
2299 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2301 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2302 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2303 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2304 buf
[35] = int_to_itoa64 (l
& 0x3f);
2306 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2308 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2309 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2310 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2311 buf
[39] = int_to_itoa64 (l
& 0x3f);
2313 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2315 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2316 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2317 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2318 //buf[43] = int_to_itoa64 (l & 0x3f);
2326 static struct termio savemodes
;
2327 static int havemodes
= 0;
2331 struct termio modmodes
;
2333 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2337 modmodes
= savemodes
;
2338 modmodes
.c_lflag
&= ~ICANON
;
2339 modmodes
.c_cc
[VMIN
] = 1;
2340 modmodes
.c_cc
[VTIME
] = 0;
2342 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2351 FD_SET (fileno (stdin
), &rfds
);
2358 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2360 if (retval
== 0) return 0;
2361 if (retval
== -1) return -1;
2368 if (!havemodes
) return 0;
2370 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2375 static struct termios savemodes
;
2376 static int havemodes
= 0;
2380 struct termios modmodes
;
2382 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2386 modmodes
= savemodes
;
2387 modmodes
.c_lflag
&= ~ICANON
;
2388 modmodes
.c_cc
[VMIN
] = 1;
2389 modmodes
.c_cc
[VTIME
] = 0;
2391 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2400 FD_SET (fileno (stdin
), &rfds
);
2407 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2409 if (retval
== 0) return 0;
2410 if (retval
== -1) return -1;
2417 if (!havemodes
) return 0;
2419 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2424 static DWORD saveMode
= 0;
2428 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2430 GetConsoleMode (stdinHandle
, &saveMode
);
2431 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2438 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2440 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2442 if (rc
== WAIT_TIMEOUT
) return 0;
2443 if (rc
== WAIT_ABANDONED
) return -1;
2444 if (rc
== WAIT_FAILED
) return -1;
2446 // The whole ReadConsoleInput () part is a workaround.
2447 // For some unknown reason, maybe a mingw bug, a random signal
2448 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2449 // Then it wants to read with getche () a keyboard input
2450 // which has never been made.
2452 INPUT_RECORD buf
[100];
2456 memset (buf
, 0, sizeof (buf
));
2458 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2460 FlushConsoleInputBuffer (stdinHandle
);
2462 for (uint i
= 0; i
< num
; i
++)
2464 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2466 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2468 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2470 return KeyEvent
.uChar
.AsciiChar
;
2478 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2480 SetConsoleMode (stdinHandle
, saveMode
);
2490 #define MSG_ENOMEM "Insufficient memory available"
2492 void *mycalloc (size_t nmemb
, size_t size
)
2494 void *p
= calloc (nmemb
, size
);
2498 log_error ("ERROR: %s", MSG_ENOMEM
);
2506 void *mymalloc (size_t size
)
2508 void *p
= malloc (size
);
2512 log_error ("ERROR: %s", MSG_ENOMEM
);
2517 memset (p
, 0, size
);
2522 void myfree (void *ptr
)
2524 if (ptr
== NULL
) return;
2529 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2531 void *p
= realloc (ptr
, oldsz
+ add
);
2535 log_error ("ERROR: %s", MSG_ENOMEM
);
2540 memset ((char *) p
+ oldsz
, 0, add
);
2545 char *mystrdup (const char *s
)
2547 const size_t len
= strlen (s
);
2549 char *b
= (char *) mymalloc (len
+ 1);
2556 FILE *logfile_open (char *logfile
)
2558 FILE *fp
= fopen (logfile
, "ab");
2568 void logfile_close (FILE *fp
)
2570 if (fp
== stdout
) return;
2575 void logfile_append (const char *fmt
, ...)
2577 if (data
.logfile_disable
== 1) return;
2579 FILE *fp
= logfile_open (data
.logfile
);
2585 vfprintf (fp
, fmt
, ap
);
2596 int logfile_generate_id ()
2598 const int n
= rand ();
2607 char *logfile_generate_topid ()
2609 const int id
= logfile_generate_id ();
2611 char *topid
= (char *) mymalloc (1 + 16 + 1);
2613 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2618 char *logfile_generate_subid ()
2620 const int id
= logfile_generate_id ();
2622 char *subid
= (char *) mymalloc (1 + 16 + 1);
2624 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2634 void lock_file (FILE *fp
)
2638 memset (&lock
, 0, sizeof (struct flock
));
2640 lock
.l_type
= F_WRLCK
;
2641 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2645 log_error ("ERROR: failed acquiring write lock: %s", strerror (errno
));
2652 void unlock_file (FILE *fp
)
2656 memset (&lock
, 0, sizeof (struct flock
));
2658 lock
.l_type
= F_UNLCK
;
2659 fcntl(fileno(fp
), F_SETLK
, &lock
);
2666 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2668 FlushFileBuffers (h
);
2677 #if defined(_WIN) && defined(HAVE_NVAPI)
2678 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2682 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nv
, nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2686 log_info ("WARN: No NvAPI adapters found");
2693 #endif // _WIN && HAVE_NVAPI
2695 #if defined(LINUX) && defined(HAVE_NVML)
2696 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2700 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2702 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nv
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2704 // can be used to determine if the device by index matches the cuda device by index
2705 // char name[100]; memset (name, 0, sizeof (name));
2706 // hm_NVML_nvmlDeviceGetName (data.hm_nv, nvGPUHandle[i], name, sizeof (name) - 1);
2713 log_info ("WARN: No NVML adapters found");
2720 #endif // LINUX && HAVE_NVML
2723 int get_adapters_num_amd (void *adl
, int *iNumberAdapters
)
2725 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2727 if (iNumberAdapters
== 0)
2729 log_info ("WARN: No ADL adapters found.");
2738 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2740 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2741 ADLODParameters lpOdParameters;
2743 lpOdParameters.iSize = sizeof (ADLODParameters);
2744 size_t plevels_size = 0;
2746 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2748 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2749 __func__, iAdapterIndex,
2750 lpOdParameters.iNumberOfPerformanceLevels,
2751 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2752 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2754 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2756 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2758 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2760 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2762 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2763 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2764 __func__, iAdapterIndex, j,
2765 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2767 myfree (lpOdPerformanceLevels);
2773 LPAdapterInfo
hm_get_adapter_info_amd (void *adl
, int iNumberAdapters
)
2775 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2777 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2779 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2781 return lpAdapterInfo
;
2786 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2789 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2793 for (uint i = 0; i < num_adl_adapters; i++)
2795 int opencl_bus_num = hm_device[i].busid;
2796 int opencl_dev_num = hm_device[i].devid;
2798 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2806 if (idx >= DEVICES_MAX) return -1;
2811 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2813 for (uint i = 0; i < opencl_num_devices; i++)
2815 cl_device_topology_amd device_topology;
2817 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2819 hm_device[i].busid = device_topology.pcie.bus;
2820 hm_device[i].devid = device_topology.pcie.device;
2825 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2827 // basically bubble sort
2829 for (int i
= 0; i
< num_adl_adapters
; i
++)
2831 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2833 // get info of adapter [x]
2835 u32 adapter_index_x
= valid_adl_device_list
[j
];
2836 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2838 u32 bus_num_x
= info_x
.iBusNumber
;
2839 u32 dev_num_x
= info_x
.iDeviceNumber
;
2841 // get info of adapter [y]
2843 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2844 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2846 u32 bus_num_y
= info_y
.iBusNumber
;
2847 u32 dev_num_y
= info_y
.iDeviceNumber
;
2851 if (bus_num_y
< bus_num_x
)
2855 else if (bus_num_y
== bus_num_x
)
2857 if (dev_num_y
< dev_num_x
)
2865 u32 temp
= valid_adl_device_list
[j
+ 1];
2867 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2868 valid_adl_device_list
[j
+ 0] = temp
;
2874 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2876 *num_adl_adapters
= 0;
2878 u32
*adl_adapters
= NULL
;
2880 int *bus_numbers
= NULL
;
2881 int *device_numbers
= NULL
;
2883 for (int i
= 0; i
< iNumberAdapters
; i
++)
2885 AdapterInfo info
= lpAdapterInfo
[i
];
2887 if (strlen (info
.strUDID
) < 1) continue;
2890 if (info
.iVendorID
!= 1002) continue;
2892 if (info
.iVendorID
!= 0x1002) continue;
2895 if (info
.iBusNumber
< 0) continue;
2896 if (info
.iDeviceNumber
< 0) continue;
2900 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2902 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2909 if (found
) continue;
2911 // add it to the list
2913 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2915 adl_adapters
[*num_adl_adapters
] = i
;
2917 // rest is just bookkeeping
2919 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2920 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2922 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2923 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2925 (*num_adl_adapters
)++;
2928 myfree (bus_numbers
);
2929 myfree (device_numbers
);
2931 // sort the list by increasing bus id, device id number
2933 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2935 return adl_adapters
;
2938 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2940 // loop through all valid devices
2942 for (int i
= 0; i
< num_adl_adapters
; i
++)
2944 u32 adapter_index
= valid_adl_device_list
[i
];
2948 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2950 // unfortunately this doesn't work since bus id and dev id are not unique
2951 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2952 // if (opencl_device_index == -1) continue;
2954 int opencl_device_index
= i
;
2956 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2958 // get fanspeed info
2960 if (hm_device
[opencl_device_index
].od_version
== 5)
2962 ADLFanSpeedInfo FanSpeedInfo
;
2964 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2966 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2968 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2970 // check read and write capability in fanspeedinfo
2972 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2973 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2975 hm_device
[opencl_device_index
].fan_supported
= 1;
2979 hm_device
[opencl_device_index
].fan_supported
= 0;
2982 else // od_version == 6
2984 ADLOD6FanSpeedInfo faninfo
;
2986 memset (&faninfo
, 0, sizeof (faninfo
));
2988 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2990 // check read capability in fanspeedinfo
2992 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2994 hm_device
[opencl_device_index
].fan_supported
= 1;
2998 hm_device
[opencl_device_index
].fan_supported
= 0;
3006 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3008 for (int i
= 0; i
< num_adl_adapters
; i
++)
3010 u32 adapter_index
= valid_adl_device_list
[i
];
3014 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3016 // get overdrive version
3018 int od_supported
= 0;
3022 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3024 // store the overdrive version in hm_device
3026 // unfortunately this doesn't work since bus id and dev id are not unique
3027 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3028 // if (opencl_device_index == -1) continue;
3030 int opencl_device_index
= i
;
3032 hm_device
[opencl_device_index
].od_version
= od_version
;
3038 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3040 for (int i
= 0; i
< num_adl_adapters
; i
++)
3042 u32 adapter_index
= valid_adl_device_list
[i
];
3046 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3048 // store the iAdapterIndex in hm_device
3050 // unfortunately this doesn't work since bus id and dev id are not unique
3051 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3052 // if (opencl_device_index == -1) continue;
3054 int opencl_device_index
= i
;
3056 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3059 return num_adl_adapters
;
3063 int hm_get_temperature_with_device_id (const uint device_id
)
3065 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3068 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3072 if (data
.hm_device
[device_id
].od_version
== 5)
3074 ADLTemperature Temperature
;
3076 Temperature
.iSize
= sizeof (ADLTemperature
);
3078 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3080 return Temperature
.iTemperature
/ 1000;
3082 else if (data
.hm_device
[device_id
].od_version
== 6)
3084 int Temperature
= 0;
3086 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3088 return Temperature
/ 1000;
3094 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3095 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3097 #if defined(LINUX) && defined(HAVE_NVML)
3098 int temperature
= 0;
3100 hm_NVML_nvmlDeviceGetTemperature (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (unsigned int *) &temperature
);
3105 #if defined(WIN) && defined(HAVE_NVAPI)
3106 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3108 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3109 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3110 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3111 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3113 if (hm_NvAPI_GPU_GetThermalSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3115 return pThermalSettings
.sensor
[0].currentTemp
;
3116 #endif // WIN && HAVE_NVAPI
3118 #endif // HAVE_NVML || HAVE_NVAPI
3123 int hm_get_fanspeed_with_device_id (const uint device_id
)
3125 // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
3126 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3128 if (data
.hm_device
[device_id
].fan_supported
== 1)
3131 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3135 if (data
.hm_device
[device_id
].od_version
== 5)
3137 ADLFanSpeedValue lpFanSpeedValue
;
3139 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3141 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3142 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3143 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3145 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3147 return lpFanSpeedValue
.iFanSpeed
;
3149 else // od_version == 6
3151 ADLOD6FanSpeedInfo faninfo
;
3153 memset (&faninfo
, 0, sizeof (faninfo
));
3155 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3157 return faninfo
.iFanSpeedPercent
;
3163 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3164 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3166 #if defined(LINUX) && defined(HAVE_NVML)
3169 hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (unsigned int *) &speed
);
3174 #if defined(WIN) && defined(HAVE_NVAPI)
3176 NV_GPU_COOLER_SETTINGS pCoolerSettings
;
3178 pCoolerSettings
.Version
= GPU_COOLER_SETTINGS_VER
| sizeof (NV_GPU_COOLER_SETTINGS
);
3180 hm_NvAPI_GPU_GetCoolerSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pCoolerSettings
);
3182 return pCoolerSettings
.Cooler
[0].CurrentLevel
;
3185 #endif // HAVE_NVML || HAVE_NVAPI
3191 int hm_get_utilization_with_device_id (const uint device_id
)
3193 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3196 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3200 ADLPMActivity PMActivity
;
3202 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3204 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3206 return PMActivity
.iActivityPercent
;
3211 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3212 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3214 #if defined(LINUX) && defined(HAVE_NVML)
3215 nvmlUtilization_t utilization
;
3217 hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3219 return utilization
.gpu
;
3222 #if defined(WIN) && defined(HAVE_NVAPI)
3223 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3225 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3227 if (hm_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3229 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3232 #endif // HAVE_NVML || HAVE_NVAPI
3238 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3240 if (data
.hm_device
[device_id
].fan_supported
== 1)
3244 if (data
.hm_device
[device_id
].od_version
== 5)
3246 ADLFanSpeedValue lpFanSpeedValue
;
3248 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3250 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3251 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3252 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3253 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3255 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3259 else // od_version == 6
3261 ADLOD6FanSpeedValue fan_speed_value
;
3263 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3265 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3266 fan_speed_value
.iFanSpeed
= fanspeed
;
3268 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3279 // helper function for status display
3281 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3283 #define VALUE_NOT_AVAILABLE "N/A"
3287 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3291 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3294 #endif // HAVE_HWMON
3300 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3302 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3304 if (css_cnt
> SP_PW_MAX
)
3306 log_error ("ERROR: mask length is too long");
3311 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3313 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3315 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3316 uint cs_len
= css
[css_pos
].cs_len
;
3318 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3320 uint c
= cs_buf
[cs_pos
] & 0xff;
3327 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3329 cs_t
*cs
= &css
[css_cnt
];
3331 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3333 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3337 for (i
= 0; i
< cs
->cs_len
; i
++)
3339 const uint u
= cs
->cs_buf
[i
];
3344 for (i
= 0; i
< in_len
; i
++)
3346 uint u
= in_buf
[i
] & 0xff;
3348 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3350 if (css_uniq
[u
] == 1) continue;
3354 cs
->cs_buf
[cs
->cs_len
] = u
;
3362 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3366 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3368 uint p0
= in_buf
[in_pos
] & 0xff;
3370 if (interpret
== 1 && p0
== '?')
3374 if (in_pos
== in_len
) break;
3376 uint p1
= in_buf
[in_pos
] & 0xff;
3380 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3382 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3384 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3386 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3388 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3390 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3392 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3393 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3395 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3396 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3398 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3399 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3401 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3402 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3404 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3406 default: log_error ("Syntax error: %s", in_buf
);
3412 if (data
.hex_charset
)
3416 if (in_pos
== in_len
)
3418 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3423 uint p1
= in_buf
[in_pos
] & 0xff;
3425 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3427 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3434 chr
= hex_convert (p1
) << 0;
3435 chr
|= hex_convert (p0
) << 4;
3437 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3443 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3449 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3453 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3455 sum
*= css
[css_pos
].cs_len
;
3461 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3463 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3468 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3470 char p0
= mask_buf
[mask_pos
];
3476 if (mask_pos
== mask_len
) break;
3478 char p1
= mask_buf
[mask_pos
];
3484 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3486 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3488 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3490 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3492 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3494 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3496 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3497 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3499 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3500 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3502 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3503 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3505 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3506 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3508 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3510 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3516 if (data
.hex_charset
)
3520 // if there is no 2nd hex character, show an error:
3522 if (mask_pos
== mask_len
)
3524 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3529 char p1
= mask_buf
[mask_pos
];
3531 // if they are not valid hex character, show an error:
3533 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3535 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3542 chr
|= hex_convert (p1
) << 0;
3543 chr
|= hex_convert (p0
) << 4;
3545 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3551 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3558 log_error ("ERROR: invalid mask length (0)");
3568 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3570 for (int i
= 0; i
< css_cnt
; i
++)
3572 uint len
= css
[i
].cs_len
;
3573 u64 next
= val
/ len
;
3574 uint pos
= val
% len
;
3575 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3580 void mp_cut_at (char *mask
, uint max
)
3584 uint mask_len
= strlen (mask
);
3586 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3588 if (mask
[i
] == '?') i
++;
3594 void mp_setup_sys (cs_t
*mp_sys
)
3598 uint donec
[CHARSIZ
] = { 0 };
3600 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3601 mp_sys
[0].cs_buf
[pos
++] = chr
;
3602 mp_sys
[0].cs_len
= pos
; }
3604 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3605 mp_sys
[1].cs_buf
[pos
++] = chr
;
3606 mp_sys
[1].cs_len
= pos
; }
3608 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3609 mp_sys
[2].cs_buf
[pos
++] = chr
;
3610 mp_sys
[2].cs_len
= pos
; }
3612 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3613 mp_sys
[3].cs_buf
[pos
++] = chr
;
3614 mp_sys
[3].cs_len
= pos
; }
3616 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3617 mp_sys
[4].cs_len
= pos
; }
3619 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3620 mp_sys
[5].cs_len
= pos
; }
3623 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3625 FILE *fp
= fopen (buf
, "rb");
3627 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3629 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3633 char mp_file
[1024] = { 0 };
3635 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3639 len
= in_superchop (mp_file
);
3643 log_info ("WARNING: charset file corrupted");
3645 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3649 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3654 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3656 mp_usr
[index
].cs_len
= 0;
3658 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3661 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3663 char *new_mask_buf
= (char *) mymalloc (256);
3669 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3671 if (css_pos
== len
) break;
3673 char p0
= mask_buf
[mask_pos
];
3675 new_mask_buf
[mask_pos
] = p0
;
3681 if (mask_pos
== mask_len
) break;
3683 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3687 if (data
.hex_charset
)
3691 if (mask_pos
== mask_len
)
3693 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3698 char p1
= mask_buf
[mask_pos
];
3700 // if they are not valid hex character, show an error:
3702 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3704 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3709 new_mask_buf
[mask_pos
] = p1
;
3714 if (css_pos
== len
) return (new_mask_buf
);
3716 myfree (new_mask_buf
);
3725 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3731 for (i
= start
; i
< stop
; i
++)
3733 sum
*= root_css_buf
[i
].cs_len
;
3739 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3743 cs_t
*cs
= &root_css_buf
[start
];
3747 for (i
= start
; i
< stop
; i
++)
3749 const u64 m
= v
% cs
->cs_len
;
3750 const u64 d
= v
/ cs
->cs_len
;
3754 const uint k
= cs
->cs_buf
[m
];
3756 pw_buf
[i
- start
] = (char) k
;
3758 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3762 int sp_comp_val (const void *p1
, const void *p2
)
3764 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3765 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3767 return b2
->val
- b1
->val
;
3770 void sp_setup_tbl (const char *shared_dir
, char *hcstat
, uint disable
, uint classic
, hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
)
3777 * Initialize hcstats
3780 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3782 u64
*root_stats_ptr
= root_stats_buf
;
3784 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3786 for (i
= 0; i
< SP_PW_MAX
; i
++)
3788 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3790 root_stats_ptr
+= CHARSIZ
;
3793 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3795 u64
*markov_stats_ptr
= markov_stats_buf
;
3797 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3799 for (i
= 0; i
< SP_PW_MAX
; i
++)
3801 for (j
= 0; j
< CHARSIZ
; j
++)
3803 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3805 markov_stats_ptr
+= CHARSIZ
;
3815 char hcstat_tmp
[256] = { 0 };
3817 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3819 hcstat
= hcstat_tmp
;
3822 FILE *fd
= fopen (hcstat
, "rb");
3826 log_error ("%s: %s", hcstat
, strerror (errno
));
3831 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3833 log_error ("%s: Could not load data", hcstat
);
3840 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3842 log_error ("%s: Could not load data", hcstat
);
3852 * Markov modifier of hcstat_table on user request
3857 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
3858 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
3863 /* Add all stats to first position */
3865 for (i
= 1; i
< SP_PW_MAX
; i
++)
3867 u64
*out
= root_stats_buf_by_pos
[0];
3868 u64
*in
= root_stats_buf_by_pos
[i
];
3870 for (j
= 0; j
< CHARSIZ
; j
++)
3876 for (i
= 1; i
< SP_PW_MAX
; i
++)
3878 u64
*out
= markov_stats_buf_by_key
[0][0];
3879 u64
*in
= markov_stats_buf_by_key
[i
][0];
3881 for (j
= 0; j
< CHARSIZ
; j
++)
3883 for (k
= 0; k
< CHARSIZ
; k
++)
3890 /* copy them to all pw_positions */
3892 for (i
= 1; i
< SP_PW_MAX
; i
++)
3894 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
3897 for (i
= 1; i
< SP_PW_MAX
; i
++)
3899 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
3907 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3909 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3911 for (i
= 0; i
< SP_PW_MAX
; i
++)
3913 root_table_buf_by_pos
[i
] = root_table_ptr
;
3915 root_table_ptr
+= CHARSIZ
;
3918 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3920 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3922 for (i
= 0; i
< SP_PW_MAX
; i
++)
3924 for (j
= 0; j
< CHARSIZ
; j
++)
3926 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3928 markov_table_ptr
+= CHARSIZ
;
3933 * Convert hcstat to tables
3936 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3938 uint key
= i
% CHARSIZ
;
3940 root_table_buf
[i
].key
= key
;
3941 root_table_buf
[i
].val
= root_stats_buf
[i
];
3944 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3946 uint key
= i
% CHARSIZ
;
3948 markov_table_buf
[i
].key
= key
;
3949 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3952 myfree (root_stats_buf
);
3953 myfree (markov_stats_buf
);
3959 for (i
= 0; i
< SP_PW_MAX
; i
++)
3961 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3964 for (i
= 0; i
< SP_PW_MAX
; i
++)
3966 for (j
= 0; j
< CHARSIZ
; j
++)
3968 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3973 void sp_tbl_to_css (hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint threshold
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3976 * Convert tables to css
3979 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
3981 uint pw_pos
= i
/ CHARSIZ
;
3983 cs_t
*cs
= &root_css_buf
[pw_pos
];
3985 if (cs
->cs_len
== threshold
) continue;
3987 uint key
= root_table_buf
[i
].key
;
3989 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
3991 cs
->cs_buf
[cs
->cs_len
] = key
;
3997 * Convert table to css
4000 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4002 uint c
= i
/ CHARSIZ
;
4004 cs_t
*cs
= &markov_css_buf
[c
];
4006 if (cs
->cs_len
== threshold
) continue;
4008 uint pw_pos
= c
/ CHARSIZ
;
4010 uint key
= markov_table_buf
[i
].key
;
4012 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4014 cs
->cs_buf
[cs
->cs_len
] = key
;
4020 for (uint i = 0; i < 8; i++)
4022 for (uint j = 0x20; j < 0x80; j++)
4024 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4026 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4028 for (uint k = 0; k < 10; k++)
4030 printf (" %u\n", ptr->cs_buf[k]);
4037 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4039 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4041 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4051 for (uint j
= 1; j
< CHARSIZ
; j
++)
4061 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4063 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4065 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4067 out
+= CHARSIZ
* CHARSIZ
;
4068 in
+= CHARSIZ
* CHARSIZ
;
4070 for (uint j
= 0; j
< CHARSIZ
; j
++)
4077 for (uint k
= 1; k
< CHARSIZ
; k
++)
4089 * mixed shared functions
4092 void dump_hex (const u8
*s
, const int sz
)
4094 for (int i
= 0; i
< sz
; i
++)
4096 log_info_nn ("%02x ", s
[i
]);
4102 void usage_mini_print (const char *progname
)
4104 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4107 void usage_big_print (const char *progname
)
4109 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4112 char *get_exec_path ()
4114 int exec_path_len
= 1024;
4116 char *exec_path
= (char *) mymalloc (exec_path_len
);
4120 char tmp
[32] = { 0 };
4122 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4124 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4128 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4132 uint size
= exec_path_len
;
4134 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4136 log_error("! executable path buffer too small\n");
4141 const int len
= strlen (exec_path
);
4144 #error Your Operating System is not supported or detected
4152 char *get_install_dir (const char *progname
)
4154 char *install_dir
= mystrdup (progname
);
4155 char *last_slash
= NULL
;
4157 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4161 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4167 install_dir
[0] = '.';
4171 return (install_dir
);
4174 char *get_profile_dir (const char *homedir
)
4176 #define DOT_HASHCAT ".hashcat"
4178 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4180 char *profile_dir
= (char *) mymalloc (len
+ 1);
4182 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4187 char *get_session_dir (const char *profile_dir
)
4189 #define SESSIONS_FOLDER "sessions"
4191 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4193 char *session_dir
= (char *) mymalloc (len
+ 1);
4195 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4200 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4204 FILE *fd
= fopen (filename
, "rb");
4208 log_error ("%s: %s", filename
, strerror (errno
));
4213 #define MAX_KEY_SIZE (1024 * 1024)
4215 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4217 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4223 for (int fpos
= 0; fpos
< nread
; fpos
++)
4225 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4227 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4228 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4229 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4230 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4232 if (kpos
>= 64) kpos
= 0;
4238 void set_cpu_affinity (char *cpu_affinity
)
4241 DWORD_PTR aff_mask
= 0;
4249 char *devices
= strdup (cpu_affinity
);
4251 char *next
= strtok (devices
, ",");
4255 uint cpu_id
= atoi (next
);
4270 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4276 aff_mask
|= 1 << (cpu_id
- 1);
4278 CPU_SET ((cpu_id
- 1), &cpuset
);
4281 } while ((next
= strtok (NULL
, ",")) != NULL
);
4287 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4288 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4290 pthread_t thread
= pthread_self ();
4291 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4295 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4297 char *element
, *end
;
4299 end
= (char *) base
+ nmemb
* size
;
4301 for (element
= (char *) base
; element
< end
; element
+= size
)
4302 if (!compar (element
, key
))
4308 int sort_by_salt (const void *v1
, const void *v2
)
4310 const salt_t
*s1
= (const salt_t
*) v1
;
4311 const salt_t
*s2
= (const salt_t
*) v2
;
4313 const int res1
= s1
->salt_len
- s2
->salt_len
;
4315 if (res1
!= 0) return (res1
);
4317 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4319 if (res2
!= 0) return (res2
);
4327 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4328 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4335 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4336 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4342 int sort_by_salt_buf (const void *v1
, const void *v2
)
4344 const pot_t
*p1
= (const pot_t
*) v1
;
4345 const pot_t
*p2
= (const pot_t
*) v2
;
4347 const hash_t
*h1
= &p1
->hash
;
4348 const hash_t
*h2
= &p2
->hash
;
4350 const salt_t
*s1
= h1
->salt
;
4351 const salt_t
*s2
= h2
->salt
;
4357 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4358 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4364 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4366 const hash_t
*h1
= (const hash_t
*) v1
;
4367 const hash_t
*h2
= (const hash_t
*) v2
;
4369 const salt_t
*s1
= h1
->salt
;
4370 const salt_t
*s2
= h2
->salt
;
4372 // testphase: this should work
4377 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4378 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4381 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4382 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4383 if (s1->salt_len > s2->salt_len) return ( 1);
4384 if (s1->salt_len < s2->salt_len) return (-1);
4386 uint n = s1->salt_len;
4390 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4391 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4398 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4400 const hash_t
*h1
= (const hash_t
*) v1
;
4401 const hash_t
*h2
= (const hash_t
*) v2
;
4403 const salt_t
*s1
= h1
->salt
;
4404 const salt_t
*s2
= h2
->salt
;
4406 // 12 - 2 (since last 2 uints contain the digest)
4411 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4412 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4418 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4420 const hash_t
*h1
= (const hash_t
*) v1
;
4421 const hash_t
*h2
= (const hash_t
*) v2
;
4423 const void *d1
= h1
->digest
;
4424 const void *d2
= h2
->digest
;
4426 return data
.sort_by_digest (d1
, d2
);
4429 int sort_by_hash (const void *v1
, const void *v2
)
4431 const hash_t
*h1
= (const hash_t
*) v1
;
4432 const hash_t
*h2
= (const hash_t
*) v2
;
4436 const salt_t
*s1
= h1
->salt
;
4437 const salt_t
*s2
= h2
->salt
;
4439 int res
= sort_by_salt (s1
, s2
);
4441 if (res
!= 0) return (res
);
4444 const void *d1
= h1
->digest
;
4445 const void *d2
= h2
->digest
;
4447 return data
.sort_by_digest (d1
, d2
);
4450 int sort_by_pot (const void *v1
, const void *v2
)
4452 const pot_t
*p1
= (const pot_t
*) v1
;
4453 const pot_t
*p2
= (const pot_t
*) v2
;
4455 const hash_t
*h1
= &p1
->hash
;
4456 const hash_t
*h2
= &p2
->hash
;
4458 return sort_by_hash (h1
, h2
);
4461 int sort_by_mtime (const void *p1
, const void *p2
)
4463 const char **f1
= (const char **) p1
;
4464 const char **f2
= (const char **) p2
;
4466 struct stat s1
; stat (*f1
, &s1
);
4467 struct stat s2
; stat (*f2
, &s2
);
4469 return s2
.st_mtime
- s1
.st_mtime
;
4472 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4474 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4475 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4477 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4480 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4482 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4483 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4485 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4488 int sort_by_stringptr (const void *p1
, const void *p2
)
4490 const char **s1
= (const char **) p1
;
4491 const char **s2
= (const char **) p2
;
4493 return strcmp (*s1
, *s2
);
4496 int sort_by_dictstat (const void *s1
, const void *s2
)
4498 dictstat_t
*d1
= (dictstat_t
*) s1
;
4499 dictstat_t
*d2
= (dictstat_t
*) s2
;
4502 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4504 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4507 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4510 int sort_by_bitmap (const void *p1
, const void *p2
)
4512 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4513 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4515 return b1
->collisions
- b2
->collisions
;
4518 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4520 const u32
*d1
= (const u32
*) v1
;
4521 const u32
*d2
= (const u32
*) v2
;
4527 if (d1
[n
] > d2
[n
]) return ( 1);
4528 if (d1
[n
] < d2
[n
]) return (-1);
4534 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4536 const u32
*d1
= (const u32
*) v1
;
4537 const u32
*d2
= (const u32
*) v2
;
4543 if (d1
[n
] > d2
[n
]) return ( 1);
4544 if (d1
[n
] < d2
[n
]) return (-1);
4550 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4552 const u32
*d1
= (const u32
*) v1
;
4553 const u32
*d2
= (const u32
*) v2
;
4559 if (d1
[n
] > d2
[n
]) return ( 1);
4560 if (d1
[n
] < d2
[n
]) return (-1);
4566 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4568 const u32
*d1
= (const u32
*) v1
;
4569 const u32
*d2
= (const u32
*) v2
;
4575 if (d1
[n
] > d2
[n
]) return ( 1);
4576 if (d1
[n
] < d2
[n
]) return (-1);
4582 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4584 const u32
*d1
= (const u32
*) v1
;
4585 const u32
*d2
= (const u32
*) v2
;
4591 if (d1
[n
] > d2
[n
]) return ( 1);
4592 if (d1
[n
] < d2
[n
]) return (-1);
4598 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4600 const u32
*d1
= (const u32
*) v1
;
4601 const u32
*d2
= (const u32
*) v2
;
4607 if (d1
[n
] > d2
[n
]) return ( 1);
4608 if (d1
[n
] < d2
[n
]) return (-1);
4614 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4616 const u32
*d1
= (const u32
*) v1
;
4617 const u32
*d2
= (const u32
*) v2
;
4623 if (d1
[n
] > d2
[n
]) return ( 1);
4624 if (d1
[n
] < d2
[n
]) return (-1);
4630 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4632 const u32
*d1
= (const u32
*) v1
;
4633 const u32
*d2
= (const u32
*) v2
;
4639 if (d1
[n
] > d2
[n
]) return ( 1);
4640 if (d1
[n
] < d2
[n
]) return (-1);
4646 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4648 const u64
*d1
= (const u64
*) v1
;
4649 const u64
*d2
= (const u64
*) v2
;
4655 if (d1
[n
] > d2
[n
]) return ( 1);
4656 if (d1
[n
] < d2
[n
]) return (-1);
4662 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4664 const u64
*d1
= (const u64
*) v1
;
4665 const u64
*d2
= (const u64
*) v2
;
4671 if (d1
[n
] > d2
[n
]) return ( 1);
4672 if (d1
[n
] < d2
[n
]) return (-1);
4678 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4680 const u64
*d1
= (const u64
*) v1
;
4681 const u64
*d2
= (const u64
*) v2
;
4687 if (d1
[n
] > d2
[n
]) return ( 1);
4688 if (d1
[n
] < d2
[n
]) return (-1);
4694 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4696 const u32
*d1
= (const u32
*) v1
;
4697 const u32
*d2
= (const u32
*) v2
;
4699 const uint dgst_pos0
= data
.dgst_pos0
;
4700 const uint dgst_pos1
= data
.dgst_pos1
;
4701 const uint dgst_pos2
= data
.dgst_pos2
;
4702 const uint dgst_pos3
= data
.dgst_pos3
;
4704 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4705 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4706 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4707 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4708 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4709 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4710 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4711 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4716 void format_debug (char *debug_file
, uint debug_mode
, unsigned char *orig_plain_ptr
, uint orig_plain_len
, unsigned char *mod_plain_ptr
, uint mod_plain_len
, char *rule_buf
, int rule_len
)
4718 uint outfile_autohex
= data
.outfile_autohex
;
4720 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4722 FILE *debug_fp
= NULL
;
4724 if (debug_file
!= NULL
)
4726 debug_fp
= fopen (debug_file
, "ab");
4728 lock_file (debug_fp
);
4735 if (debug_fp
== NULL
)
4737 log_info ("WARNING: Could not open debug-file for writing");
4741 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4743 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4745 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4748 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4750 if (debug_mode
== 4)
4752 fputc (':', debug_fp
);
4754 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4757 fputc ('\n', debug_fp
);
4759 if (debug_file
!= NULL
) fclose (debug_fp
);
4763 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4765 int needs_hexify
= 0;
4767 if (outfile_autohex
== 1)
4769 for (uint i
= 0; i
< plain_len
; i
++)
4771 if (plain_ptr
[i
] < 0x20)
4778 if (plain_ptr
[i
] > 0x7f)
4787 if (needs_hexify
== 1)
4789 fprintf (fp
, "$HEX[");
4791 for (uint i
= 0; i
< plain_len
; i
++)
4793 fprintf (fp
, "%02x", plain_ptr
[i
]);
4800 fwrite (plain_ptr
, plain_len
, 1, fp
);
4804 void format_output (FILE *out_fp
, char *out_buf
, unsigned char *plain_ptr
, const uint plain_len
, const u64 crackpos
, unsigned char *username
, const uint user_len
)
4806 uint outfile_format
= data
.outfile_format
;
4808 char separator
= data
.separator
;
4810 if (outfile_format
& OUTFILE_FMT_HASH
)
4812 fprintf (out_fp
, "%s", out_buf
);
4814 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4816 fputc (separator
, out_fp
);
4819 else if (data
.username
)
4821 if (username
!= NULL
)
4823 for (uint i
= 0; i
< user_len
; i
++)
4825 fprintf (out_fp
, "%c", username
[i
]);
4828 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4830 fputc (separator
, out_fp
);
4835 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4837 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4839 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4841 fputc (separator
, out_fp
);
4845 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4847 for (uint i
= 0; i
< plain_len
; i
++)
4849 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4852 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4854 fputc (separator
, out_fp
);
4858 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4861 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4866 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
4868 fprintf (out_fp
, "%llu", crackpos
);
4873 fputc ('\n', out_fp
);
4876 void handle_show_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
4880 pot_key
.hash
.salt
= hashes_buf
->salt
;
4881 pot_key
.hash
.digest
= hashes_buf
->digest
;
4883 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4889 input_buf
[input_len
] = 0;
4892 unsigned char *username
= NULL
;
4897 user_t
*user
= hashes_buf
->hash_info
->user
;
4901 username
= (unsigned char *) (user
->user_name
);
4903 user_len
= user
->user_len
;
4907 // do output the line
4908 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
4912 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
4913 #define LM_MASKED_PLAIN "[notfound]"
4915 void handle_show_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
4921 pot_left_key
.hash
.salt
= hash_left
->salt
;
4922 pot_left_key
.hash
.digest
= hash_left
->digest
;
4924 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4928 uint weak_hash_found
= 0;
4930 pot_t pot_right_key
;
4932 pot_right_key
.hash
.salt
= hash_right
->salt
;
4933 pot_right_key
.hash
.digest
= hash_right
->digest
;
4935 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4937 if (pot_right_ptr
== NULL
)
4939 // special case, if "weak hash"
4941 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
4943 weak_hash_found
= 1;
4945 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4947 // in theory this is not needed, but we are paranoia:
4949 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4950 pot_right_ptr
->plain_len
= 0;
4954 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
4956 if (weak_hash_found
== 1) myfree (pot_right_ptr
); // this shouldn't happen at all: if weak_hash_found == 1, than pot_right_ptr is not NULL for sure
4961 // at least one half was found:
4965 input_buf
[input_len
] = 0;
4969 unsigned char *username
= NULL
;
4974 user_t
*user
= hash_left
->hash_info
->user
;
4978 username
= (unsigned char *) (user
->user_name
);
4980 user_len
= user
->user_len
;
4984 // mask the part which was not found
4986 uint left_part_masked
= 0;
4987 uint right_part_masked
= 0;
4989 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
4991 if (pot_left_ptr
== NULL
)
4993 left_part_masked
= 1;
4995 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4997 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
4999 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5000 pot_left_ptr
->plain_len
= mask_plain_len
;
5003 if (pot_right_ptr
== NULL
)
5005 right_part_masked
= 1;
5007 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5009 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5011 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5012 pot_right_ptr
->plain_len
= mask_plain_len
;
5015 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5019 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5021 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5023 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5025 // do output the line
5027 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5029 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5031 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5032 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5035 void handle_left_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5039 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5041 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5043 if (pot_ptr
== NULL
)
5047 input_buf
[input_len
] = 0;
5049 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5053 void handle_left_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5059 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5061 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5065 pot_t pot_right_key
;
5067 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5069 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5071 uint weak_hash_found
= 0;
5073 if (pot_right_ptr
== NULL
)
5075 // special case, if "weak hash"
5077 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5079 weak_hash_found
= 1;
5081 // we just need that pot_right_ptr is not a NULL pointer
5083 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5087 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5089 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5094 // ... at least one part was not cracked
5098 input_buf
[input_len
] = 0;
5100 // only show the hash part which is still not cracked
5102 uint user_len
= input_len
- 32;
5104 char *hash_output
= (char *) mymalloc (33);
5106 memcpy (hash_output
, input_buf
, input_len
);
5108 if (pot_left_ptr
!= NULL
)
5110 // only show right part (because left part was already found)
5112 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5114 hash_output
[user_len
+ 16] = 0;
5117 if (pot_right_ptr
!= NULL
)
5119 // only show left part (because right part was already found)
5121 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5123 hash_output
[user_len
+ 16] = 0;
5126 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5128 myfree (hash_output
);
5130 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5133 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5135 uint opencl_platforms_filter
= 0;
5137 if (opencl_platforms
)
5139 char *platforms
= strdup (opencl_platforms
);
5141 char *next
= strtok (platforms
, ",");
5145 int platform
= atoi (next
);
5147 if (platform
< 1 || platform
> 32)
5149 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5154 opencl_platforms_filter
|= 1 << (platform
- 1);
5156 } while ((next
= strtok (NULL
, ",")) != NULL
);
5162 opencl_platforms_filter
= -1;
5165 return opencl_platforms_filter
;
5168 u32
setup_devices_filter (char *opencl_devices
)
5170 u32 devices_filter
= 0;
5174 char *devices
= strdup (opencl_devices
);
5176 char *next
= strtok (devices
, ",");
5180 int device_id
= atoi (next
);
5182 if (device_id
< 1 || device_id
> 32)
5184 log_error ("ERROR: invalid device_id %u specified", device_id
);
5189 devices_filter
|= 1 << (device_id
- 1);
5191 } while ((next
= strtok (NULL
, ",")) != NULL
);
5197 devices_filter
= -1;
5200 return devices_filter
;
5203 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5205 cl_device_type device_types_filter
= 0;
5207 if (opencl_device_types
)
5209 char *device_types
= strdup (opencl_device_types
);
5211 char *next
= strtok (device_types
, ",");
5215 int device_type
= atoi (next
);
5217 if (device_type
< 1 || device_type
> 3)
5219 log_error ("ERROR: invalid device_type %u specified", device_type
);
5224 device_types_filter
|= 1 << device_type
;
5226 } while ((next
= strtok (NULL
, ",")) != NULL
);
5228 free (device_types
);
5232 // Do not use CPU by default, this often reduces GPU performance because
5233 // the CPU is too busy to handle GPU synchronization
5235 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5238 return device_types_filter
;
5241 u32
get_random_num (const u32 min
, const u32 max
)
5243 if (min
== max
) return (min
);
5245 return ((rand () % (max
- min
)) + min
);
5248 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5250 u32 quotient
= dividend
/ divisor
;
5252 if (dividend
% divisor
) quotient
++;
5257 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5259 u64 quotient
= dividend
/ divisor
;
5261 if (dividend
% divisor
) quotient
++;
5266 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5268 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5269 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5271 if (tm
->tm_year
- 70)
5273 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5274 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5276 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5278 else if (tm
->tm_yday
)
5280 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5281 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5283 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5285 else if (tm
->tm_hour
)
5287 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5288 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5290 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5292 else if (tm
->tm_min
)
5294 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5295 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5297 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5301 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5303 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5307 void format_speed_display (float val
, char *buf
, size_t len
)
5318 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5329 /* generate output */
5333 snprintf (buf
, len
- 1, "%.0f ", val
);
5337 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5341 void lowercase (u8
*buf
, int len
)
5343 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5346 void uppercase (u8
*buf
, int len
)
5348 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5351 int fgetl (FILE *fp
, char *line_buf
)
5357 const int c
= fgetc (fp
);
5359 if (c
== EOF
) break;
5361 line_buf
[line_len
] = (char) c
;
5365 if (line_len
== BUFSIZ
) line_len
--;
5367 if (c
== '\n') break;
5370 if (line_len
== 0) return 0;
5372 if (line_buf
[line_len
- 1] == '\n')
5376 line_buf
[line_len
] = 0;
5379 if (line_len
== 0) return 0;
5381 if (line_buf
[line_len
- 1] == '\r')
5385 line_buf
[line_len
] = 0;
5391 int in_superchop (char *buf
)
5393 int len
= strlen (buf
);
5397 if (buf
[len
- 1] == '\n')
5404 if (buf
[len
- 1] == '\r')
5419 char **scan_directory (const char *path
)
5421 char *tmp_path
= mystrdup (path
);
5423 size_t tmp_path_len
= strlen (tmp_path
);
5425 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5427 tmp_path
[tmp_path_len
- 1] = 0;
5429 tmp_path_len
= strlen (tmp_path
);
5432 char **files
= NULL
;
5438 if ((d
= opendir (tmp_path
)) != NULL
)
5444 memset (&e
, 0, sizeof (e
));
5445 struct dirent
*de
= NULL
;
5447 if (readdir_r (d
, &e
, &de
) != 0)
5449 log_error ("ERROR: readdir_r() failed");
5454 if (de
== NULL
) break;
5458 while ((de
= readdir (d
)) != NULL
)
5461 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5463 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5465 char *path_file
= (char *) mymalloc (path_size
+ 1);
5467 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5469 path_file
[path_size
] = 0;
5473 if ((d_test
= opendir (path_file
)) != NULL
)
5481 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5485 files
[num_files
- 1] = path_file
;
5491 else if (errno
== ENOTDIR
)
5493 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5497 files
[num_files
- 1] = mystrdup (path
);
5500 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5504 files
[num_files
- 1] = NULL
;
5511 int count_dictionaries (char **dictionary_files
)
5513 if (dictionary_files
== NULL
) return 0;
5517 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5525 char *stroptitype (const uint opti_type
)
5529 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5530 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5531 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5532 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5533 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5534 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5535 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5536 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5537 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5538 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5539 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5540 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5541 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5542 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5548 char *strparser (const uint parser_status
)
5550 switch (parser_status
)
5552 case PARSER_OK
: return ((char *) PA_000
); break;
5553 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5554 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5555 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5556 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5557 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5558 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5559 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5560 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5561 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5562 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5563 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5564 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5565 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5566 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5567 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5568 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5571 return ((char *) PA_255
);
5574 char *strhashtype (const uint hash_mode
)
5578 case 0: return ((char *) HT_00000
); break;
5579 case 10: return ((char *) HT_00010
); break;
5580 case 11: return ((char *) HT_00011
); break;
5581 case 12: return ((char *) HT_00012
); break;
5582 case 20: return ((char *) HT_00020
); break;
5583 case 21: return ((char *) HT_00021
); break;
5584 case 22: return ((char *) HT_00022
); break;
5585 case 23: return ((char *) HT_00023
); break;
5586 case 30: return ((char *) HT_00030
); break;
5587 case 40: return ((char *) HT_00040
); break;
5588 case 50: return ((char *) HT_00050
); break;
5589 case 60: return ((char *) HT_00060
); break;
5590 case 100: return ((char *) HT_00100
); break;
5591 case 101: return ((char *) HT_00101
); break;
5592 case 110: return ((char *) HT_00110
); break;
5593 case 111: return ((char *) HT_00111
); break;
5594 case 112: return ((char *) HT_00112
); break;
5595 case 120: return ((char *) HT_00120
); break;
5596 case 121: return ((char *) HT_00121
); break;
5597 case 122: return ((char *) HT_00122
); break;
5598 case 124: return ((char *) HT_00124
); break;
5599 case 130: return ((char *) HT_00130
); break;
5600 case 131: return ((char *) HT_00131
); break;
5601 case 132: return ((char *) HT_00132
); break;
5602 case 133: return ((char *) HT_00133
); break;
5603 case 140: return ((char *) HT_00140
); break;
5604 case 141: return ((char *) HT_00141
); break;
5605 case 150: return ((char *) HT_00150
); break;
5606 case 160: return ((char *) HT_00160
); break;
5607 case 190: return ((char *) HT_00190
); break;
5608 case 200: return ((char *) HT_00200
); break;
5609 case 300: return ((char *) HT_00300
); break;
5610 case 400: return ((char *) HT_00400
); break;
5611 case 500: return ((char *) HT_00500
); break;
5612 case 501: return ((char *) HT_00501
); break;
5613 case 900: return ((char *) HT_00900
); break;
5614 case 910: return ((char *) HT_00910
); break;
5615 case 1000: return ((char *) HT_01000
); break;
5616 case 1100: return ((char *) HT_01100
); break;
5617 case 1400: return ((char *) HT_01400
); break;
5618 case 1410: return ((char *) HT_01410
); break;
5619 case 1420: return ((char *) HT_01420
); break;
5620 case 1421: return ((char *) HT_01421
); break;
5621 case 1430: return ((char *) HT_01430
); break;
5622 case 1440: return ((char *) HT_01440
); break;
5623 case 1441: return ((char *) HT_01441
); break;
5624 case 1450: return ((char *) HT_01450
); break;
5625 case 1460: return ((char *) HT_01460
); break;
5626 case 1500: return ((char *) HT_01500
); break;
5627 case 1600: return ((char *) HT_01600
); break;
5628 case 1700: return ((char *) HT_01700
); break;
5629 case 1710: return ((char *) HT_01710
); break;
5630 case 1711: return ((char *) HT_01711
); break;
5631 case 1720: return ((char *) HT_01720
); break;
5632 case 1722: return ((char *) HT_01722
); break;
5633 case 1730: return ((char *) HT_01730
); break;
5634 case 1731: return ((char *) HT_01731
); break;
5635 case 1740: return ((char *) HT_01740
); break;
5636 case 1750: return ((char *) HT_01750
); break;
5637 case 1760: return ((char *) HT_01760
); break;
5638 case 1800: return ((char *) HT_01800
); break;
5639 case 2100: return ((char *) HT_02100
); break;
5640 case 2400: return ((char *) HT_02400
); break;
5641 case 2410: return ((char *) HT_02410
); break;
5642 case 2500: return ((char *) HT_02500
); break;
5643 case 2600: return ((char *) HT_02600
); break;
5644 case 2611: return ((char *) HT_02611
); break;
5645 case 2612: return ((char *) HT_02612
); break;
5646 case 2711: return ((char *) HT_02711
); break;
5647 case 2811: return ((char *) HT_02811
); break;
5648 case 3000: return ((char *) HT_03000
); break;
5649 case 3100: return ((char *) HT_03100
); break;
5650 case 3200: return ((char *) HT_03200
); break;
5651 case 3710: return ((char *) HT_03710
); break;
5652 case 3711: return ((char *) HT_03711
); break;
5653 case 3800: return ((char *) HT_03800
); break;
5654 case 4300: return ((char *) HT_04300
); break;
5655 case 4400: return ((char *) HT_04400
); break;
5656 case 4500: return ((char *) HT_04500
); break;
5657 case 4700: return ((char *) HT_04700
); break;
5658 case 4800: return ((char *) HT_04800
); break;
5659 case 4900: return ((char *) HT_04900
); break;
5660 case 5000: return ((char *) HT_05000
); break;
5661 case 5100: return ((char *) HT_05100
); break;
5662 case 5200: return ((char *) HT_05200
); break;
5663 case 5300: return ((char *) HT_05300
); break;
5664 case 5400: return ((char *) HT_05400
); break;
5665 case 5500: return ((char *) HT_05500
); break;
5666 case 5600: return ((char *) HT_05600
); break;
5667 case 5700: return ((char *) HT_05700
); break;
5668 case 5800: return ((char *) HT_05800
); break;
5669 case 6000: return ((char *) HT_06000
); break;
5670 case 6100: return ((char *) HT_06100
); break;
5671 case 6211: return ((char *) HT_06211
); break;
5672 case 6212: return ((char *) HT_06212
); break;
5673 case 6213: return ((char *) HT_06213
); break;
5674 case 6221: return ((char *) HT_06221
); break;
5675 case 6222: return ((char *) HT_06222
); break;
5676 case 6223: return ((char *) HT_06223
); break;
5677 case 6231: return ((char *) HT_06231
); break;
5678 case 6232: return ((char *) HT_06232
); break;
5679 case 6233: return ((char *) HT_06233
); break;
5680 case 6241: return ((char *) HT_06241
); break;
5681 case 6242: return ((char *) HT_06242
); break;
5682 case 6243: return ((char *) HT_06243
); break;
5683 case 6300: return ((char *) HT_06300
); break;
5684 case 6400: return ((char *) HT_06400
); break;
5685 case 6500: return ((char *) HT_06500
); break;
5686 case 6600: return ((char *) HT_06600
); break;
5687 case 6700: return ((char *) HT_06700
); break;
5688 case 6800: return ((char *) HT_06800
); break;
5689 case 6900: return ((char *) HT_06900
); break;
5690 case 7100: return ((char *) HT_07100
); break;
5691 case 7200: return ((char *) HT_07200
); break;
5692 case 7300: return ((char *) HT_07300
); break;
5693 case 7400: return ((char *) HT_07400
); break;
5694 case 7500: return ((char *) HT_07500
); break;
5695 case 7600: return ((char *) HT_07600
); break;
5696 case 7700: return ((char *) HT_07700
); break;
5697 case 7800: return ((char *) HT_07800
); break;
5698 case 7900: return ((char *) HT_07900
); break;
5699 case 8000: return ((char *) HT_08000
); break;
5700 case 8100: return ((char *) HT_08100
); break;
5701 case 8200: return ((char *) HT_08200
); break;
5702 case 8300: return ((char *) HT_08300
); break;
5703 case 8400: return ((char *) HT_08400
); break;
5704 case 8500: return ((char *) HT_08500
); break;
5705 case 8600: return ((char *) HT_08600
); break;
5706 case 8700: return ((char *) HT_08700
); break;
5707 case 8800: return ((char *) HT_08800
); break;
5708 case 8900: return ((char *) HT_08900
); break;
5709 case 9000: return ((char *) HT_09000
); break;
5710 case 9100: return ((char *) HT_09100
); break;
5711 case 9200: return ((char *) HT_09200
); break;
5712 case 9300: return ((char *) HT_09300
); break;
5713 case 9400: return ((char *) HT_09400
); break;
5714 case 9500: return ((char *) HT_09500
); break;
5715 case 9600: return ((char *) HT_09600
); break;
5716 case 9700: return ((char *) HT_09700
); break;
5717 case 9710: return ((char *) HT_09710
); break;
5718 case 9720: return ((char *) HT_09720
); break;
5719 case 9800: return ((char *) HT_09800
); break;
5720 case 9810: return ((char *) HT_09810
); break;
5721 case 9820: return ((char *) HT_09820
); break;
5722 case 9900: return ((char *) HT_09900
); break;
5723 case 10000: return ((char *) HT_10000
); break;
5724 case 10100: return ((char *) HT_10100
); break;
5725 case 10200: return ((char *) HT_10200
); break;
5726 case 10300: return ((char *) HT_10300
); break;
5727 case 10400: return ((char *) HT_10400
); break;
5728 case 10410: return ((char *) HT_10410
); break;
5729 case 10420: return ((char *) HT_10420
); break;
5730 case 10500: return ((char *) HT_10500
); break;
5731 case 10600: return ((char *) HT_10600
); break;
5732 case 10700: return ((char *) HT_10700
); break;
5733 case 10800: return ((char *) HT_10800
); break;
5734 case 10900: return ((char *) HT_10900
); break;
5735 case 11000: return ((char *) HT_11000
); break;
5736 case 11100: return ((char *) HT_11100
); break;
5737 case 11200: return ((char *) HT_11200
); break;
5738 case 11300: return ((char *) HT_11300
); break;
5739 case 11400: return ((char *) HT_11400
); break;
5740 case 11500: return ((char *) HT_11500
); break;
5741 case 11600: return ((char *) HT_11600
); break;
5742 case 11700: return ((char *) HT_11700
); break;
5743 case 11800: return ((char *) HT_11800
); break;
5744 case 11900: return ((char *) HT_11900
); break;
5745 case 12000: return ((char *) HT_12000
); break;
5746 case 12100: return ((char *) HT_12100
); break;
5747 case 12200: return ((char *) HT_12200
); break;
5748 case 12300: return ((char *) HT_12300
); break;
5749 case 12400: return ((char *) HT_12400
); break;
5750 case 12500: return ((char *) HT_12500
); break;
5751 case 12600: return ((char *) HT_12600
); break;
5752 case 12700: return ((char *) HT_12700
); break;
5753 case 12800: return ((char *) HT_12800
); break;
5754 case 12900: return ((char *) HT_12900
); break;
5755 case 13000: return ((char *) HT_13000
); break;
5758 return ((char *) "Unknown");
5761 char *strstatus (const uint devices_status
)
5763 switch (devices_status
)
5765 case STATUS_INIT
: return ((char *) ST_0000
); break;
5766 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5767 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5768 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5769 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5770 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5771 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5772 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5773 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5774 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5777 return ((char *) "Unknown");
5780 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5782 uint hash_type
= data
.hash_type
;
5783 uint hash_mode
= data
.hash_mode
;
5784 uint salt_type
= data
.salt_type
;
5785 uint opts_type
= data
.opts_type
;
5786 uint opti_type
= data
.opti_type
;
5787 uint dgst_size
= data
.dgst_size
;
5789 char *hashfile
= data
.hashfile
;
5793 uint digest_buf
[64] = { 0 };
5795 u64
*digest_buf64
= (u64
*) digest_buf
;
5797 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5799 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5801 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5807 case HASH_TYPE_DESCRYPT
:
5808 FP (digest_buf
[1], digest_buf
[0], tt
);
5811 case HASH_TYPE_DESRACF
:
5812 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5813 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5815 FP (digest_buf
[1], digest_buf
[0], tt
);
5819 FP (digest_buf
[1], digest_buf
[0], tt
);
5822 case HASH_TYPE_NETNTLM
:
5823 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5824 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5825 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5826 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5828 FP (digest_buf
[1], digest_buf
[0], tt
);
5829 FP (digest_buf
[3], digest_buf
[2], tt
);
5832 case HASH_TYPE_BSDICRYPT
:
5833 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5834 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5836 FP (digest_buf
[1], digest_buf
[0], tt
);
5841 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5846 digest_buf
[0] += MD4M_A
;
5847 digest_buf
[1] += MD4M_B
;
5848 digest_buf
[2] += MD4M_C
;
5849 digest_buf
[3] += MD4M_D
;
5853 digest_buf
[0] += MD5M_A
;
5854 digest_buf
[1] += MD5M_B
;
5855 digest_buf
[2] += MD5M_C
;
5856 digest_buf
[3] += MD5M_D
;
5859 case HASH_TYPE_SHA1
:
5860 digest_buf
[0] += SHA1M_A
;
5861 digest_buf
[1] += SHA1M_B
;
5862 digest_buf
[2] += SHA1M_C
;
5863 digest_buf
[3] += SHA1M_D
;
5864 digest_buf
[4] += SHA1M_E
;
5867 case HASH_TYPE_SHA256
:
5868 digest_buf
[0] += SHA256M_A
;
5869 digest_buf
[1] += SHA256M_B
;
5870 digest_buf
[2] += SHA256M_C
;
5871 digest_buf
[3] += SHA256M_D
;
5872 digest_buf
[4] += SHA256M_E
;
5873 digest_buf
[5] += SHA256M_F
;
5874 digest_buf
[6] += SHA256M_G
;
5875 digest_buf
[7] += SHA256M_H
;
5878 case HASH_TYPE_SHA384
:
5879 digest_buf64
[0] += SHA384M_A
;
5880 digest_buf64
[1] += SHA384M_B
;
5881 digest_buf64
[2] += SHA384M_C
;
5882 digest_buf64
[3] += SHA384M_D
;
5883 digest_buf64
[4] += SHA384M_E
;
5884 digest_buf64
[5] += SHA384M_F
;
5885 digest_buf64
[6] += 0;
5886 digest_buf64
[7] += 0;
5889 case HASH_TYPE_SHA512
:
5890 digest_buf64
[0] += SHA512M_A
;
5891 digest_buf64
[1] += SHA512M_B
;
5892 digest_buf64
[2] += SHA512M_C
;
5893 digest_buf64
[3] += SHA512M_D
;
5894 digest_buf64
[4] += SHA512M_E
;
5895 digest_buf64
[5] += SHA512M_F
;
5896 digest_buf64
[6] += SHA512M_G
;
5897 digest_buf64
[7] += SHA512M_H
;
5902 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
5904 if (dgst_size
== DGST_SIZE_4_2
)
5906 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5908 else if (dgst_size
== DGST_SIZE_4_4
)
5910 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5912 else if (dgst_size
== DGST_SIZE_4_5
)
5914 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5916 else if (dgst_size
== DGST_SIZE_4_6
)
5918 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5920 else if (dgst_size
== DGST_SIZE_4_8
)
5922 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5924 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
5926 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
5928 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5930 else if (hash_type
== HASH_TYPE_SHA384
)
5932 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5934 else if (hash_type
== HASH_TYPE_SHA512
)
5936 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5938 else if (hash_type
== HASH_TYPE_GOST
)
5940 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5943 else if (dgst_size
== DGST_SIZE_4_64
)
5945 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5947 else if (dgst_size
== DGST_SIZE_8_25
)
5949 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5953 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
5954 | (data
.salt_type
== SALT_TYPE_EXTERN
)
5955 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
5961 memset (&salt
, 0, sizeof (salt_t
));
5963 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
5965 char *ptr
= (char *) salt
.salt_buf
;
5967 uint len
= salt
.salt_len
;
5969 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5975 case HASH_TYPE_NETNTLM
:
5977 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
5978 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
5980 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
5986 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
5988 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
5996 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
5998 uint max
= salt
.salt_len
/ 4;
6002 for (uint i
= 0; i
< max
; i
++)
6004 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6008 if (opts_type
& OPTS_TYPE_ST_HEX
)
6010 char tmp
[64] = { 0 };
6012 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6014 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6019 memcpy (ptr
, tmp
, len
);
6022 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6024 memset (ptr
+ len
, 0, memset_size
);
6026 salt
.salt_len
= len
;
6030 // some modes require special encoding
6033 uint out_buf_plain
[256] = { 0 };
6034 uint out_buf_salt
[256] = { 0 };
6036 char tmp_buf
[1024] = { 0 };
6038 char *ptr_plain
= (char *) out_buf_plain
;
6039 char *ptr_salt
= (char *) out_buf_salt
;
6041 if (hash_mode
== 22)
6043 char username
[30] = { 0 };
6045 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6047 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6049 u16
*ptr
= (u16
*) digest_buf
;
6051 tmp_buf
[ 0] = sig
[0];
6052 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6053 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6054 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6055 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6056 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6057 tmp_buf
[ 6] = sig
[1];
6058 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6059 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6060 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6061 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6062 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6063 tmp_buf
[12] = sig
[2];
6064 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6065 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6066 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6067 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6068 tmp_buf
[17] = sig
[3];
6069 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6070 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6071 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6072 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6073 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6074 tmp_buf
[23] = sig
[4];
6075 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6076 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6077 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6078 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6079 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6080 tmp_buf
[29] = sig
[5];
6082 snprintf (out_buf
, len
-1, "%s:%s",
6086 else if (hash_mode
== 23)
6088 // do not show the \nskyper\n part in output
6090 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6092 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6094 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6101 else if (hash_mode
== 101)
6103 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6105 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6106 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6107 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6108 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6109 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6111 memcpy (tmp_buf
, digest_buf
, 20);
6113 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6115 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6117 else if (hash_mode
== 111)
6119 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6121 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6122 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6123 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6124 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6125 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6127 memcpy (tmp_buf
, digest_buf
, 20);
6128 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6130 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6132 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6134 else if (hash_mode
== 122)
6136 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6137 (char *) salt
.salt_buf
,
6144 else if (hash_mode
== 124)
6146 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6147 (char *) salt
.salt_buf
,
6154 else if (hash_mode
== 131)
6156 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6157 (char *) salt
.salt_buf
,
6165 else if (hash_mode
== 132)
6167 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6168 (char *) salt
.salt_buf
,
6175 else if (hash_mode
== 133)
6177 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6179 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6180 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6181 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6182 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6183 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6185 memcpy (tmp_buf
, digest_buf
, 20);
6187 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6189 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6191 else if (hash_mode
== 141)
6193 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6195 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6197 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6199 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6201 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6202 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6203 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6204 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6205 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6207 memcpy (tmp_buf
, digest_buf
, 20);
6209 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6213 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6215 else if (hash_mode
== 400)
6217 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6219 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6220 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6221 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6222 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6224 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6226 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6228 else if (hash_mode
== 500)
6230 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6232 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6233 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6234 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6235 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6237 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6239 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6241 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6245 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6248 else if (hash_mode
== 501)
6250 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6252 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6253 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6255 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6257 else if (hash_mode
== 1421)
6259 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6261 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6277 else if (hash_mode
== 1441)
6279 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6281 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6283 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6285 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6287 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6288 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6289 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6290 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6291 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6292 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6293 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6294 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6296 memcpy (tmp_buf
, digest_buf
, 32);
6298 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6302 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6304 else if (hash_mode
== 1500)
6306 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6307 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6308 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6309 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6310 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6312 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6314 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6316 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6317 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6319 memcpy (tmp_buf
, digest_buf
, 8);
6321 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6323 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6327 else if (hash_mode
== 1600)
6329 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6331 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6332 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6333 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6334 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6336 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6338 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6340 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6344 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6347 else if (hash_mode
== 1711)
6349 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6351 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6352 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6353 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6354 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6355 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6356 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6357 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6358 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6360 memcpy (tmp_buf
, digest_buf
, 64);
6361 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6363 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6365 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6367 else if (hash_mode
== 1722)
6369 uint
*ptr
= digest_buf
;
6371 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6372 (unsigned char *) salt
.salt_buf
,
6382 else if (hash_mode
== 1731)
6384 uint
*ptr
= digest_buf
;
6386 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6387 (unsigned char *) salt
.salt_buf
,
6397 else if (hash_mode
== 1800)
6401 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6402 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6403 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6404 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6405 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6406 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6407 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6408 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6410 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6412 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6414 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6418 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6421 else if (hash_mode
== 2100)
6425 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6427 salt
.salt_iter
+ 1);
6429 uint signature_len
= strlen (out_buf
);
6431 pos
+= signature_len
;
6432 len
-= signature_len
;
6434 char *salt_ptr
= (char *) salt
.salt_buf
;
6436 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6438 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6439 byte_swap_32 (digest_buf
[0]),
6440 byte_swap_32 (digest_buf
[1]),
6441 byte_swap_32 (digest_buf
[2]),
6442 byte_swap_32 (digest_buf
[3]));
6444 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6446 memcpy (tmp_buf
, digest_buf
, 16);
6448 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6450 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6451 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6452 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6453 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6455 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6456 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6457 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6458 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6460 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6461 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6462 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6463 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6465 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6466 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6467 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6468 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6470 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6471 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6472 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6473 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6477 else if (hash_mode
== 2500)
6479 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6481 wpa_t
*wpa
= &wpas
[salt_pos
];
6483 uint pke
[25] = { 0 };
6485 char *pke_ptr
= (char *) pke
;
6487 for (uint i
= 0; i
< 25; i
++)
6489 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6492 unsigned char mac1
[6] = { 0 };
6493 unsigned char mac2
[6] = { 0 };
6495 memcpy (mac1
, pke_ptr
+ 23, 6);
6496 memcpy (mac2
, pke_ptr
+ 29, 6);
6498 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6499 (char *) salt
.salt_buf
,
6513 else if (hash_mode
== 4400)
6515 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6516 byte_swap_32 (digest_buf
[0]),
6517 byte_swap_32 (digest_buf
[1]),
6518 byte_swap_32 (digest_buf
[2]),
6519 byte_swap_32 (digest_buf
[3]));
6521 else if (hash_mode
== 4700)
6523 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6524 byte_swap_32 (digest_buf
[0]),
6525 byte_swap_32 (digest_buf
[1]),
6526 byte_swap_32 (digest_buf
[2]),
6527 byte_swap_32 (digest_buf
[3]),
6528 byte_swap_32 (digest_buf
[4]));
6530 else if (hash_mode
== 4800)
6532 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6534 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6539 byte_swap_32 (salt
.salt_buf
[0]),
6540 byte_swap_32 (salt
.salt_buf
[1]),
6541 byte_swap_32 (salt
.salt_buf
[2]),
6542 byte_swap_32 (salt
.salt_buf
[3]),
6545 else if (hash_mode
== 4900)
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
== 5100)
6556 snprintf (out_buf
, len
-1, "%08x%08x",
6560 else if (hash_mode
== 5200)
6562 snprintf (out_buf
, len
-1, "%s", hashfile
);
6564 else if (hash_mode
== 5300)
6566 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6568 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6570 int buf_len
= len
-1;
6574 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6576 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6578 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6580 snprintf (out_buf
, buf_len
, ":");
6586 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6594 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6596 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6598 if ((i
== 0) || (i
== 5))
6600 snprintf (out_buf
, buf_len
, ":");
6606 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6614 for (uint i
= 0; i
< 4; i
++)
6618 snprintf (out_buf
, buf_len
, ":");
6624 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6630 else if (hash_mode
== 5400)
6632 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6634 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6636 int buf_len
= len
-1;
6640 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6642 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6644 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6646 snprintf (out_buf
, buf_len
, ":");
6652 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6660 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6662 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6664 if ((i
== 0) || (i
== 5))
6666 snprintf (out_buf
, buf_len
, ":");
6672 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6680 for (uint i
= 0; i
< 5; i
++)
6684 snprintf (out_buf
, buf_len
, ":");
6690 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6696 else if (hash_mode
== 5500)
6698 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6700 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6702 char user_buf
[64] = { 0 };
6703 char domain_buf
[64] = { 0 };
6704 char srvchall_buf
[1024] = { 0 };
6705 char clichall_buf
[1024] = { 0 };
6707 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6709 char *ptr
= (char *) netntlm
->userdomain_buf
;
6711 user_buf
[i
] = ptr
[j
];
6714 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6716 char *ptr
= (char *) netntlm
->userdomain_buf
;
6718 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6721 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6723 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6725 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6728 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6730 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6732 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6735 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6743 byte_swap_32 (salt
.salt_buf_pc
[0]),
6744 byte_swap_32 (salt
.salt_buf_pc
[1]),
6747 else if (hash_mode
== 5600)
6749 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6751 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6753 char user_buf
[64] = { 0 };
6754 char domain_buf
[64] = { 0 };
6755 char srvchall_buf
[1024] = { 0 };
6756 char clichall_buf
[1024] = { 0 };
6758 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6760 char *ptr
= (char *) netntlm
->userdomain_buf
;
6762 user_buf
[i
] = ptr
[j
];
6765 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6767 char *ptr
= (char *) netntlm
->userdomain_buf
;
6769 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6772 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6774 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6776 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6779 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6781 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6783 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6786 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6796 else if (hash_mode
== 5700)
6798 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6800 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6801 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6802 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6803 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6804 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6805 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6806 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6807 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6809 memcpy (tmp_buf
, digest_buf
, 32);
6811 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6815 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6817 else if (hash_mode
== 5800)
6819 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6820 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6821 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6822 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6823 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6825 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6832 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6834 snprintf (out_buf
, len
-1, "%s", hashfile
);
6836 else if (hash_mode
== 6300)
6838 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6840 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6841 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6842 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6843 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6845 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6847 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6849 else if (hash_mode
== 6400)
6851 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6853 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6855 else if (hash_mode
== 6500)
6857 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6859 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6861 else if (hash_mode
== 6600)
6863 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6865 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6867 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6868 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6870 uint buf_len
= len
- 1;
6872 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6875 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6877 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6882 else if (hash_mode
== 6700)
6884 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6886 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6888 else if (hash_mode
== 6800)
6890 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6892 else if (hash_mode
== 7100)
6894 uint
*ptr
= digest_buf
;
6896 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6898 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6900 uint esalt
[8] = { 0 };
6902 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6903 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6904 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6905 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6906 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6907 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6908 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6909 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6911 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",
6912 SIGNATURE_SHA512OSX
,
6914 esalt
[ 0], esalt
[ 1],
6915 esalt
[ 2], esalt
[ 3],
6916 esalt
[ 4], esalt
[ 5],
6917 esalt
[ 6], esalt
[ 7],
6925 ptr
[15], ptr
[14]);
6927 else if (hash_mode
== 7200)
6929 uint
*ptr
= digest_buf
;
6931 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6933 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6937 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
6939 len_used
= strlen (out_buf
);
6941 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
6943 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
6945 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
6948 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",
6956 ptr
[15], ptr
[14]);
6958 else if (hash_mode
== 7300)
6960 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
6962 rakp_t
*rakp
= &rakps
[salt_pos
];
6964 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
6966 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
6969 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
6976 else if (hash_mode
== 7400)
6978 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6980 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6981 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6982 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6983 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6984 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6985 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6986 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6987 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6989 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6991 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
6993 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6997 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7000 else if (hash_mode
== 7500)
7002 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7004 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7006 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7007 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7009 char data
[128] = { 0 };
7011 char *ptr_data
= data
;
7013 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7015 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7018 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7020 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7025 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7027 (char *) krb5pa
->user
,
7028 (char *) krb5pa
->realm
,
7029 (char *) krb5pa
->salt
,
7032 else if (hash_mode
== 7700)
7034 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7035 (char *) salt
.salt_buf
,
7039 else if (hash_mode
== 7800)
7041 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7042 (char *) salt
.salt_buf
,
7049 else if (hash_mode
== 7900)
7051 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7055 char *tmp
= (char *) salt
.salt_buf_pc
;
7057 ptr_plain
[42] = tmp
[0];
7063 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7065 else if (hash_mode
== 8000)
7067 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7068 (unsigned char *) salt
.salt_buf
,
7078 else if (hash_mode
== 8100)
7080 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7081 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7083 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7084 (unsigned char *) salt
.salt_buf
,
7091 else if (hash_mode
== 8200)
7093 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7095 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7097 char data_buf
[4096] = { 0 };
7099 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7101 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7104 data_buf
[cloudkey
->data_len
* 2] = 0;
7106 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7107 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7108 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7109 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7110 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7111 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7112 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7113 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7115 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7116 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7117 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7118 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7120 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7136 else if (hash_mode
== 8300)
7138 char digest_buf_c
[34] = { 0 };
7140 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7142 digest_buf_c
[32] = 0;
7146 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7148 char domain_buf_c
[33] = { 0 };
7150 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7152 for (uint i
= 0; i
< salt_pc_len
; i
++)
7154 const char next
= domain_buf_c
[i
];
7156 domain_buf_c
[i
] = '.';
7161 domain_buf_c
[salt_pc_len
] = 0;
7165 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7167 else if (hash_mode
== 8500)
7169 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7171 else if (hash_mode
== 2612)
7173 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7175 (char *) salt
.salt_buf
,
7181 else if (hash_mode
== 3711)
7183 char *salt_ptr
= (char *) salt
.salt_buf
;
7185 salt_ptr
[salt
.salt_len
- 1] = 0;
7187 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7188 SIGNATURE_MEDIAWIKI_B
,
7195 else if (hash_mode
== 8800)
7197 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7199 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7201 char tmp
[3073] = { 0 };
7203 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7205 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7210 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7211 SIGNATURE_ANDROIDFDE
,
7212 byte_swap_32 (salt
.salt_buf
[0]),
7213 byte_swap_32 (salt
.salt_buf
[1]),
7214 byte_swap_32 (salt
.salt_buf
[2]),
7215 byte_swap_32 (salt
.salt_buf
[3]),
7216 byte_swap_32 (digest_buf
[0]),
7217 byte_swap_32 (digest_buf
[1]),
7218 byte_swap_32 (digest_buf
[2]),
7219 byte_swap_32 (digest_buf
[3]),
7222 else if (hash_mode
== 8900)
7224 uint N
= salt
.scrypt_N
;
7225 uint r
= salt
.scrypt_r
;
7226 uint p
= salt
.scrypt_p
;
7228 char base64_salt
[32] = { 0 };
7230 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7232 memset (tmp_buf
, 0, 46);
7234 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7235 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7236 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7237 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7238 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7239 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7240 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7241 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7242 digest_buf
[8] = 0; // needed for base64_encode ()
7244 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7246 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7254 else if (hash_mode
== 9000)
7256 snprintf (out_buf
, len
-1, "%s", hashfile
);
7258 else if (hash_mode
== 9200)
7262 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7264 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7266 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7270 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7271 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7272 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7273 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7274 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7275 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7276 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7277 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7278 digest_buf
[8] = 0; // needed for base64_encode ()
7280 char tmp_buf
[64] = { 0 };
7282 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7283 tmp_buf
[43] = 0; // cut it here
7287 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7289 else if (hash_mode
== 9300)
7291 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7292 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7293 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7294 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7295 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7296 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7297 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7298 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7299 digest_buf
[8] = 0; // needed for base64_encode ()
7301 char tmp_buf
[64] = { 0 };
7303 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7304 tmp_buf
[43] = 0; // cut it here
7306 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7308 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7310 else if (hash_mode
== 9400)
7312 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7314 office2007_t
*office2007
= &office2007s
[salt_pos
];
7316 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7317 SIGNATURE_OFFICE2007
,
7320 office2007
->keySize
,
7326 office2007
->encryptedVerifier
[0],
7327 office2007
->encryptedVerifier
[1],
7328 office2007
->encryptedVerifier
[2],
7329 office2007
->encryptedVerifier
[3],
7330 office2007
->encryptedVerifierHash
[0],
7331 office2007
->encryptedVerifierHash
[1],
7332 office2007
->encryptedVerifierHash
[2],
7333 office2007
->encryptedVerifierHash
[3],
7334 office2007
->encryptedVerifierHash
[4]);
7336 else if (hash_mode
== 9500)
7338 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7340 office2010_t
*office2010
= &office2010s
[salt_pos
];
7342 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,
7348 office2010
->encryptedVerifier
[0],
7349 office2010
->encryptedVerifier
[1],
7350 office2010
->encryptedVerifier
[2],
7351 office2010
->encryptedVerifier
[3],
7352 office2010
->encryptedVerifierHash
[0],
7353 office2010
->encryptedVerifierHash
[1],
7354 office2010
->encryptedVerifierHash
[2],
7355 office2010
->encryptedVerifierHash
[3],
7356 office2010
->encryptedVerifierHash
[4],
7357 office2010
->encryptedVerifierHash
[5],
7358 office2010
->encryptedVerifierHash
[6],
7359 office2010
->encryptedVerifierHash
[7]);
7361 else if (hash_mode
== 9600)
7363 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7365 office2013_t
*office2013
= &office2013s
[salt_pos
];
7367 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,
7373 office2013
->encryptedVerifier
[0],
7374 office2013
->encryptedVerifier
[1],
7375 office2013
->encryptedVerifier
[2],
7376 office2013
->encryptedVerifier
[3],
7377 office2013
->encryptedVerifierHash
[0],
7378 office2013
->encryptedVerifierHash
[1],
7379 office2013
->encryptedVerifierHash
[2],
7380 office2013
->encryptedVerifierHash
[3],
7381 office2013
->encryptedVerifierHash
[4],
7382 office2013
->encryptedVerifierHash
[5],
7383 office2013
->encryptedVerifierHash
[6],
7384 office2013
->encryptedVerifierHash
[7]);
7386 else if (hash_mode
== 9700)
7388 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7390 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7392 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7393 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7394 byte_swap_32 (salt
.salt_buf
[0]),
7395 byte_swap_32 (salt
.salt_buf
[1]),
7396 byte_swap_32 (salt
.salt_buf
[2]),
7397 byte_swap_32 (salt
.salt_buf
[3]),
7398 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7399 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7400 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7401 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7402 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7403 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7404 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7405 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7407 else if (hash_mode
== 9710)
7409 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7411 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7413 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7414 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7415 byte_swap_32 (salt
.salt_buf
[0]),
7416 byte_swap_32 (salt
.salt_buf
[1]),
7417 byte_swap_32 (salt
.salt_buf
[2]),
7418 byte_swap_32 (salt
.salt_buf
[3]),
7419 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7420 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7421 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7422 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7423 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7424 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7425 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7426 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7428 else if (hash_mode
== 9720)
7430 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7432 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7434 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7436 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7437 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7438 byte_swap_32 (salt
.salt_buf
[0]),
7439 byte_swap_32 (salt
.salt_buf
[1]),
7440 byte_swap_32 (salt
.salt_buf
[2]),
7441 byte_swap_32 (salt
.salt_buf
[3]),
7442 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7443 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7444 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7445 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7446 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7447 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7448 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7449 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7456 else if (hash_mode
== 9800)
7458 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7460 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7462 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7463 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7468 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7469 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7470 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7471 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7472 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7473 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7474 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7475 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7476 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7478 else if (hash_mode
== 9810)
7480 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7482 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7484 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7485 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7490 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7491 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7492 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7493 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7494 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7495 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7496 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7497 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7498 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7500 else if (hash_mode
== 9820)
7502 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7504 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7506 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7508 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
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]),
7529 else if (hash_mode
== 10000)
7533 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7535 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7537 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7541 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7542 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7543 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7544 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7545 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7546 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7547 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7548 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7549 digest_buf
[8] = 0; // needed for base64_encode ()
7551 char tmp_buf
[64] = { 0 };
7553 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7557 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7559 else if (hash_mode
== 10100)
7561 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7566 byte_swap_32 (salt
.salt_buf
[0]),
7567 byte_swap_32 (salt
.salt_buf
[1]),
7568 byte_swap_32 (salt
.salt_buf
[2]),
7569 byte_swap_32 (salt
.salt_buf
[3]));
7571 else if (hash_mode
== 10200)
7573 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7575 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7579 char challenge
[100] = { 0 };
7581 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7585 char tmp_buf
[100] = { 0 };
7587 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7588 (char *) cram_md5
->user
,
7594 char response
[100] = { 0 };
7596 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7598 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7600 else if (hash_mode
== 10300)
7602 char tmp_buf
[100] = { 0 };
7604 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7605 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7607 uint tmp_len
= 20 + salt
.salt_len
;
7611 char base64_encoded
[100] = { 0 };
7613 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7615 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7617 else if (hash_mode
== 10400)
7619 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7621 pdf_t
*pdf
= &pdfs
[salt_pos
];
7623 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",
7631 byte_swap_32 (pdf
->id_buf
[0]),
7632 byte_swap_32 (pdf
->id_buf
[1]),
7633 byte_swap_32 (pdf
->id_buf
[2]),
7634 byte_swap_32 (pdf
->id_buf
[3]),
7636 byte_swap_32 (pdf
->u_buf
[0]),
7637 byte_swap_32 (pdf
->u_buf
[1]),
7638 byte_swap_32 (pdf
->u_buf
[2]),
7639 byte_swap_32 (pdf
->u_buf
[3]),
7640 byte_swap_32 (pdf
->u_buf
[4]),
7641 byte_swap_32 (pdf
->u_buf
[5]),
7642 byte_swap_32 (pdf
->u_buf
[6]),
7643 byte_swap_32 (pdf
->u_buf
[7]),
7645 byte_swap_32 (pdf
->o_buf
[0]),
7646 byte_swap_32 (pdf
->o_buf
[1]),
7647 byte_swap_32 (pdf
->o_buf
[2]),
7648 byte_swap_32 (pdf
->o_buf
[3]),
7649 byte_swap_32 (pdf
->o_buf
[4]),
7650 byte_swap_32 (pdf
->o_buf
[5]),
7651 byte_swap_32 (pdf
->o_buf
[6]),
7652 byte_swap_32 (pdf
->o_buf
[7])
7655 else if (hash_mode
== 10410)
7657 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7659 pdf_t
*pdf
= &pdfs
[salt_pos
];
7661 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",
7669 byte_swap_32 (pdf
->id_buf
[0]),
7670 byte_swap_32 (pdf
->id_buf
[1]),
7671 byte_swap_32 (pdf
->id_buf
[2]),
7672 byte_swap_32 (pdf
->id_buf
[3]),
7674 byte_swap_32 (pdf
->u_buf
[0]),
7675 byte_swap_32 (pdf
->u_buf
[1]),
7676 byte_swap_32 (pdf
->u_buf
[2]),
7677 byte_swap_32 (pdf
->u_buf
[3]),
7678 byte_swap_32 (pdf
->u_buf
[4]),
7679 byte_swap_32 (pdf
->u_buf
[5]),
7680 byte_swap_32 (pdf
->u_buf
[6]),
7681 byte_swap_32 (pdf
->u_buf
[7]),
7683 byte_swap_32 (pdf
->o_buf
[0]),
7684 byte_swap_32 (pdf
->o_buf
[1]),
7685 byte_swap_32 (pdf
->o_buf
[2]),
7686 byte_swap_32 (pdf
->o_buf
[3]),
7687 byte_swap_32 (pdf
->o_buf
[4]),
7688 byte_swap_32 (pdf
->o_buf
[5]),
7689 byte_swap_32 (pdf
->o_buf
[6]),
7690 byte_swap_32 (pdf
->o_buf
[7])
7693 else if (hash_mode
== 10420)
7695 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7697 pdf_t
*pdf
= &pdfs
[salt_pos
];
7699 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7701 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",
7709 byte_swap_32 (pdf
->id_buf
[0]),
7710 byte_swap_32 (pdf
->id_buf
[1]),
7711 byte_swap_32 (pdf
->id_buf
[2]),
7712 byte_swap_32 (pdf
->id_buf
[3]),
7714 byte_swap_32 (pdf
->u_buf
[0]),
7715 byte_swap_32 (pdf
->u_buf
[1]),
7716 byte_swap_32 (pdf
->u_buf
[2]),
7717 byte_swap_32 (pdf
->u_buf
[3]),
7718 byte_swap_32 (pdf
->u_buf
[4]),
7719 byte_swap_32 (pdf
->u_buf
[5]),
7720 byte_swap_32 (pdf
->u_buf
[6]),
7721 byte_swap_32 (pdf
->u_buf
[7]),
7723 byte_swap_32 (pdf
->o_buf
[0]),
7724 byte_swap_32 (pdf
->o_buf
[1]),
7725 byte_swap_32 (pdf
->o_buf
[2]),
7726 byte_swap_32 (pdf
->o_buf
[3]),
7727 byte_swap_32 (pdf
->o_buf
[4]),
7728 byte_swap_32 (pdf
->o_buf
[5]),
7729 byte_swap_32 (pdf
->o_buf
[6]),
7730 byte_swap_32 (pdf
->o_buf
[7]),
7738 else if (hash_mode
== 10500)
7740 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7742 pdf_t
*pdf
= &pdfs
[salt_pos
];
7744 if (pdf
->id_len
== 32)
7746 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",
7754 byte_swap_32 (pdf
->id_buf
[0]),
7755 byte_swap_32 (pdf
->id_buf
[1]),
7756 byte_swap_32 (pdf
->id_buf
[2]),
7757 byte_swap_32 (pdf
->id_buf
[3]),
7758 byte_swap_32 (pdf
->id_buf
[4]),
7759 byte_swap_32 (pdf
->id_buf
[5]),
7760 byte_swap_32 (pdf
->id_buf
[6]),
7761 byte_swap_32 (pdf
->id_buf
[7]),
7763 byte_swap_32 (pdf
->u_buf
[0]),
7764 byte_swap_32 (pdf
->u_buf
[1]),
7765 byte_swap_32 (pdf
->u_buf
[2]),
7766 byte_swap_32 (pdf
->u_buf
[3]),
7767 byte_swap_32 (pdf
->u_buf
[4]),
7768 byte_swap_32 (pdf
->u_buf
[5]),
7769 byte_swap_32 (pdf
->u_buf
[6]),
7770 byte_swap_32 (pdf
->u_buf
[7]),
7772 byte_swap_32 (pdf
->o_buf
[0]),
7773 byte_swap_32 (pdf
->o_buf
[1]),
7774 byte_swap_32 (pdf
->o_buf
[2]),
7775 byte_swap_32 (pdf
->o_buf
[3]),
7776 byte_swap_32 (pdf
->o_buf
[4]),
7777 byte_swap_32 (pdf
->o_buf
[5]),
7778 byte_swap_32 (pdf
->o_buf
[6]),
7779 byte_swap_32 (pdf
->o_buf
[7])
7784 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",
7792 byte_swap_32 (pdf
->id_buf
[0]),
7793 byte_swap_32 (pdf
->id_buf
[1]),
7794 byte_swap_32 (pdf
->id_buf
[2]),
7795 byte_swap_32 (pdf
->id_buf
[3]),
7797 byte_swap_32 (pdf
->u_buf
[0]),
7798 byte_swap_32 (pdf
->u_buf
[1]),
7799 byte_swap_32 (pdf
->u_buf
[2]),
7800 byte_swap_32 (pdf
->u_buf
[3]),
7801 byte_swap_32 (pdf
->u_buf
[4]),
7802 byte_swap_32 (pdf
->u_buf
[5]),
7803 byte_swap_32 (pdf
->u_buf
[6]),
7804 byte_swap_32 (pdf
->u_buf
[7]),
7806 byte_swap_32 (pdf
->o_buf
[0]),
7807 byte_swap_32 (pdf
->o_buf
[1]),
7808 byte_swap_32 (pdf
->o_buf
[2]),
7809 byte_swap_32 (pdf
->o_buf
[3]),
7810 byte_swap_32 (pdf
->o_buf
[4]),
7811 byte_swap_32 (pdf
->o_buf
[5]),
7812 byte_swap_32 (pdf
->o_buf
[6]),
7813 byte_swap_32 (pdf
->o_buf
[7])
7817 else if (hash_mode
== 10600)
7819 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7821 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7822 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7824 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7826 else if (hash_mode
== 10700)
7828 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7830 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7831 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7833 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7835 else if (hash_mode
== 10900)
7837 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7839 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7840 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7842 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7844 else if (hash_mode
== 11100)
7846 u32 salt_challenge
= salt
.salt_buf
[0];
7848 salt_challenge
= byte_swap_32 (salt_challenge
);
7850 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7852 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7853 SIGNATURE_POSTGRESQL_AUTH
,
7861 else if (hash_mode
== 11200)
7863 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7864 SIGNATURE_MYSQL_AUTH
,
7865 (unsigned char *) salt
.salt_buf
,
7872 else if (hash_mode
== 11300)
7874 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7876 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7878 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7879 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7880 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7882 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7883 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7884 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7886 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7888 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7890 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7893 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7895 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7897 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7900 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7902 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
7904 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7907 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
7908 SIGNATURE_BITCOIN_WALLET
,
7912 (unsigned char *) salt
.salt_buf
,
7920 free (cry_master_buf
);
7922 free (public_key_buf
);
7924 else if (hash_mode
== 11400)
7926 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7928 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7929 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7931 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7933 else if (hash_mode
== 11600)
7935 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
7937 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
7939 const uint data_len
= seven_zip
->data_len
;
7941 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
7943 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
7945 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
7947 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
7950 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
7951 SIGNATURE_SEVEN_ZIP
,
7955 (char *) seven_zip
->salt_buf
,
7957 seven_zip
->iv_buf
[0],
7958 seven_zip
->iv_buf
[1],
7959 seven_zip
->iv_buf
[2],
7960 seven_zip
->iv_buf
[3],
7962 seven_zip
->data_len
,
7963 seven_zip
->unpack_size
,
7968 else if (hash_mode
== 11700)
7970 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
7980 else if (hash_mode
== 11800)
7982 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8000 else if (hash_mode
== 11900)
8002 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8004 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8005 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8007 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8009 else if (hash_mode
== 12000)
8011 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8013 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8014 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8016 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8018 else if (hash_mode
== 12100)
8020 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8022 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8023 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8025 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8027 else if (hash_mode
== 12200)
8029 uint
*ptr_digest
= digest_buf
;
8030 uint
*ptr_salt
= salt
.salt_buf
;
8032 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8039 else if (hash_mode
== 12300)
8041 uint
*ptr_digest
= digest_buf
;
8042 uint
*ptr_salt
= salt
.salt_buf
;
8044 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",
8045 ptr_digest
[ 0], ptr_digest
[ 1],
8046 ptr_digest
[ 2], ptr_digest
[ 3],
8047 ptr_digest
[ 4], ptr_digest
[ 5],
8048 ptr_digest
[ 6], ptr_digest
[ 7],
8049 ptr_digest
[ 8], ptr_digest
[ 9],
8050 ptr_digest
[10], ptr_digest
[11],
8051 ptr_digest
[12], ptr_digest
[13],
8052 ptr_digest
[14], ptr_digest
[15],
8058 else if (hash_mode
== 12400)
8060 // encode iteration count
8062 char salt_iter
[5] = { 0 };
8064 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8065 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8066 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8067 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8072 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8073 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8074 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8075 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8080 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8082 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8083 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8085 memcpy (tmp_buf
, digest_buf
, 8);
8087 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8091 // fill the resulting buffer
8093 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8095 else if (hash_mode
== 12500)
8097 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8099 byte_swap_32 (salt
.salt_buf
[0]),
8100 byte_swap_32 (salt
.salt_buf
[1]),
8106 else if (hash_mode
== 12600)
8108 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8109 digest_buf
[0] + salt
.salt_buf_pc
[0],
8110 digest_buf
[1] + salt
.salt_buf_pc
[1],
8111 digest_buf
[2] + salt
.salt_buf_pc
[2],
8112 digest_buf
[3] + salt
.salt_buf_pc
[3],
8113 digest_buf
[4] + salt
.salt_buf_pc
[4],
8114 digest_buf
[5] + salt
.salt_buf_pc
[5],
8115 digest_buf
[6] + salt
.salt_buf_pc
[6],
8116 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8118 else if (hash_mode
== 12700)
8120 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8122 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8123 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8125 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8127 else if (hash_mode
== 12800)
8129 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8131 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",
8144 byte_swap_32 (digest_buf
[0]),
8145 byte_swap_32 (digest_buf
[1]),
8146 byte_swap_32 (digest_buf
[2]),
8147 byte_swap_32 (digest_buf
[3]),
8148 byte_swap_32 (digest_buf
[4]),
8149 byte_swap_32 (digest_buf
[5]),
8150 byte_swap_32 (digest_buf
[6]),
8151 byte_swap_32 (digest_buf
[7])
8154 else if (hash_mode
== 12900)
8156 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",
8165 byte_swap_32 (digest_buf
[0]),
8166 byte_swap_32 (digest_buf
[1]),
8167 byte_swap_32 (digest_buf
[2]),
8168 byte_swap_32 (digest_buf
[3]),
8169 byte_swap_32 (digest_buf
[4]),
8170 byte_swap_32 (digest_buf
[5]),
8171 byte_swap_32 (digest_buf
[6]),
8172 byte_swap_32 (digest_buf
[7]),
8179 else if (hash_mode
== 13000)
8181 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8183 rar5_t
*rar5
= &rar5s
[salt_pos
];
8185 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8195 byte_swap_32 (digest_buf
[0]),
8196 byte_swap_32 (digest_buf
[1])
8201 if (hash_type
== HASH_TYPE_MD4
)
8203 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8209 else if (hash_type
== HASH_TYPE_MD5
)
8211 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8217 else if (hash_type
== HASH_TYPE_SHA1
)
8219 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8226 else if (hash_type
== HASH_TYPE_SHA256
)
8228 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8238 else if (hash_type
== HASH_TYPE_SHA384
)
8240 uint
*ptr
= digest_buf
;
8242 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8250 else if (hash_type
== HASH_TYPE_SHA512
)
8252 uint
*ptr
= digest_buf
;
8254 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8264 else if (hash_type
== HASH_TYPE_LM
)
8266 snprintf (out_buf
, len
-1, "%08x%08x",
8270 else if (hash_type
== HASH_TYPE_ORACLEH
)
8272 snprintf (out_buf
, len
-1, "%08X%08X",
8276 else if (hash_type
== HASH_TYPE_BCRYPT
)
8278 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8279 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8281 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8283 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8285 else if (hash_type
== HASH_TYPE_KECCAK
)
8287 uint
*ptr
= digest_buf
;
8289 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",
8317 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8319 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8321 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8328 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8330 digest_buf
[ 0] = digest_buf
[ 0];
8331 digest_buf
[ 1] = digest_buf
[ 1];
8332 digest_buf
[ 2] = digest_buf
[ 2];
8333 digest_buf
[ 3] = digest_buf
[ 3];
8334 digest_buf
[ 4] = digest_buf
[ 4];
8335 digest_buf
[ 5] = digest_buf
[ 5];
8336 digest_buf
[ 6] = digest_buf
[ 6];
8337 digest_buf
[ 7] = digest_buf
[ 7];
8338 digest_buf
[ 8] = digest_buf
[ 8];
8339 digest_buf
[ 9] = digest_buf
[ 9];
8340 digest_buf
[10] = digest_buf
[10];
8341 digest_buf
[11] = digest_buf
[11];
8342 digest_buf
[12] = digest_buf
[12];
8343 digest_buf
[13] = digest_buf
[13];
8344 digest_buf
[14] = digest_buf
[14];
8345 digest_buf
[15] = digest_buf
[15];
8347 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8365 else if (hash_type
== HASH_TYPE_GOST
)
8367 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8377 else if (hash_type
== HASH_TYPE_MYSQL
)
8379 snprintf (out_buf
, len
-1, "%08x%08x",
8383 else if (hash_type
== HASH_TYPE_LOTUS5
)
8385 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8391 else if (hash_type
== HASH_TYPE_LOTUS6
)
8393 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8394 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8395 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8396 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8398 char buf
[16] = { 0 };
8400 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8401 memcpy (buf
+ 5, digest_buf
, 9);
8405 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8407 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8410 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8412 else if (hash_type
== HASH_TYPE_LOTUS8
)
8414 char buf
[52] = { 0 };
8418 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8424 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8428 buf
[26] = salt
.salt_buf_pc
[0];
8429 buf
[27] = salt
.salt_buf_pc
[1];
8433 memcpy (buf
+ 28, digest_buf
, 8);
8435 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8439 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8441 else if (hash_type
== HASH_TYPE_CRC32
)
8443 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8447 if (salt_type
== SALT_TYPE_INTERN
)
8449 size_t pos
= strlen (out_buf
);
8451 out_buf
[pos
] = data
.separator
;
8453 char *ptr
= (char *) salt
.salt_buf
;
8455 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8457 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8461 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8463 memset (hccap
, 0, sizeof (hccap_t
));
8465 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8467 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8469 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8470 wpa_t
*wpa
= &wpas
[salt_pos
];
8472 hccap
->keyver
= wpa
->keyver
;
8474 hccap
->eapol_size
= wpa
->eapol_size
;
8476 if (wpa
->keyver
!= 1)
8478 uint eapol_tmp
[64] = { 0 };
8480 for (uint i
= 0; i
< 64; i
++)
8482 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8485 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8489 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8492 uint pke_tmp
[25] = { 0 };
8494 for (int i
= 5; i
< 25; i
++)
8496 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8499 char *pke_ptr
= (char *) pke_tmp
;
8501 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8502 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8503 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8504 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8506 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8508 uint dgst_size
= data
.dgst_size
;
8510 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8512 if (wpa
->keyver
!= 1)
8514 uint digest_tmp
[4] = { 0 };
8516 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8517 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8518 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8519 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8521 memcpy (hccap
->keymic
, digest_tmp
, 16);
8525 memcpy (hccap
->keymic
, digest_ptr
, 16);
8529 void SuspendThreads ()
8531 if (data
.devices_status
== STATUS_RUNNING
)
8533 hc_timer_set (&data
.timer_paused
);
8535 data
.devices_status
= STATUS_PAUSED
;
8537 log_info ("Paused");
8541 void ResumeThreads ()
8543 if (data
.devices_status
== STATUS_PAUSED
)
8547 hc_timer_get (data
.timer_paused
, ms_paused
);
8549 data
.ms_paused
+= ms_paused
;
8551 data
.devices_status
= STATUS_RUNNING
;
8553 log_info ("Resumed");
8559 if (data
.devices_status
!= STATUS_RUNNING
) return;
8561 data
.devices_status
= STATUS_BYPASS
;
8563 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8566 void stop_at_checkpoint ()
8568 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8570 if (data
.devices_status
!= STATUS_RUNNING
) return;
8573 // this feature only makes sense if --restore-disable was not specified
8575 if (data
.restore_disable
== 1)
8577 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8582 // check if monitoring of Restore Point updates should be enabled or disabled
8584 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8586 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8588 // save the current restore point value
8590 data
.checkpoint_cur_words
= get_lowest_words_done ();
8592 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8596 data
.devices_status
= STATUS_RUNNING
;
8598 // reset the global value for checkpoint checks
8600 data
.checkpoint_cur_words
= 0;
8602 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8608 if (data
.devices_status
== STATUS_INIT
) return;
8609 if (data
.devices_status
== STATUS_STARTING
) return;
8611 data
.devices_status
= STATUS_ABORTED
;
8616 if (data
.devices_status
== STATUS_INIT
) return;
8617 if (data
.devices_status
== STATUS_STARTING
) return;
8619 data
.devices_status
= STATUS_QUIT
;
8622 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8624 FILE *fp
= fopen (kernel_file
, "rb");
8630 memset (&st
, 0, sizeof (st
));
8632 stat (kernel_file
, &st
);
8634 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8636 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8638 if (num_read
!= (size_t) st
.st_size
)
8640 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8647 buf
[st
.st_size
] = 0;
8649 for (int i
= 0; i
< num_devices
; i
++)
8651 kernel_lengths
[i
] = (size_t) st
.st_size
;
8653 kernel_sources
[i
] = buf
;
8658 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8666 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8668 if (binary_size
> 0)
8670 FILE *fp
= fopen (dst
, "wb");
8673 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8684 restore_data_t
*init_restore (int argc
, char **argv
)
8686 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8688 if (data
.restore_disable
== 0)
8690 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8694 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8698 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8707 char pidbin
[BUFSIZ
] = { 0 };
8709 int pidbin_len
= -1;
8712 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8714 FILE *fd
= fopen (pidbin
, "rb");
8718 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8720 pidbin
[pidbin_len
] = 0;
8724 char *argv0_r
= strrchr (argv
[0], '/');
8726 char *pidbin_r
= strrchr (pidbin
, '/');
8728 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8730 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8732 if (strcmp (argv0_r
, pidbin_r
) == 0)
8734 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8741 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8743 char pidbin2
[BUFSIZ
] = { 0 };
8745 int pidbin2_len
= -1;
8747 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8748 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8750 pidbin
[pidbin_len
] = 0;
8751 pidbin2
[pidbin2_len
] = 0;
8755 if (strcmp (pidbin
, pidbin2
) == 0)
8757 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8765 if (rd
->version_bin
< RESTORE_MIN
)
8767 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8774 memset (rd
, 0, sizeof (restore_data_t
));
8776 rd
->version_bin
= VERSION_BIN
;
8779 rd
->pid
= getpid ();
8781 rd
->pid
= GetCurrentProcessId ();
8784 if (getcwd (rd
->cwd
, 255) == NULL
)
8797 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8799 FILE *fp
= fopen (eff_restore_file
, "rb");
8803 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8808 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8810 log_error ("ERROR: cannot read %s", eff_restore_file
);
8815 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8817 for (uint i
= 0; i
< rd
->argc
; i
++)
8819 char buf
[BUFSIZ
] = { 0 };
8821 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8823 log_error ("ERROR: cannot read %s", eff_restore_file
);
8828 size_t len
= strlen (buf
);
8830 if (len
) buf
[len
- 1] = 0;
8832 rd
->argv
[i
] = mystrdup (buf
);
8837 char new_cwd
[1024] = { 0 };
8839 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8843 log_error ("Restore file is corrupted");
8846 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8848 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8850 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8855 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8858 if (chdir (rd
->cwd
))
8860 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8866 u64
get_lowest_words_done ()
8870 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8872 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8874 if (device_param
->skipped
) continue;
8876 const u64 words_done
= device_param
->words_done
;
8878 if (words_done
< words_cur
) words_cur
= words_done
;
8881 // It's possible that a device's workload isn't finished right after a restore-case.
8882 // In that case, this function would return 0 and overwrite the real restore point
8883 // There's also data.words_cur which is set to rd->words_cur but it changes while
8884 // the attack is running therefore we should stick to rd->words_cur.
8885 // Note that -s influences rd->words_cur we should keep a close look on that.
8887 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
8892 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
8894 u64 words_cur
= get_lowest_words_done ();
8896 rd
->words_cur
= words_cur
;
8898 FILE *fp
= fopen (new_restore_file
, "wb");
8902 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
8907 if (setvbuf (fp
, NULL
, _IONBF
, 0))
8909 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
8914 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
8916 for (uint i
= 0; i
< rd
->argc
; i
++)
8918 fprintf (fp
, "%s", rd
->argv
[i
]);
8924 fsync (fileno (fp
));
8929 void cycle_restore ()
8931 const char *eff_restore_file
= data
.eff_restore_file
;
8932 const char *new_restore_file
= data
.new_restore_file
;
8934 restore_data_t
*rd
= data
.rd
;
8936 write_restore (new_restore_file
, rd
);
8940 memset (&st
, 0, sizeof(st
));
8942 if (stat (eff_restore_file
, &st
) == 0)
8944 if (unlink (eff_restore_file
))
8946 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
8950 if (rename (new_restore_file
, eff_restore_file
))
8952 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
8956 void check_checkpoint ()
8958 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
8960 u64 words_cur
= get_lowest_words_done ();
8962 if (words_cur
!= data
.checkpoint_cur_words
)
8973 uint
set_kernel_accel_osx (uint hash_mode
)
8977 case 1800: return GET_ACCEL_OSX (1800);
8978 case 2500: return GET_ACCEL_OSX (2500);
8979 case 5000: return GET_ACCEL_OSX (5000);
8980 case 6100: return GET_ACCEL_OSX (6100);
8981 case 6211: return GET_ACCEL_OSX (6211);
8982 case 6231: return GET_ACCEL_OSX (6231);
8983 case 6241: return GET_ACCEL_OSX (6241);
8984 case 6800: return GET_ACCEL_OSX (6800);
8985 case 7100: return GET_ACCEL_OSX (7100);
8986 case 7200: return GET_ACCEL_OSX (7200);
8987 case 7900: return GET_ACCEL_OSX (7900);
8988 case 8200: return GET_ACCEL_OSX (8200);
8989 case 8700: return GET_ACCEL_OSX (8700);
8990 case 9100: return GET_ACCEL_OSX (9100);
8991 case 9200: return GET_ACCEL_OSX (9200);
8992 case 9300: return GET_ACCEL_OSX (9300);
8993 case 9400: return GET_ACCEL_OSX (9400);
8994 case 9500: return GET_ACCEL_OSX (9500);
8995 case 9600: return GET_ACCEL_OSX (9600);
8996 case 10000: return GET_ACCEL_OSX (10000);
8997 case 10500: return GET_ACCEL_OSX (10500);
8998 case 11300: return GET_ACCEL_OSX (11300);
8999 case 11600: return GET_ACCEL_OSX (11600);
9000 case 11700: return GET_ACCEL_OSX (11700);
9001 case 11800: return GET_ACCEL_OSX (11800);
9002 case 12200: return GET_ACCEL_OSX (12200);
9003 case 12400: return GET_ACCEL_OSX (12400);
9004 case 12500: return GET_ACCEL_OSX (12500);
9005 case 13000: return GET_ACCEL_OSX (13000);
9011 uint
set_kernel_accel (uint hash_mode
, bool isGpu
)
9016 accel
= set_kernel_accel_osx (hash_mode
);
9022 uint
set_kernel_accel (uint hash_mode
)
9029 case 0: return GET_ACCEL (0);
9030 case 10: return GET_ACCEL (10);
9031 case 11: return GET_ACCEL (11);
9032 case 12: return GET_ACCEL (12);
9033 case 20: return GET_ACCEL (20);
9034 case 21: return GET_ACCEL (21);
9035 case 22: return GET_ACCEL (22);
9036 case 23: return GET_ACCEL (23);
9037 case 30: return GET_ACCEL (30);
9038 case 40: return GET_ACCEL (40);
9039 case 50: return GET_ACCEL (50);
9040 case 60: return GET_ACCEL (60);
9041 case 100: return GET_ACCEL (100);
9042 case 101: return GET_ACCEL (101);
9043 case 110: return GET_ACCEL (110);
9044 case 111: return GET_ACCEL (111);
9045 case 112: return GET_ACCEL (112);
9046 case 120: return GET_ACCEL (120);
9047 case 121: return GET_ACCEL (121);
9048 case 122: return GET_ACCEL (122);
9049 case 124: return GET_ACCEL (124);
9050 case 130: return GET_ACCEL (130);
9051 case 131: return GET_ACCEL (131);
9052 case 132: return GET_ACCEL (132);
9053 case 133: return GET_ACCEL (133);
9054 case 140: return GET_ACCEL (140);
9055 case 141: return GET_ACCEL (141);
9056 case 150: return GET_ACCEL (150);
9057 case 160: return GET_ACCEL (160);
9058 case 190: return GET_ACCEL (190);
9059 case 200: return GET_ACCEL (200);
9060 case 300: return GET_ACCEL (300);
9061 case 400: return GET_ACCEL (400);
9062 case 500: return GET_ACCEL (500);
9063 case 501: return GET_ACCEL (501);
9064 case 900: return GET_ACCEL (900);
9065 case 910: return GET_ACCEL (910);
9066 case 1000: return GET_ACCEL (1000);
9067 case 1100: return GET_ACCEL (1100);
9068 case 1400: return GET_ACCEL (1400);
9069 case 1410: return GET_ACCEL (1410);
9070 case 1420: return GET_ACCEL (1420);
9071 case 1421: return GET_ACCEL (1421);
9072 case 1430: return GET_ACCEL (1430);
9073 case 1440: return GET_ACCEL (1440);
9074 case 1441: return GET_ACCEL (1441);
9075 case 1450: return GET_ACCEL (1450);
9076 case 1460: return GET_ACCEL (1460);
9077 case 1500: return GET_ACCEL (1500);
9078 case 1600: return GET_ACCEL (1600);
9079 case 1700: return GET_ACCEL (1700);
9080 case 1710: return GET_ACCEL (1710);
9081 case 1711: return GET_ACCEL (1711);
9082 case 1720: return GET_ACCEL (1720);
9083 case 1722: return GET_ACCEL (1722);
9084 case 1730: return GET_ACCEL (1730);
9085 case 1731: return GET_ACCEL (1731);
9086 case 1740: return GET_ACCEL (1740);
9087 case 1750: return GET_ACCEL (1750);
9088 case 1760: return GET_ACCEL (1760);
9089 case 1800: return GET_ACCEL (1800);
9090 case 2100: return GET_ACCEL (2100);
9091 case 2400: return GET_ACCEL (2400);
9092 case 2410: return GET_ACCEL (2410);
9093 case 2500: return GET_ACCEL (2500);
9094 case 2600: return GET_ACCEL (2600);
9095 case 2611: return GET_ACCEL (2611);
9096 case 2612: return GET_ACCEL (2612);
9097 case 2711: return GET_ACCEL (2711);
9098 case 2811: return GET_ACCEL (2811);
9099 case 3000: return GET_ACCEL (3000);
9100 case 3100: return GET_ACCEL (3100);
9101 case 3200: return GET_ACCEL (3200);
9102 case 3710: return GET_ACCEL (3710);
9103 case 3711: return GET_ACCEL (3711);
9104 case 3800: return GET_ACCEL (3800);
9105 case 4300: return GET_ACCEL (4300);
9106 case 4400: return GET_ACCEL (4400);
9107 case 4500: return GET_ACCEL (4500);
9108 case 4700: return GET_ACCEL (4700);
9109 case 4800: return GET_ACCEL (4800);
9110 case 4900: return GET_ACCEL (4900);
9111 case 5000: return GET_ACCEL (5000);
9112 case 5100: return GET_ACCEL (5100);
9113 case 5200: return GET_ACCEL (5200);
9114 case 5300: return GET_ACCEL (5300);
9115 case 5400: return GET_ACCEL (5400);
9116 case 5500: return GET_ACCEL (5500);
9117 case 5600: return GET_ACCEL (5600);
9118 case 5700: return GET_ACCEL (5700);
9119 case 5800: return GET_ACCEL (5800);
9120 case 6000: return GET_ACCEL (6000);
9121 case 6100: return GET_ACCEL (6100);
9122 case 6211: return GET_ACCEL (6211);
9123 case 6212: return GET_ACCEL (6212);
9124 case 6213: return GET_ACCEL (6213);
9125 case 6221: return GET_ACCEL (6221);
9126 case 6222: return GET_ACCEL (6222);
9127 case 6223: return GET_ACCEL (6223);
9128 case 6231: return GET_ACCEL (6231);
9129 case 6232: return GET_ACCEL (6232);
9130 case 6233: return GET_ACCEL (6233);
9131 case 6241: return GET_ACCEL (6241);
9132 case 6242: return GET_ACCEL (6242);
9133 case 6243: return GET_ACCEL (6243);
9134 case 6300: return GET_ACCEL (6300);
9135 case 6400: return GET_ACCEL (6400);
9136 case 6500: return GET_ACCEL (6500);
9137 case 6600: return GET_ACCEL (6600);
9138 case 6700: return GET_ACCEL (6700);
9139 case 6800: return GET_ACCEL (6800);
9140 case 6900: return GET_ACCEL (6900);
9141 case 7100: return GET_ACCEL (7100);
9142 case 7200: return GET_ACCEL (7200);
9143 case 7300: return GET_ACCEL (7300);
9144 case 7400: return GET_ACCEL (7400);
9145 case 7500: return GET_ACCEL (7500);
9146 case 7600: return GET_ACCEL (7600);
9147 case 7700: return GET_ACCEL (7700);
9148 case 7800: return GET_ACCEL (7800);
9149 case 7900: return GET_ACCEL (7900);
9150 case 8000: return GET_ACCEL (8000);
9151 case 8100: return GET_ACCEL (8100);
9152 case 8200: return GET_ACCEL (8200);
9153 case 8300: return GET_ACCEL (8300);
9154 case 8400: return GET_ACCEL (8400);
9155 case 8500: return GET_ACCEL (8500);
9156 case 8600: return GET_ACCEL (8600);
9157 case 8700: return GET_ACCEL (8700);
9158 case 8800: return GET_ACCEL (8800);
9159 case 8900: return GET_ACCEL (8900);
9160 case 9000: return GET_ACCEL (9000);
9161 case 9100: return GET_ACCEL (9100);
9162 case 9200: return GET_ACCEL (9200);
9163 case 9300: return GET_ACCEL (9300);
9164 case 9400: return GET_ACCEL (9400);
9165 case 9500: return GET_ACCEL (9500);
9166 case 9600: return GET_ACCEL (9600);
9167 case 9700: return GET_ACCEL (9700);
9168 case 9710: return GET_ACCEL (9710);
9169 case 9720: return GET_ACCEL (9720);
9170 case 9800: return GET_ACCEL (9800);
9171 case 9810: return GET_ACCEL (9810);
9172 case 9820: return GET_ACCEL (9820);
9173 case 9900: return GET_ACCEL (9900);
9174 case 10000: return GET_ACCEL (10000);
9175 case 10100: return GET_ACCEL (10100);
9176 case 10200: return GET_ACCEL (10200);
9177 case 10300: return GET_ACCEL (10300);
9178 case 10400: return GET_ACCEL (10400);
9179 case 10410: return GET_ACCEL (10410);
9180 case 10420: return GET_ACCEL (10420);
9181 case 10500: return GET_ACCEL (10500);
9182 case 10600: return GET_ACCEL (10600);
9183 case 10700: return GET_ACCEL (10700);
9184 case 10800: return GET_ACCEL (10800);
9185 case 10900: return GET_ACCEL (10900);
9186 case 11000: return GET_ACCEL (11000);
9187 case 11100: return GET_ACCEL (11100);
9188 case 11200: return GET_ACCEL (11200);
9189 case 11300: return GET_ACCEL (11300);
9190 case 11400: return GET_ACCEL (11400);
9191 case 11500: return GET_ACCEL (11500);
9192 case 11600: return GET_ACCEL (11600);
9193 case 11700: return GET_ACCEL (11700);
9194 case 11800: return GET_ACCEL (11800);
9195 case 11900: return GET_ACCEL (11900);
9196 case 12000: return GET_ACCEL (12000);
9197 case 12100: return GET_ACCEL (12100);
9198 case 12200: return GET_ACCEL (12200);
9199 case 12300: return GET_ACCEL (12300);
9200 case 12400: return GET_ACCEL (12400);
9201 case 12500: return GET_ACCEL (12500);
9202 case 12600: return GET_ACCEL (12600);
9203 case 12700: return GET_ACCEL (12700);
9204 case 12800: return GET_ACCEL (12800);
9205 case 12900: return GET_ACCEL (12900);
9206 case 13000: return GET_ACCEL (13000);
9213 uint
set_kernel_loops_osx (uint hash_mode
)
9217 case 0: return GET_LOOPS_OSX (0);
9218 case 10: return GET_LOOPS_OSX (10);
9219 case 11: return GET_LOOPS_OSX (11);
9220 case 12: return GET_LOOPS_OSX (12);
9221 case 20: return GET_LOOPS_OSX (20);
9222 case 21: return GET_LOOPS_OSX (21);
9223 case 22: return GET_LOOPS_OSX (22);
9224 case 23: return GET_LOOPS_OSX (23);
9225 case 30: return GET_LOOPS_OSX (30);
9226 case 40: return GET_LOOPS_OSX (40);
9227 case 50: return GET_LOOPS_OSX (50);
9228 case 60: return GET_LOOPS_OSX (60);
9229 case 100: return GET_LOOPS_OSX (100);
9230 case 101: return GET_LOOPS_OSX (101);
9231 case 110: return GET_LOOPS_OSX (110);
9232 case 111: return GET_LOOPS_OSX (111);
9233 case 112: return GET_LOOPS_OSX (112);
9234 case 120: return GET_LOOPS_OSX (120);
9235 case 121: return GET_LOOPS_OSX (121);
9236 case 122: return GET_LOOPS_OSX (122);
9237 case 124: return GET_LOOPS_OSX (124);
9238 case 130: return GET_LOOPS_OSX (130);
9239 case 131: return GET_LOOPS_OSX (131);
9240 case 132: return GET_LOOPS_OSX (132);
9241 case 133: return GET_LOOPS_OSX (133);
9242 case 140: return GET_LOOPS_OSX (140);
9243 case 141: return GET_LOOPS_OSX (141);
9244 case 150: return GET_LOOPS_OSX (150);
9245 case 160: return GET_LOOPS_OSX (160);
9246 case 190: return GET_LOOPS_OSX (190);
9247 case 200: return GET_LOOPS_OSX (200);
9248 case 300: return GET_LOOPS_OSX (300);
9249 case 900: return GET_LOOPS_OSX (900);
9250 case 1000: return GET_LOOPS_OSX (1000);
9251 case 1100: return GET_LOOPS_OSX (1100);
9252 case 1400: return GET_LOOPS_OSX (1400);
9253 case 1410: return GET_LOOPS_OSX (1410);
9254 case 1420: return GET_LOOPS_OSX (1420);
9255 case 1421: return GET_LOOPS_OSX (1421);
9256 case 1430: return GET_LOOPS_OSX (1430);
9257 case 1440: return GET_LOOPS_OSX (1440);
9258 case 1441: return GET_LOOPS_OSX (1441);
9259 case 1450: return GET_LOOPS_OSX (1450);
9260 case 1460: return GET_LOOPS_OSX (1460);
9261 case 1700: return GET_LOOPS_OSX (1700);
9262 case 1710: return GET_LOOPS_OSX (1710);
9263 case 1711: return GET_LOOPS_OSX (1711);
9264 case 1720: return GET_LOOPS_OSX (1720);
9265 case 1722: return GET_LOOPS_OSX (1722);
9266 case 1730: return GET_LOOPS_OSX (1730);
9267 case 1731: return GET_LOOPS_OSX (1731);
9268 case 1740: return GET_LOOPS_OSX (1740);
9269 case 1750: return GET_LOOPS_OSX (1750);
9270 case 1760: return GET_LOOPS_OSX (1760);
9271 case 2400: return GET_LOOPS_OSX (2400);
9272 case 2410: return GET_LOOPS_OSX (2410);
9273 case 2600: return GET_LOOPS_OSX (2600);
9274 case 2611: return GET_LOOPS_OSX (2611);
9275 case 2612: return GET_LOOPS_OSX (2612);
9276 case 2711: return GET_LOOPS_OSX (2711);
9277 case 2811: return GET_LOOPS_OSX (2811);
9278 case 3100: return GET_LOOPS_OSX (3100);
9279 case 3200: return GET_LOOPS_OSX (3200);
9280 case 3710: return GET_LOOPS_OSX (3710);
9281 case 3711: return GET_LOOPS_OSX (3711);
9282 case 3800: return GET_LOOPS_OSX (3800);
9283 case 4300: return GET_LOOPS_OSX (4300);
9284 case 4400: return GET_LOOPS_OSX (4400);
9285 case 4500: return GET_LOOPS_OSX (4500);
9286 case 4700: return GET_LOOPS_OSX (4700);
9287 case 4800: return GET_LOOPS_OSX (4800);
9288 case 4900: return GET_LOOPS_OSX (4900);
9289 case 5000: return GET_LOOPS_OSX (5000);
9290 case 5100: return GET_LOOPS_OSX (5100);
9291 case 5300: return GET_LOOPS_OSX (5300);
9292 case 5400: return GET_LOOPS_OSX (5400);
9293 case 5500: return GET_LOOPS_OSX (5500);
9294 case 5600: return GET_LOOPS_OSX (5600);
9295 case 5700: return GET_LOOPS_OSX (5700);
9296 case 6000: return GET_LOOPS_OSX (6000);
9297 case 6100: return GET_LOOPS_OSX (6100);
9298 case 6231: return GET_LOOPS_OSX (6231);
9299 case 6232: return GET_LOOPS_OSX (6232);
9300 case 6233: return GET_LOOPS_OSX (6233);
9301 case 6900: return GET_LOOPS_OSX (6900);
9302 case 7300: return GET_LOOPS_OSX (7300);
9303 case 7500: return GET_LOOPS_OSX (7500);
9304 case 7600: return GET_LOOPS_OSX (7600);
9305 case 7700: return GET_LOOPS_OSX (7700);
9306 case 7800: return GET_LOOPS_OSX (7800);
9307 case 8000: return GET_LOOPS_OSX (8000);
9308 case 8100: return GET_LOOPS_OSX (8100);
9309 case 8200: return GET_LOOPS_OSX (8200);
9310 case 8300: return GET_LOOPS_OSX (8300);
9311 case 8400: return GET_LOOPS_OSX (8400);
9312 case 8500: return GET_LOOPS_OSX (8500);
9313 case 8600: return GET_LOOPS_OSX (8600);
9314 case 8700: return GET_LOOPS_OSX (8700);
9315 case 9700: return GET_LOOPS_OSX (9700);
9316 case 9710: return GET_LOOPS_OSX (9710);
9317 case 9720: return GET_LOOPS_OSX (9720);
9318 case 9800: return GET_LOOPS_OSX (9800);
9319 case 9810: return GET_LOOPS_OSX (9810);
9320 case 9820: return GET_LOOPS_OSX (9820);
9321 case 9900: return GET_LOOPS_OSX (9900);
9322 case 10100: return GET_LOOPS_OSX (10100);
9323 case 10200: return GET_LOOPS_OSX (10200);
9324 case 10400: return GET_LOOPS_OSX (10400);
9325 case 10410: return GET_LOOPS_OSX (10410);
9326 case 10420: return GET_LOOPS_OSX (10420);
9327 case 10600: return GET_LOOPS_OSX (10600);
9328 case 10700: return GET_LOOPS_OSX (10700);
9329 case 10800: return GET_LOOPS_OSX (10800);
9330 case 11000: return GET_LOOPS_OSX (11000);
9331 case 11100: return GET_LOOPS_OSX (11100);
9332 case 11200: return GET_LOOPS_OSX (11200);
9333 case 11300: return GET_LOOPS_OSX (11300);
9334 case 11400: return GET_LOOPS_OSX (11400);
9335 case 11500: return GET_LOOPS_OSX (11500);
9336 case 11700: return GET_LOOPS_OSX (11700);
9337 case 11800: return GET_LOOPS_OSX (11800);
9338 case 12600: return GET_LOOPS_OSX (12600);
9344 uint
set_kernel_loops (uint hash_mode
, bool isGpu
)
9348 loops
= set_kernel_loops_osx (hash_mode
);
9355 uint
set_kernel_loops (uint hash_mode
)
9362 case 0: return GET_LOOPS (0);
9363 case 10: return GET_LOOPS (10);
9364 case 11: return GET_LOOPS (11);
9365 case 12: return GET_LOOPS (12);
9366 case 20: return GET_LOOPS (20);
9367 case 21: return GET_LOOPS (21);
9368 case 22: return GET_LOOPS (22);
9369 case 23: return GET_LOOPS (23);
9370 case 30: return GET_LOOPS (30);
9371 case 40: return GET_LOOPS (40);
9372 case 50: return GET_LOOPS (50);
9373 case 60: return GET_LOOPS (60);
9374 case 100: return GET_LOOPS (100);
9375 case 101: return GET_LOOPS (101);
9376 case 110: return GET_LOOPS (110);
9377 case 111: return GET_LOOPS (111);
9378 case 112: return GET_LOOPS (112);
9379 case 120: return GET_LOOPS (120);
9380 case 121: return GET_LOOPS (121);
9381 case 122: return GET_LOOPS (122);
9382 case 124: return GET_LOOPS (124);
9383 case 130: return GET_LOOPS (130);
9384 case 131: return GET_LOOPS (131);
9385 case 132: return GET_LOOPS (132);
9386 case 133: return GET_LOOPS (133);
9387 case 140: return GET_LOOPS (140);
9388 case 141: return GET_LOOPS (141);
9389 case 150: return GET_LOOPS (150);
9390 case 160: return GET_LOOPS (160);
9391 case 190: return GET_LOOPS (190);
9392 case 200: return GET_LOOPS (200);
9393 case 300: return GET_LOOPS (300);
9394 case 400: return GET_LOOPS (400);
9395 case 500: return GET_LOOPS (500);
9396 case 501: return GET_LOOPS (501);
9397 case 900: return GET_LOOPS (900);
9398 case 910: return GET_LOOPS (910);
9399 case 1000: return GET_LOOPS (1000);
9400 case 1100: return GET_LOOPS (1100);
9401 case 1400: return GET_LOOPS (1400);
9402 case 1410: return GET_LOOPS (1410);
9403 case 1420: return GET_LOOPS (1420);
9404 case 1421: return GET_LOOPS (1421);
9405 case 1430: return GET_LOOPS (1430);
9406 case 1440: return GET_LOOPS (1440);
9407 case 1441: return GET_LOOPS (1441);
9408 case 1450: return GET_LOOPS (1450);
9409 case 1460: return GET_LOOPS (1460);
9410 case 1500: return GET_LOOPS (1500);
9411 case 1600: return GET_LOOPS (1600);
9412 case 1700: return GET_LOOPS (1700);
9413 case 1710: return GET_LOOPS (1710);
9414 case 1711: return GET_LOOPS (1711);
9415 case 1720: return GET_LOOPS (1720);
9416 case 1722: return GET_LOOPS (1722);
9417 case 1730: return GET_LOOPS (1730);
9418 case 1731: return GET_LOOPS (1731);
9419 case 1740: return GET_LOOPS (1740);
9420 case 1750: return GET_LOOPS (1750);
9421 case 1760: return GET_LOOPS (1760);
9422 case 1800: return GET_LOOPS (1800);
9423 case 2100: return GET_LOOPS (2100);
9424 case 2400: return GET_LOOPS (2400);
9425 case 2410: return GET_LOOPS (2410);
9426 case 2500: return GET_LOOPS (2500);
9427 case 2600: return GET_LOOPS (2600);
9428 case 2611: return GET_LOOPS (2611);
9429 case 2612: return GET_LOOPS (2612);
9430 case 2711: return GET_LOOPS (2711);
9431 case 2811: return GET_LOOPS (2811);
9432 case 3000: return GET_LOOPS (3000);
9433 case 3100: return GET_LOOPS (3100);
9434 case 3200: return GET_LOOPS (3200);
9435 case 3710: return GET_LOOPS (3710);
9436 case 3711: return GET_LOOPS (3711);
9437 case 3800: return GET_LOOPS (3800);
9438 case 4300: return GET_LOOPS (4300);
9439 case 4400: return GET_LOOPS (4400);
9440 case 4500: return GET_LOOPS (4500);
9441 case 4700: return GET_LOOPS (4700);
9442 case 4800: return GET_LOOPS (4800);
9443 case 4900: return GET_LOOPS (4900);
9444 case 5000: return GET_LOOPS (5000);
9445 case 5100: return GET_LOOPS (5100);
9446 case 5200: return GET_LOOPS (5200);
9447 case 5300: return GET_LOOPS (5300);
9448 case 5400: return GET_LOOPS (5400);
9449 case 5500: return GET_LOOPS (5500);
9450 case 5600: return GET_LOOPS (5600);
9451 case 5700: return GET_LOOPS (5700);
9452 case 5800: return GET_LOOPS (5800);
9453 case 6000: return GET_LOOPS (6000);
9454 case 6100: return GET_LOOPS (6100);
9455 case 6211: return GET_LOOPS (6211);
9456 case 6212: return GET_LOOPS (6212);
9457 case 6213: return GET_LOOPS (6213);
9458 case 6221: return GET_LOOPS (6221);
9459 case 6222: return GET_LOOPS (6222);
9460 case 6223: return GET_LOOPS (6223);
9461 case 6231: return GET_LOOPS (6231);
9462 case 6232: return GET_LOOPS (6232);
9463 case 6233: return GET_LOOPS (6233);
9464 case 6241: return GET_LOOPS (6241);
9465 case 6242: return GET_LOOPS (6242);
9466 case 6243: return GET_LOOPS (6243);
9467 case 6300: return GET_LOOPS (6300);
9468 case 6400: return GET_LOOPS (6400);
9469 case 6500: return GET_LOOPS (6500);
9470 case 6600: return GET_LOOPS (6600);
9471 case 6700: return GET_LOOPS (6700);
9472 case 6800: return GET_LOOPS (6800);
9473 case 6900: return GET_LOOPS (6900);
9474 case 7100: return GET_LOOPS (7100);
9475 case 7200: return GET_LOOPS (7200);
9476 case 7300: return GET_LOOPS (7300);
9477 case 7400: return GET_LOOPS (7400);
9478 case 7500: return GET_LOOPS (7500);
9479 case 7600: return GET_LOOPS (7600);
9480 case 7700: return GET_LOOPS (7700);
9481 case 7800: return GET_LOOPS (7800);
9482 case 7900: return GET_LOOPS (7900);
9483 case 8000: return GET_LOOPS (8000);
9484 case 8100: return GET_LOOPS (8100);
9485 case 8200: return GET_LOOPS (8200);
9486 case 8300: return GET_LOOPS (8300);
9487 case 8400: return GET_LOOPS (8400);
9488 case 8500: return GET_LOOPS (8500);
9489 case 8600: return GET_LOOPS (8600);
9490 case 8700: return GET_LOOPS (8700);
9491 case 8800: return GET_LOOPS (8800);
9492 case 8900: return GET_LOOPS (8900);
9493 case 9000: return GET_LOOPS (9000);
9494 case 9100: return GET_LOOPS (9100);
9495 case 9200: return GET_LOOPS (9200);
9496 case 9300: return GET_LOOPS (9300);
9497 case 9400: return GET_LOOPS (9400);
9498 case 9500: return GET_LOOPS (9500);
9499 case 9600: return GET_LOOPS (9600);
9500 case 9700: return GET_LOOPS (9700);
9501 case 9710: return GET_LOOPS (9710);
9502 case 9720: return GET_LOOPS (9720);
9503 case 9800: return GET_LOOPS (9800);
9504 case 9810: return GET_LOOPS (9810);
9505 case 9820: return GET_LOOPS (9820);
9506 case 9900: return GET_LOOPS (9900);
9507 case 10000: return GET_LOOPS (10000);
9508 case 10100: return GET_LOOPS (10100);
9509 case 10200: return GET_LOOPS (10200);
9510 case 10300: return GET_LOOPS (10300);
9511 case 10400: return GET_LOOPS (10400);
9512 case 10410: return GET_LOOPS (10410);
9513 case 10420: return GET_LOOPS (10420);
9514 case 10500: return GET_LOOPS (10500);
9515 case 10600: return GET_LOOPS (10600);
9516 case 10700: return GET_LOOPS (10700);
9517 case 10800: return GET_LOOPS (10800);
9518 case 10900: return GET_LOOPS (10900);
9519 case 11000: return GET_LOOPS (11000);
9520 case 11100: return GET_LOOPS (11100);
9521 case 11200: return GET_LOOPS (11200);
9522 case 11300: return GET_LOOPS (11300);
9523 case 11400: return GET_LOOPS (11400);
9524 case 11500: return GET_LOOPS (11500);
9525 case 11600: return GET_LOOPS (11600);
9526 case 11700: return GET_LOOPS (11700);
9527 case 11800: return GET_LOOPS (11800);
9528 case 11900: return GET_LOOPS (11900);
9529 case 12000: return GET_LOOPS (12000);
9530 case 12100: return GET_LOOPS (12100);
9531 case 12200: return GET_LOOPS (12200);
9532 case 12300: return GET_LOOPS (12300);
9533 case 12400: return GET_LOOPS (12400);
9534 case 12500: return GET_LOOPS (12500);
9535 case 12600: return GET_LOOPS (12600);
9536 case 12700: return GET_LOOPS (12700);
9537 case 12800: return GET_LOOPS (12800);
9538 case 12900: return GET_LOOPS (12900);
9539 case 13000: return GET_LOOPS (13000);
9549 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9551 u8 tmp
[256] = { 0 };
9553 if (salt_len
> sizeof (tmp
))
9558 memcpy (tmp
, in
, salt_len
);
9560 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9562 if ((salt_len
% 2) == 0)
9564 u32 new_salt_len
= salt_len
/ 2;
9566 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9571 tmp
[i
] = hex_convert (p1
) << 0;
9572 tmp
[i
] |= hex_convert (p0
) << 4;
9575 salt_len
= new_salt_len
;
9582 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9584 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9587 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9589 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9593 u32
*tmp_uint
= (u32
*) tmp
;
9595 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9596 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9597 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9598 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9599 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9600 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9601 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9602 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9603 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9604 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9606 salt_len
= salt_len
* 2;
9614 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9616 lowercase (tmp
, salt_len
);
9619 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9621 uppercase (tmp
, salt_len
);
9626 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9631 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9636 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9638 u32
*tmp_uint
= (uint
*) tmp
;
9644 for (u32 i
= 0; i
< max
; i
++)
9646 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9649 // Important: we may need to increase the length of memcpy since
9650 // we don't want to "loose" some swapped bytes (could happen if
9651 // they do not perfectly fit in the 4-byte blocks)
9652 // Memcpy does always copy the bytes in the BE order, but since
9653 // we swapped them, some important bytes could be in positions
9654 // we normally skip with the original len
9656 if (len
% 4) len
+= 4 - (len
% 4);
9659 memcpy (out
, tmp
, len
);
9664 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9666 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9668 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9670 u32
*digest
= (u32
*) hash_buf
->digest
;
9672 salt_t
*salt
= hash_buf
->salt
;
9674 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9676 char *iter_pos
= input_buf
+ 4;
9678 salt
->salt_iter
= 1 << atoi (iter_pos
);
9680 char *salt_pos
= strchr (iter_pos
, '$');
9682 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9688 salt
->salt_len
= salt_len
;
9690 u8 tmp_buf
[100] = { 0 };
9692 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9694 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9696 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9698 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9699 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9700 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9701 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9703 char *hash_pos
= salt_pos
+ 22;
9705 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9707 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9709 memcpy (digest
, tmp_buf
, 24);
9711 digest
[0] = byte_swap_32 (digest
[0]);
9712 digest
[1] = byte_swap_32 (digest
[1]);
9713 digest
[2] = byte_swap_32 (digest
[2]);
9714 digest
[3] = byte_swap_32 (digest
[3]);
9715 digest
[4] = byte_swap_32 (digest
[4]);
9716 digest
[5] = byte_swap_32 (digest
[5]);
9718 digest
[5] &= ~0xff; // its just 23 not 24 !
9723 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9725 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9727 u32
*digest
= (u32
*) hash_buf
->digest
;
9729 u8 tmp_buf
[100] = { 0 };
9731 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9733 memcpy (digest
, tmp_buf
, 32);
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]);
9741 digest
[6] = byte_swap_32 (digest
[6]);
9742 digest
[7] = byte_swap_32 (digest
[7]);
9744 digest
[0] -= SHA256M_A
;
9745 digest
[1] -= SHA256M_B
;
9746 digest
[2] -= SHA256M_C
;
9747 digest
[3] -= SHA256M_D
;
9748 digest
[4] -= SHA256M_E
;
9749 digest
[5] -= SHA256M_F
;
9750 digest
[6] -= SHA256M_G
;
9751 digest
[7] -= SHA256M_H
;
9756 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9758 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9760 u32
*digest
= (u32
*) hash_buf
->digest
;
9762 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9763 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9765 digest
[0] = byte_swap_32 (digest
[0]);
9766 digest
[1] = byte_swap_32 (digest
[1]);
9770 IP (digest
[0], digest
[1], tt
);
9772 digest
[0] = digest
[0];
9773 digest
[1] = digest
[1];
9780 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9782 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9784 u32
*digest
= (u32
*) hash_buf
->digest
;
9786 salt_t
*salt
= hash_buf
->salt
;
9788 char *hash_pos
= input_buf
+ 8;
9790 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9791 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9792 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9793 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9794 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9796 digest
[0] -= SHA1M_A
;
9797 digest
[1] -= SHA1M_B
;
9798 digest
[2] -= SHA1M_C
;
9799 digest
[3] -= SHA1M_D
;
9800 digest
[4] -= SHA1M_E
;
9804 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9806 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9808 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9810 salt
->salt_len
= salt_len
;
9815 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9817 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9819 u64
*digest
= (u64
*) hash_buf
->digest
;
9821 salt_t
*salt
= hash_buf
->salt
;
9823 char *hash_pos
= input_buf
+ 8;
9825 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9826 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9827 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9828 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9829 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9830 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9831 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9832 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9834 digest
[0] -= SHA512M_A
;
9835 digest
[1] -= SHA512M_B
;
9836 digest
[2] -= SHA512M_C
;
9837 digest
[3] -= SHA512M_D
;
9838 digest
[4] -= SHA512M_E
;
9839 digest
[5] -= SHA512M_F
;
9840 digest
[6] -= SHA512M_G
;
9841 digest
[7] -= SHA512M_H
;
9845 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9847 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9849 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9851 salt
->salt_len
= salt_len
;
9856 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9858 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9860 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9864 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9867 u32
*digest
= (u32
*) hash_buf
->digest
;
9869 salt_t
*salt
= hash_buf
->salt
;
9871 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9872 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9873 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9874 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9876 digest
[0] = byte_swap_32 (digest
[0]);
9877 digest
[1] = byte_swap_32 (digest
[1]);
9878 digest
[2] = byte_swap_32 (digest
[2]);
9879 digest
[3] = byte_swap_32 (digest
[3]);
9881 digest
[0] -= MD5M_A
;
9882 digest
[1] -= MD5M_B
;
9883 digest
[2] -= MD5M_C
;
9884 digest
[3] -= MD5M_D
;
9886 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9888 uint salt_len
= input_len
- 32 - 1;
9890 char *salt_buf
= input_buf
+ 32 + 1;
9892 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9894 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9896 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9898 salt
->salt_len
= salt_len
;
9903 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9905 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9907 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9911 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9916 char clean_input_buf
[32] = { 0 };
9918 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9919 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9921 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9925 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9931 clean_input_buf
[k
] = input_buf
[i
];
9939 u32
*digest
= (u32
*) hash_buf
->digest
;
9941 salt_t
*salt
= hash_buf
->salt
;
9943 u32 a
, b
, c
, d
, e
, f
;
9945 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9946 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9947 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9948 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9949 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9950 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9952 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9953 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9955 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9956 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9957 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9958 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9959 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9960 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9962 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9963 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9965 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9966 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9967 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9968 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9969 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9970 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9972 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9973 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9975 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9976 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9977 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9978 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9979 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9980 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9982 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9983 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9985 digest
[0] = byte_swap_32 (digest
[0]);
9986 digest
[1] = byte_swap_32 (digest
[1]);
9987 digest
[2] = byte_swap_32 (digest
[2]);
9988 digest
[3] = byte_swap_32 (digest
[3]);
9990 digest
[0] -= MD5M_A
;
9991 digest
[1] -= MD5M_B
;
9992 digest
[2] -= MD5M_C
;
9993 digest
[3] -= MD5M_D
;
9995 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9997 uint salt_len
= input_len
- 30 - 1;
9999 char *salt_buf
= input_buf
+ 30 + 1;
10001 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10003 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10005 // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
10006 if (salt_len
> 10) return (PARSER_SALT_LENGTH
);
10008 salt
->salt_len
= salt_len
;
10010 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10012 salt
->salt_len
+= 22;
10014 return (PARSER_OK
);
10017 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10019 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10021 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10025 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10028 u32
*digest
= (u32
*) hash_buf
->digest
;
10030 salt_t
*salt
= hash_buf
->salt
;
10032 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10033 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10034 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10035 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10036 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10038 digest
[0] -= SHA1M_A
;
10039 digest
[1] -= SHA1M_B
;
10040 digest
[2] -= SHA1M_C
;
10041 digest
[3] -= SHA1M_D
;
10042 digest
[4] -= SHA1M_E
;
10044 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10046 uint salt_len
= input_len
- 40 - 1;
10048 char *salt_buf
= input_buf
+ 40 + 1;
10050 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10052 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10054 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10056 salt
->salt_len
= salt_len
;
10058 return (PARSER_OK
);
10061 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10063 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10065 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10069 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10072 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10074 char *iter_pos
= input_buf
+ 6;
10076 salt_t
*salt
= hash_buf
->salt
;
10078 uint iter
= atoi (iter_pos
);
10082 iter
= ROUNDS_DCC2
;
10085 salt
->salt_iter
= iter
- 1;
10087 char *salt_pos
= strchr (iter_pos
, '#');
10089 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10093 char *digest_pos
= strchr (salt_pos
, '#');
10095 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10099 uint salt_len
= digest_pos
- salt_pos
- 1;
10101 u32
*digest
= (u32
*) hash_buf
->digest
;
10103 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10104 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10105 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10106 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10108 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10110 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10112 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10114 salt
->salt_len
= salt_len
;
10116 return (PARSER_OK
);
10119 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10121 u32
*digest
= (u32
*) hash_buf
->digest
;
10123 salt_t
*salt
= hash_buf
->salt
;
10125 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10129 memcpy (&in
, input_buf
, input_len
);
10131 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10133 memcpy (digest
, in
.keymic
, 16);
10136 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10137 The phrase "Pairwise key expansion"
10138 Access Point Address (referred to as Authenticator Address AA)
10139 Supplicant Address (referred to as Supplicant Address SA)
10140 Access Point Nonce (referred to as Authenticator Anonce)
10141 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10144 uint salt_len
= strlen (in
.essid
);
10146 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10148 salt
->salt_len
= salt_len
;
10150 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10152 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10154 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10156 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10158 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10159 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10163 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10164 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10167 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10169 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10170 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10174 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10175 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10178 for (int i
= 0; i
< 25; i
++)
10180 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10183 wpa
->keyver
= in
.keyver
;
10185 if (wpa
->keyver
> 255)
10187 log_info ("ATTENTION!");
10188 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10189 log_info (" This could be due to a recent aircrack-ng bug.");
10190 log_info (" The key version was automatically reset to a reasonable value.");
10193 wpa
->keyver
&= 0xff;
10196 wpa
->eapol_size
= in
.eapol_size
;
10198 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10200 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10202 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10204 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10206 if (wpa
->keyver
== 1)
10212 digest
[0] = byte_swap_32 (digest
[0]);
10213 digest
[1] = byte_swap_32 (digest
[1]);
10214 digest
[2] = byte_swap_32 (digest
[2]);
10215 digest
[3] = byte_swap_32 (digest
[3]);
10217 for (int i
= 0; i
< 64; i
++)
10219 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10223 salt
->salt_buf
[10] = digest
[1];
10224 salt
->salt_buf
[11] = digest
[2];
10226 return (PARSER_OK
);
10229 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10231 u32
*digest
= (u32
*) hash_buf
->digest
;
10233 salt_t
*salt
= hash_buf
->salt
;
10235 if (input_len
== 0)
10237 log_error ("Password Safe v2 container not specified");
10242 FILE *fp
= fopen (input_buf
, "rb");
10246 log_error ("%s: %s", input_buf
, strerror (errno
));
10253 memset (&buf
, 0, sizeof (psafe2_hdr
));
10255 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10259 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10261 salt
->salt_buf
[0] = buf
.random
[0];
10262 salt
->salt_buf
[1] = buf
.random
[1];
10264 salt
->salt_len
= 8;
10265 salt
->salt_iter
= 1000;
10267 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10268 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10269 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10270 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10271 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10273 return (PARSER_OK
);
10276 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10278 u32
*digest
= (u32
*) hash_buf
->digest
;
10280 salt_t
*salt
= hash_buf
->salt
;
10282 if (input_len
== 0)
10284 log_error (".psafe3 not specified");
10289 FILE *fp
= fopen (input_buf
, "rb");
10293 log_error ("%s: %s", input_buf
, strerror (errno
));
10300 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10304 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10306 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10308 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10310 salt
->salt_iter
= in
.iterations
+ 1;
10312 salt
->salt_buf
[0] = in
.salt_buf
[0];
10313 salt
->salt_buf
[1] = in
.salt_buf
[1];
10314 salt
->salt_buf
[2] = in
.salt_buf
[2];
10315 salt
->salt_buf
[3] = in
.salt_buf
[3];
10316 salt
->salt_buf
[4] = in
.salt_buf
[4];
10317 salt
->salt_buf
[5] = in
.salt_buf
[5];
10318 salt
->salt_buf
[6] = in
.salt_buf
[6];
10319 salt
->salt_buf
[7] = in
.salt_buf
[7];
10321 salt
->salt_len
= 32;
10323 digest
[0] = in
.hash_buf
[0];
10324 digest
[1] = in
.hash_buf
[1];
10325 digest
[2] = in
.hash_buf
[2];
10326 digest
[3] = in
.hash_buf
[3];
10327 digest
[4] = in
.hash_buf
[4];
10328 digest
[5] = in
.hash_buf
[5];
10329 digest
[6] = in
.hash_buf
[6];
10330 digest
[7] = in
.hash_buf
[7];
10332 digest
[0] = byte_swap_32 (digest
[0]);
10333 digest
[1] = byte_swap_32 (digest
[1]);
10334 digest
[2] = byte_swap_32 (digest
[2]);
10335 digest
[3] = byte_swap_32 (digest
[3]);
10336 digest
[4] = byte_swap_32 (digest
[4]);
10337 digest
[5] = byte_swap_32 (digest
[5]);
10338 digest
[6] = byte_swap_32 (digest
[6]);
10339 digest
[7] = byte_swap_32 (digest
[7]);
10341 return (PARSER_OK
);
10344 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10346 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10348 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10350 u32
*digest
= (u32
*) hash_buf
->digest
;
10352 salt_t
*salt
= hash_buf
->salt
;
10354 char *iter_pos
= input_buf
+ 3;
10356 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10358 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10360 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10362 salt
->salt_iter
= salt_iter
;
10364 char *salt_pos
= iter_pos
+ 1;
10368 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10370 salt
->salt_len
= salt_len
;
10372 char *hash_pos
= salt_pos
+ salt_len
;
10374 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10376 return (PARSER_OK
);
10379 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10381 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10383 u32
*digest
= (u32
*) hash_buf
->digest
;
10385 salt_t
*salt
= hash_buf
->salt
;
10387 char *salt_pos
= input_buf
+ 3;
10389 uint iterations_len
= 0;
10391 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10395 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10397 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10398 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10402 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10406 iterations_len
+= 8;
10410 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10413 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10415 char *hash_pos
= strchr (salt_pos
, '$');
10417 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10419 uint salt_len
= hash_pos
- salt_pos
;
10421 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10423 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10425 salt
->salt_len
= salt_len
;
10429 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10431 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10433 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10435 return (PARSER_OK
);
10438 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10440 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10442 u32
*digest
= (u32
*) hash_buf
->digest
;
10444 salt_t
*salt
= hash_buf
->salt
;
10446 char *salt_pos
= input_buf
+ 6;
10448 uint iterations_len
= 0;
10450 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10454 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10456 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10457 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10461 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10465 iterations_len
+= 8;
10469 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10472 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10474 char *hash_pos
= strchr (salt_pos
, '$');
10476 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10478 uint salt_len
= hash_pos
- salt_pos
;
10480 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10482 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10484 salt
->salt_len
= salt_len
;
10488 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10490 return (PARSER_OK
);
10493 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10495 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10497 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10499 u32
*digest
= (u32
*) hash_buf
->digest
;
10501 salt_t
*salt
= hash_buf
->salt
;
10503 char *salt_pos
= input_buf
+ 14;
10505 char *hash_pos
= strchr (salt_pos
, '*');
10507 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10511 uint salt_len
= hash_pos
- salt_pos
- 1;
10513 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10515 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10517 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10519 salt
->salt_len
= salt_len
;
10521 u8 tmp_buf
[100] = { 0 };
10523 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10525 memcpy (digest
, tmp_buf
, 20);
10527 digest
[0] = byte_swap_32 (digest
[0]);
10528 digest
[1] = byte_swap_32 (digest
[1]);
10529 digest
[2] = byte_swap_32 (digest
[2]);
10530 digest
[3] = byte_swap_32 (digest
[3]);
10531 digest
[4] = byte_swap_32 (digest
[4]);
10533 digest
[0] -= SHA1M_A
;
10534 digest
[1] -= SHA1M_B
;
10535 digest
[2] -= SHA1M_C
;
10536 digest
[3] -= SHA1M_D
;
10537 digest
[4] -= SHA1M_E
;
10539 return (PARSER_OK
);
10542 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10544 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10546 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10548 if (c12
& 3) return (PARSER_HASH_VALUE
);
10550 u32
*digest
= (u32
*) hash_buf
->digest
;
10552 salt_t
*salt
= hash_buf
->salt
;
10554 // for ascii_digest
10555 salt
->salt_sign
[0] = input_buf
[0];
10556 salt
->salt_sign
[1] = input_buf
[1];
10558 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10559 | itoa64_to_int (input_buf
[1]) << 6;
10561 salt
->salt_len
= 2;
10563 u8 tmp_buf
[100] = { 0 };
10565 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10567 memcpy (digest
, tmp_buf
, 8);
10571 IP (digest
[0], digest
[1], tt
);
10576 return (PARSER_OK
);
10579 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10581 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10583 u32
*digest
= (u32
*) hash_buf
->digest
;
10585 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10586 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10587 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10588 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10590 digest
[0] = byte_swap_32 (digest
[0]);
10591 digest
[1] = byte_swap_32 (digest
[1]);
10592 digest
[2] = byte_swap_32 (digest
[2]);
10593 digest
[3] = byte_swap_32 (digest
[3]);
10595 digest
[0] -= MD4M_A
;
10596 digest
[1] -= MD4M_B
;
10597 digest
[2] -= MD4M_C
;
10598 digest
[3] -= MD4M_D
;
10600 return (PARSER_OK
);
10603 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10605 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10607 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10611 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10614 u32
*digest
= (u32
*) hash_buf
->digest
;
10616 salt_t
*salt
= hash_buf
->salt
;
10618 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10619 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10620 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10621 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10623 digest
[0] = byte_swap_32 (digest
[0]);
10624 digest
[1] = byte_swap_32 (digest
[1]);
10625 digest
[2] = byte_swap_32 (digest
[2]);
10626 digest
[3] = byte_swap_32 (digest
[3]);
10628 digest
[0] -= MD4M_A
;
10629 digest
[1] -= MD4M_B
;
10630 digest
[2] -= MD4M_C
;
10631 digest
[3] -= MD4M_D
;
10633 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10635 uint salt_len
= input_len
- 32 - 1;
10637 char *salt_buf
= input_buf
+ 32 + 1;
10639 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10641 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10643 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10645 salt
->salt_len
= salt_len
;
10647 return (PARSER_OK
);
10650 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10652 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10654 u32
*digest
= (u32
*) hash_buf
->digest
;
10656 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10657 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10658 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10659 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10661 digest
[0] = byte_swap_32 (digest
[0]);
10662 digest
[1] = byte_swap_32 (digest
[1]);
10663 digest
[2] = byte_swap_32 (digest
[2]);
10664 digest
[3] = byte_swap_32 (digest
[3]);
10666 digest
[0] -= MD5M_A
;
10667 digest
[1] -= MD5M_B
;
10668 digest
[2] -= MD5M_C
;
10669 digest
[3] -= MD5M_D
;
10671 return (PARSER_OK
);
10674 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10676 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) 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]);
10685 digest
[0] = byte_swap_32 (digest
[0]);
10686 digest
[1] = byte_swap_32 (digest
[1]);
10688 return (PARSER_OK
);
10691 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10693 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10695 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10699 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10702 u32
*digest
= (u32
*) hash_buf
->digest
;
10704 salt_t
*salt
= hash_buf
->salt
;
10706 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10707 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10708 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10709 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10711 digest
[0] = byte_swap_32 (digest
[0]);
10712 digest
[1] = byte_swap_32 (digest
[1]);
10713 digest
[2] = byte_swap_32 (digest
[2]);
10714 digest
[3] = byte_swap_32 (digest
[3]);
10716 digest
[0] -= MD5M_A
;
10717 digest
[1] -= MD5M_B
;
10718 digest
[2] -= MD5M_C
;
10719 digest
[3] -= MD5M_D
;
10721 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10723 uint salt_len
= input_len
- 32 - 1;
10725 char *salt_buf
= input_buf
+ 32 + 1;
10727 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10729 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10731 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10733 salt
->salt_len
= salt_len
;
10735 return (PARSER_OK
);
10738 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10740 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10742 u32
*digest
= (u32
*) hash_buf
->digest
;
10744 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10745 | itoa64_to_int (input_buf
[ 1]) << 6
10746 | itoa64_to_int (input_buf
[ 2]) << 12
10747 | itoa64_to_int (input_buf
[ 3]) << 18;
10748 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10749 | itoa64_to_int (input_buf
[ 5]) << 6
10750 | itoa64_to_int (input_buf
[ 6]) << 12
10751 | itoa64_to_int (input_buf
[ 7]) << 18;
10752 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10753 | itoa64_to_int (input_buf
[ 9]) << 6
10754 | itoa64_to_int (input_buf
[10]) << 12
10755 | itoa64_to_int (input_buf
[11]) << 18;
10756 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10757 | itoa64_to_int (input_buf
[13]) << 6
10758 | itoa64_to_int (input_buf
[14]) << 12
10759 | itoa64_to_int (input_buf
[15]) << 18;
10761 digest
[0] -= MD5M_A
;
10762 digest
[1] -= MD5M_B
;
10763 digest
[2] -= MD5M_C
;
10764 digest
[3] -= MD5M_D
;
10766 digest
[0] &= 0x00ffffff;
10767 digest
[1] &= 0x00ffffff;
10768 digest
[2] &= 0x00ffffff;
10769 digest
[3] &= 0x00ffffff;
10771 return (PARSER_OK
);
10774 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10776 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10778 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10782 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10785 u32
*digest
= (u32
*) hash_buf
->digest
;
10787 salt_t
*salt
= hash_buf
->salt
;
10789 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10790 | itoa64_to_int (input_buf
[ 1]) << 6
10791 | itoa64_to_int (input_buf
[ 2]) << 12
10792 | itoa64_to_int (input_buf
[ 3]) << 18;
10793 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10794 | itoa64_to_int (input_buf
[ 5]) << 6
10795 | itoa64_to_int (input_buf
[ 6]) << 12
10796 | itoa64_to_int (input_buf
[ 7]) << 18;
10797 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10798 | itoa64_to_int (input_buf
[ 9]) << 6
10799 | itoa64_to_int (input_buf
[10]) << 12
10800 | itoa64_to_int (input_buf
[11]) << 18;
10801 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10802 | itoa64_to_int (input_buf
[13]) << 6
10803 | itoa64_to_int (input_buf
[14]) << 12
10804 | itoa64_to_int (input_buf
[15]) << 18;
10806 digest
[0] -= MD5M_A
;
10807 digest
[1] -= MD5M_B
;
10808 digest
[2] -= MD5M_C
;
10809 digest
[3] -= MD5M_D
;
10811 digest
[0] &= 0x00ffffff;
10812 digest
[1] &= 0x00ffffff;
10813 digest
[2] &= 0x00ffffff;
10814 digest
[3] &= 0x00ffffff;
10816 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10818 uint salt_len
= input_len
- 16 - 1;
10820 char *salt_buf
= input_buf
+ 16 + 1;
10822 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10824 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10826 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10828 salt
->salt_len
= salt_len
;
10830 return (PARSER_OK
);
10833 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10835 key
[0] = (nthash
[0] >> 0);
10836 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10837 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10838 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10839 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10840 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10841 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10842 key
[7] = (nthash
[6] << 1);
10854 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10856 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10858 u32
*digest
= (u32
*) hash_buf
->digest
;
10860 salt_t
*salt
= hash_buf
->salt
;
10862 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10868 char *user_pos
= input_buf
;
10870 char *unused_pos
= strchr (user_pos
, ':');
10872 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10874 uint user_len
= unused_pos
- user_pos
;
10876 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10880 char *domain_pos
= strchr (unused_pos
, ':');
10882 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10884 uint unused_len
= domain_pos
- unused_pos
;
10886 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10890 char *srvchall_pos
= strchr (domain_pos
, ':');
10892 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10894 uint domain_len
= srvchall_pos
- domain_pos
;
10896 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10900 char *hash_pos
= strchr (srvchall_pos
, ':');
10902 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10904 uint srvchall_len
= hash_pos
- srvchall_pos
;
10906 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10910 char *clichall_pos
= strchr (hash_pos
, ':');
10912 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10914 uint hash_len
= clichall_pos
- hash_pos
;
10916 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10920 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10922 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10925 * store some data for later use
10928 netntlm
->user_len
= user_len
* 2;
10929 netntlm
->domain_len
= domain_len
* 2;
10930 netntlm
->srvchall_len
= srvchall_len
/ 2;
10931 netntlm
->clichall_len
= clichall_len
/ 2;
10933 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10934 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10937 * handle username and domainname
10940 for (uint i
= 0; i
< user_len
; i
++)
10942 *userdomain_ptr
++ = user_pos
[i
];
10943 *userdomain_ptr
++ = 0;
10946 for (uint i
= 0; i
< domain_len
; i
++)
10948 *userdomain_ptr
++ = domain_pos
[i
];
10949 *userdomain_ptr
++ = 0;
10953 * handle server challenge encoding
10956 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10958 const char p0
= srvchall_pos
[i
+ 0];
10959 const char p1
= srvchall_pos
[i
+ 1];
10961 *chall_ptr
++ = hex_convert (p1
) << 0
10962 | hex_convert (p0
) << 4;
10966 * handle client challenge encoding
10969 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10971 const char p0
= clichall_pos
[i
+ 0];
10972 const char p1
= clichall_pos
[i
+ 1];
10974 *chall_ptr
++ = hex_convert (p1
) << 0
10975 | hex_convert (p0
) << 4;
10982 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10984 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10986 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10988 salt
->salt_len
= salt_len
;
10990 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10991 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10992 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10993 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10995 digest
[0] = byte_swap_32 (digest
[0]);
10996 digest
[1] = byte_swap_32 (digest
[1]);
10997 digest
[2] = byte_swap_32 (digest
[2]);
10998 digest
[3] = byte_swap_32 (digest
[3]);
11000 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11002 uint digest_tmp
[2] = { 0 };
11004 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11005 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11007 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11008 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11010 /* special case 2: ESS */
11012 if (srvchall_len
== 48)
11014 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11016 uint w
[16] = { 0 };
11018 w
[ 0] = netntlm
->chall_buf
[6];
11019 w
[ 1] = netntlm
->chall_buf
[7];
11020 w
[ 2] = netntlm
->chall_buf
[0];
11021 w
[ 3] = netntlm
->chall_buf
[1];
11025 uint dgst
[4] = { 0 };
11034 salt
->salt_buf
[0] = dgst
[0];
11035 salt
->salt_buf
[1] = dgst
[1];
11039 /* precompute netntlmv1 exploit start */
11041 for (uint i
= 0; i
< 0x10000; i
++)
11043 uint key_md4
[2] = { i
, 0 };
11044 uint key_des
[2] = { 0, 0 };
11046 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11048 uint Kc
[16] = { 0 };
11049 uint Kd
[16] = { 0 };
11051 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11053 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11055 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11057 if (data3
[0] != digest_tmp
[0]) continue;
11058 if (data3
[1] != digest_tmp
[1]) continue;
11060 salt
->salt_buf
[2] = i
;
11062 salt
->salt_len
= 24;
11067 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11068 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11070 /* precompute netntlmv1 exploit stop */
11074 IP (digest
[0], digest
[1], tt
);
11075 IP (digest
[2], digest
[3], tt
);
11077 digest
[0] = rotr32 (digest
[0], 29);
11078 digest
[1] = rotr32 (digest
[1], 29);
11079 digest
[2] = rotr32 (digest
[2], 29);
11080 digest
[3] = rotr32 (digest
[3], 29);
11082 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11084 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11085 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11087 return (PARSER_OK
);
11090 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11092 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11094 u32
*digest
= (u32
*) hash_buf
->digest
;
11096 salt_t
*salt
= hash_buf
->salt
;
11098 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11104 char *user_pos
= input_buf
;
11106 char *unused_pos
= strchr (user_pos
, ':');
11108 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11110 uint user_len
= unused_pos
- user_pos
;
11112 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11116 char *domain_pos
= strchr (unused_pos
, ':');
11118 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11120 uint unused_len
= domain_pos
- unused_pos
;
11122 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11126 char *srvchall_pos
= strchr (domain_pos
, ':');
11128 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11130 uint domain_len
= srvchall_pos
- domain_pos
;
11132 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11136 char *hash_pos
= strchr (srvchall_pos
, ':');
11138 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11140 uint srvchall_len
= hash_pos
- srvchall_pos
;
11142 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11146 char *clichall_pos
= strchr (hash_pos
, ':');
11148 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11150 uint hash_len
= clichall_pos
- hash_pos
;
11152 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11156 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11158 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11160 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11163 * store some data for later use
11166 netntlm
->user_len
= user_len
* 2;
11167 netntlm
->domain_len
= domain_len
* 2;
11168 netntlm
->srvchall_len
= srvchall_len
/ 2;
11169 netntlm
->clichall_len
= clichall_len
/ 2;
11171 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11172 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11175 * handle username and domainname
11178 for (uint i
= 0; i
< user_len
; i
++)
11180 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11181 *userdomain_ptr
++ = 0;
11184 for (uint i
= 0; i
< domain_len
; i
++)
11186 *userdomain_ptr
++ = domain_pos
[i
];
11187 *userdomain_ptr
++ = 0;
11190 *userdomain_ptr
++ = 0x80;
11193 * handle server challenge encoding
11196 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11198 const char p0
= srvchall_pos
[i
+ 0];
11199 const char p1
= srvchall_pos
[i
+ 1];
11201 *chall_ptr
++ = hex_convert (p1
) << 0
11202 | hex_convert (p0
) << 4;
11206 * handle client challenge encoding
11209 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11211 const char p0
= clichall_pos
[i
+ 0];
11212 const char p1
= clichall_pos
[i
+ 1];
11214 *chall_ptr
++ = hex_convert (p1
) << 0
11215 | hex_convert (p0
) << 4;
11218 *chall_ptr
++ = 0x80;
11221 * handle hash itself
11224 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11225 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11226 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11227 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11229 digest
[0] = byte_swap_32 (digest
[0]);
11230 digest
[1] = byte_swap_32 (digest
[1]);
11231 digest
[2] = byte_swap_32 (digest
[2]);
11232 digest
[3] = byte_swap_32 (digest
[3]);
11235 * reuse challange data as salt_buf, its the buffer that is most likely unique
11238 salt
->salt_buf
[0] = 0;
11239 salt
->salt_buf
[1] = 0;
11240 salt
->salt_buf
[2] = 0;
11241 salt
->salt_buf
[3] = 0;
11242 salt
->salt_buf
[4] = 0;
11243 salt
->salt_buf
[5] = 0;
11244 salt
->salt_buf
[6] = 0;
11245 salt
->salt_buf
[7] = 0;
11249 uptr
= (uint
*) netntlm
->userdomain_buf
;
11251 for (uint i
= 0; i
< 16; i
+= 16)
11253 md5_64 (uptr
, salt
->salt_buf
);
11256 uptr
= (uint
*) netntlm
->chall_buf
;
11258 for (uint i
= 0; i
< 256; i
+= 16)
11260 md5_64 (uptr
, salt
->salt_buf
);
11263 salt
->salt_len
= 16;
11265 return (PARSER_OK
);
11268 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11270 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11272 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11276 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11279 u32
*digest
= (u32
*) hash_buf
->digest
;
11281 salt_t
*salt
= hash_buf
->salt
;
11283 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11284 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11285 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11286 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11288 digest
[0] = byte_swap_32 (digest
[0]);
11289 digest
[1] = byte_swap_32 (digest
[1]);
11290 digest
[2] = byte_swap_32 (digest
[2]);
11291 digest
[3] = byte_swap_32 (digest
[3]);
11293 digest
[0] -= MD5M_A
;
11294 digest
[1] -= MD5M_B
;
11295 digest
[2] -= MD5M_C
;
11296 digest
[3] -= MD5M_D
;
11298 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11300 uint salt_len
= input_len
- 32 - 1;
11302 char *salt_buf
= input_buf
+ 32 + 1;
11304 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11306 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11308 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11310 salt
->salt_len
= salt_len
;
11312 return (PARSER_OK
);
11315 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11317 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11319 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11323 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11326 u32
*digest
= (u32
*) hash_buf
->digest
;
11328 salt_t
*salt
= hash_buf
->salt
;
11330 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11331 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11332 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11333 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11335 digest
[0] = byte_swap_32 (digest
[0]);
11336 digest
[1] = byte_swap_32 (digest
[1]);
11337 digest
[2] = byte_swap_32 (digest
[2]);
11338 digest
[3] = byte_swap_32 (digest
[3]);
11340 digest
[0] -= MD5M_A
;
11341 digest
[1] -= MD5M_B
;
11342 digest
[2] -= MD5M_C
;
11343 digest
[3] -= MD5M_D
;
11345 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11347 uint salt_len
= input_len
- 32 - 1;
11349 char *salt_buf
= input_buf
+ 32 + 1;
11351 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11353 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11355 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11357 salt
->salt_len
= salt_len
;
11359 return (PARSER_OK
);
11362 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11364 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11366 u32
*digest
= (u32
*) hash_buf
->digest
;
11368 salt_t
*salt
= hash_buf
->salt
;
11370 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11371 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11372 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11373 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11375 digest
[0] = byte_swap_32 (digest
[0]);
11376 digest
[1] = byte_swap_32 (digest
[1]);
11377 digest
[2] = byte_swap_32 (digest
[2]);
11378 digest
[3] = byte_swap_32 (digest
[3]);
11380 digest
[0] -= MD5M_A
;
11381 digest
[1] -= MD5M_B
;
11382 digest
[2] -= MD5M_C
;
11383 digest
[3] -= MD5M_D
;
11386 * This is a virtual salt. While the algorithm is basically not salted
11387 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11388 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11391 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11393 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11395 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11397 salt
->salt_len
= salt_len
;
11399 return (PARSER_OK
);
11402 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11404 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11406 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11410 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11413 u32
*digest
= (u32
*) hash_buf
->digest
;
11415 salt_t
*salt
= hash_buf
->salt
;
11417 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11418 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11419 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11420 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11422 digest
[0] = byte_swap_32 (digest
[0]);
11423 digest
[1] = byte_swap_32 (digest
[1]);
11424 digest
[2] = byte_swap_32 (digest
[2]);
11425 digest
[3] = byte_swap_32 (digest
[3]);
11427 digest
[0] -= MD5M_A
;
11428 digest
[1] -= MD5M_B
;
11429 digest
[2] -= MD5M_C
;
11430 digest
[3] -= MD5M_D
;
11432 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11434 uint salt_len
= input_len
- 32 - 1;
11436 char *salt_buf
= input_buf
+ 32 + 1;
11438 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11440 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11442 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11444 salt
->salt_len
= salt_len
;
11446 return (PARSER_OK
);
11449 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11451 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11453 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11457 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11460 u32
*digest
= (u32
*) hash_buf
->digest
;
11462 salt_t
*salt
= hash_buf
->salt
;
11464 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11465 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11466 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11467 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11469 digest
[0] = byte_swap_32 (digest
[0]);
11470 digest
[1] = byte_swap_32 (digest
[1]);
11471 digest
[2] = byte_swap_32 (digest
[2]);
11472 digest
[3] = byte_swap_32 (digest
[3]);
11474 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11476 uint salt_len
= input_len
- 32 - 1;
11478 char *salt_buf
= input_buf
+ 32 + 1;
11480 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11482 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11484 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11486 salt
->salt_len
= salt_len
;
11488 return (PARSER_OK
);
11491 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11493 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11495 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11499 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11502 u32
*digest
= (u32
*) hash_buf
->digest
;
11504 salt_t
*salt
= hash_buf
->salt
;
11506 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11507 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11508 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11509 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11511 digest
[0] = byte_swap_32 (digest
[0]);
11512 digest
[1] = byte_swap_32 (digest
[1]);
11513 digest
[2] = byte_swap_32 (digest
[2]);
11514 digest
[3] = byte_swap_32 (digest
[3]);
11516 digest
[0] -= MD4M_A
;
11517 digest
[1] -= MD4M_B
;
11518 digest
[2] -= MD4M_C
;
11519 digest
[3] -= MD4M_D
;
11521 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11523 uint salt_len
= input_len
- 32 - 1;
11525 char *salt_buf
= input_buf
+ 32 + 1;
11527 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11529 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11531 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11533 salt
->salt_len
= salt_len
;
11535 return (PARSER_OK
);
11538 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11540 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11542 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11546 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11549 u32
*digest
= (u32
*) hash_buf
->digest
;
11551 salt_t
*salt
= hash_buf
->salt
;
11553 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11554 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11555 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11556 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11558 digest
[0] = byte_swap_32 (digest
[0]);
11559 digest
[1] = byte_swap_32 (digest
[1]);
11560 digest
[2] = byte_swap_32 (digest
[2]);
11561 digest
[3] = byte_swap_32 (digest
[3]);
11563 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11565 uint salt_len
= input_len
- 32 - 1;
11567 char *salt_buf
= input_buf
+ 32 + 1;
11569 uint salt_pc_block
[16] = { 0 };
11571 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11573 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11575 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11577 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11579 salt_pc_block
[14] = salt_len
* 8;
11581 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11583 md5_64 (salt_pc_block
, salt_pc_digest
);
11585 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11586 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11587 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11588 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11590 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11592 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11594 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11596 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11597 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11598 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11599 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11601 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11603 return (PARSER_OK
);
11606 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11608 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11610 u32
*digest
= (u32
*) hash_buf
->digest
;
11612 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11613 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11614 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11615 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11616 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11618 digest
[0] -= SHA1M_A
;
11619 digest
[1] -= SHA1M_B
;
11620 digest
[2] -= SHA1M_C
;
11621 digest
[3] -= SHA1M_D
;
11622 digest
[4] -= SHA1M_E
;
11624 return (PARSER_OK
);
11627 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11629 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11631 u32
*digest
= (u32
*) hash_buf
->digest
;
11633 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11634 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11635 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11636 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11637 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11639 return (PARSER_OK
);
11642 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11644 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11646 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11650 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11653 u32
*digest
= (u32
*) hash_buf
->digest
;
11655 salt_t
*salt
= hash_buf
->salt
;
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 digest
[0] -= SHA1M_A
;
11664 digest
[1] -= SHA1M_B
;
11665 digest
[2] -= SHA1M_C
;
11666 digest
[3] -= SHA1M_D
;
11667 digest
[4] -= SHA1M_E
;
11669 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11671 uint salt_len
= input_len
- 40 - 1;
11673 char *salt_buf
= input_buf
+ 40 + 1;
11675 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11677 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11679 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11681 salt
->salt_len
= salt_len
;
11683 return (PARSER_OK
);
11686 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11688 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11690 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11692 u32
*digest
= (u32
*) hash_buf
->digest
;
11694 u8 tmp_buf
[100] = { 0 };
11696 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11698 memcpy (digest
, tmp_buf
, 20);
11700 digest
[0] = byte_swap_32 (digest
[0]);
11701 digest
[1] = byte_swap_32 (digest
[1]);
11702 digest
[2] = byte_swap_32 (digest
[2]);
11703 digest
[3] = byte_swap_32 (digest
[3]);
11704 digest
[4] = byte_swap_32 (digest
[4]);
11706 digest
[0] -= SHA1M_A
;
11707 digest
[1] -= SHA1M_B
;
11708 digest
[2] -= SHA1M_C
;
11709 digest
[3] -= SHA1M_D
;
11710 digest
[4] -= SHA1M_E
;
11712 return (PARSER_OK
);
11715 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11717 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11719 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11721 u32
*digest
= (u32
*) hash_buf
->digest
;
11723 salt_t
*salt
= hash_buf
->salt
;
11725 u8 tmp_buf
[100] = { 0 };
11727 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11729 memcpy (digest
, tmp_buf
, 20);
11731 salt
->salt_len
= tmp_len
- 20;
11733 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11735 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11737 char *ptr
= (char *) salt
->salt_buf
;
11739 ptr
[salt
->salt_len
] = 0x80;
11742 digest
[0] = byte_swap_32 (digest
[0]);
11743 digest
[1] = byte_swap_32 (digest
[1]);
11744 digest
[2] = byte_swap_32 (digest
[2]);
11745 digest
[3] = byte_swap_32 (digest
[3]);
11746 digest
[4] = byte_swap_32 (digest
[4]);
11748 digest
[0] -= SHA1M_A
;
11749 digest
[1] -= SHA1M_B
;
11750 digest
[2] -= SHA1M_C
;
11751 digest
[3] -= SHA1M_D
;
11752 digest
[4] -= SHA1M_E
;
11754 return (PARSER_OK
);
11757 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11759 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11761 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11763 u32
*digest
= (u32
*) hash_buf
->digest
;
11765 salt_t
*salt
= hash_buf
->salt
;
11767 char *salt_buf
= input_buf
+ 6;
11771 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11773 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11775 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11777 salt
->salt_len
= salt_len
;
11779 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11781 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11782 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11783 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11784 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11785 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11787 digest
[0] -= SHA1M_A
;
11788 digest
[1] -= SHA1M_B
;
11789 digest
[2] -= SHA1M_C
;
11790 digest
[3] -= SHA1M_D
;
11791 digest
[4] -= SHA1M_E
;
11793 return (PARSER_OK
);
11796 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11798 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11800 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11802 u32
*digest
= (u32
*) hash_buf
->digest
;
11804 salt_t
*salt
= hash_buf
->salt
;
11806 char *salt_buf
= input_buf
+ 6;
11810 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11812 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11814 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11816 salt
->salt_len
= salt_len
;
11818 char *hash_pos
= input_buf
+ 6 + 8;
11820 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11821 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11822 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11823 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11824 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11826 digest
[0] -= SHA1M_A
;
11827 digest
[1] -= SHA1M_B
;
11828 digest
[2] -= SHA1M_C
;
11829 digest
[3] -= SHA1M_D
;
11830 digest
[4] -= SHA1M_E
;
11832 return (PARSER_OK
);
11835 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11837 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11839 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11841 u64
*digest
= (u64
*) hash_buf
->digest
;
11843 salt_t
*salt
= hash_buf
->salt
;
11845 char *salt_buf
= input_buf
+ 6;
11849 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11851 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11853 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11855 salt
->salt_len
= salt_len
;
11857 char *hash_pos
= input_buf
+ 6 + 8;
11859 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11860 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11861 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11862 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11863 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11864 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11865 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11866 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11868 digest
[0] -= SHA512M_A
;
11869 digest
[1] -= SHA512M_B
;
11870 digest
[2] -= SHA512M_C
;
11871 digest
[3] -= SHA512M_D
;
11872 digest
[4] -= SHA512M_E
;
11873 digest
[5] -= SHA512M_F
;
11874 digest
[6] -= SHA512M_G
;
11875 digest
[7] -= SHA512M_H
;
11877 return (PARSER_OK
);
11880 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11882 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11884 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11888 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11891 u32
*digest
= (u32
*) hash_buf
->digest
;
11893 salt_t
*salt
= hash_buf
->salt
;
11895 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11896 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11900 digest
[0] = byte_swap_32 (digest
[0]);
11901 digest
[1] = byte_swap_32 (digest
[1]);
11903 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11905 uint salt_len
= input_len
- 16 - 1;
11907 char *salt_buf
= input_buf
+ 16 + 1;
11909 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11911 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11913 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11915 salt
->salt_len
= salt_len
;
11917 return (PARSER_OK
);
11920 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11922 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11924 u32
*digest
= (u32
*) hash_buf
->digest
;
11926 salt_t
*salt
= hash_buf
->salt
;
11928 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11929 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11930 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11931 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11932 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11934 digest
[0] -= SHA1M_A
;
11935 digest
[1] -= SHA1M_B
;
11936 digest
[2] -= SHA1M_C
;
11937 digest
[3] -= SHA1M_D
;
11938 digest
[4] -= SHA1M_E
;
11940 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11942 uint salt_len
= input_len
- 40 - 1;
11944 char *salt_buf
= input_buf
+ 40 + 1;
11946 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11948 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11950 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11952 salt
->salt_len
= salt_len
;
11954 return (PARSER_OK
);
11957 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11959 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11961 u32
*digest
= (u32
*) hash_buf
->digest
;
11963 salt_t
*salt
= hash_buf
->salt
;
11965 char *hash_pos
= input_buf
;
11967 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11968 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11969 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
11970 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
11971 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
11972 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
11973 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
11974 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
11975 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
11976 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
11977 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
11978 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
11979 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
11980 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
11981 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
11982 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
11984 char *salt_pos
= input_buf
+ 128;
11986 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
11987 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
11988 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
11989 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
11991 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11992 salt
->salt_len
= 16;
11994 return (PARSER_OK
);
11997 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11999 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12001 u32
*digest
= (u32
*) hash_buf
->digest
;
12003 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12004 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12005 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12006 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12007 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12008 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12009 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12010 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12012 digest
[0] -= SHA256M_A
;
12013 digest
[1] -= SHA256M_B
;
12014 digest
[2] -= SHA256M_C
;
12015 digest
[3] -= SHA256M_D
;
12016 digest
[4] -= SHA256M_E
;
12017 digest
[5] -= SHA256M_F
;
12018 digest
[6] -= SHA256M_G
;
12019 digest
[7] -= SHA256M_H
;
12021 return (PARSER_OK
);
12024 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12026 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12028 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12032 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12035 u32
*digest
= (u32
*) hash_buf
->digest
;
12037 salt_t
*salt
= hash_buf
->salt
;
12039 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12040 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12041 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12042 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12043 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12044 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12045 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12046 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12048 digest
[0] -= SHA256M_A
;
12049 digest
[1] -= SHA256M_B
;
12050 digest
[2] -= SHA256M_C
;
12051 digest
[3] -= SHA256M_D
;
12052 digest
[4] -= SHA256M_E
;
12053 digest
[5] -= SHA256M_F
;
12054 digest
[6] -= SHA256M_G
;
12055 digest
[7] -= SHA256M_H
;
12057 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12059 uint salt_len
= input_len
- 64 - 1;
12061 char *salt_buf
= input_buf
+ 64 + 1;
12063 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12065 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12067 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12069 salt
->salt_len
= salt_len
;
12071 return (PARSER_OK
);
12074 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12076 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12078 u64
*digest
= (u64
*) hash_buf
->digest
;
12080 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12081 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12082 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12083 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12084 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12085 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12089 digest
[0] -= SHA384M_A
;
12090 digest
[1] -= SHA384M_B
;
12091 digest
[2] -= SHA384M_C
;
12092 digest
[3] -= SHA384M_D
;
12093 digest
[4] -= SHA384M_E
;
12094 digest
[5] -= SHA384M_F
;
12098 return (PARSER_OK
);
12101 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12103 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12105 u64
*digest
= (u64
*) hash_buf
->digest
;
12107 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12108 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12109 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12110 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12111 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12112 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12113 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12114 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12116 digest
[0] -= SHA512M_A
;
12117 digest
[1] -= SHA512M_B
;
12118 digest
[2] -= SHA512M_C
;
12119 digest
[3] -= SHA512M_D
;
12120 digest
[4] -= SHA512M_E
;
12121 digest
[5] -= SHA512M_F
;
12122 digest
[6] -= SHA512M_G
;
12123 digest
[7] -= SHA512M_H
;
12125 return (PARSER_OK
);
12128 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12130 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12132 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12136 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12139 u64
*digest
= (u64
*) hash_buf
->digest
;
12141 salt_t
*salt
= hash_buf
->salt
;
12143 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12144 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12145 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12146 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12147 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12148 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12149 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12150 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12152 digest
[0] -= SHA512M_A
;
12153 digest
[1] -= SHA512M_B
;
12154 digest
[2] -= SHA512M_C
;
12155 digest
[3] -= SHA512M_D
;
12156 digest
[4] -= SHA512M_E
;
12157 digest
[5] -= SHA512M_F
;
12158 digest
[6] -= SHA512M_G
;
12159 digest
[7] -= SHA512M_H
;
12161 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12163 uint salt_len
= input_len
- 128 - 1;
12165 char *salt_buf
= input_buf
+ 128 + 1;
12167 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12169 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12171 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12173 salt
->salt_len
= salt_len
;
12175 return (PARSER_OK
);
12178 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12180 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12182 u64
*digest
= (u64
*) hash_buf
->digest
;
12184 salt_t
*salt
= hash_buf
->salt
;
12186 char *salt_pos
= input_buf
+ 3;
12188 uint iterations_len
= 0;
12190 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12194 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12196 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12197 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12201 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12205 iterations_len
+= 8;
12209 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12212 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12214 char *hash_pos
= strchr (salt_pos
, '$');
12216 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12218 uint salt_len
= hash_pos
- salt_pos
;
12220 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12222 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12224 salt
->salt_len
= salt_len
;
12228 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12230 return (PARSER_OK
);
12233 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12235 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12237 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12239 u64
*digest
= (u64
*) hash_buf
->digest
;
12241 salt_t
*salt
= hash_buf
->salt
;
12243 uint keccak_mdlen
= input_len
/ 2;
12245 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12247 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12249 digest
[i
] = byte_swap_64 (digest
[i
]);
12252 salt
->keccak_mdlen
= keccak_mdlen
;
12254 return (PARSER_OK
);
12257 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12259 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12261 u32
*digest
= (u32
*) hash_buf
->digest
;
12263 salt_t
*salt
= hash_buf
->salt
;
12265 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12268 * Parse that strange long line
12273 size_t in_len
[9] = { 0 };
12275 in_off
[0] = strtok (input_buf
, ":");
12277 in_len
[0] = strlen (in_off
[0]);
12281 for (i
= 1; i
< 9; i
++)
12283 in_off
[i
] = strtok (NULL
, ":");
12285 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12287 in_len
[i
] = strlen (in_off
[i
]);
12290 char *ptr
= (char *) ikepsk
->msg_buf
;
12292 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12293 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12294 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12295 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12296 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12297 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12301 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12303 ptr
= (char *) ikepsk
->nr_buf
;
12305 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12306 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12310 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12313 * Store to database
12318 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12319 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12320 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12321 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12323 digest
[0] = byte_swap_32 (digest
[0]);
12324 digest
[1] = byte_swap_32 (digest
[1]);
12325 digest
[2] = byte_swap_32 (digest
[2]);
12326 digest
[3] = byte_swap_32 (digest
[3]);
12328 salt
->salt_len
= 32;
12330 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12331 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12332 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12333 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12334 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12335 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12336 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12337 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12339 return (PARSER_OK
);
12342 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12344 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12346 u32
*digest
= (u32
*) hash_buf
->digest
;
12348 salt_t
*salt
= hash_buf
->salt
;
12350 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12353 * Parse that strange long line
12358 size_t in_len
[9] = { 0 };
12360 in_off
[0] = strtok (input_buf
, ":");
12362 in_len
[0] = strlen (in_off
[0]);
12366 for (i
= 1; i
< 9; i
++)
12368 in_off
[i
] = strtok (NULL
, ":");
12370 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12372 in_len
[i
] = strlen (in_off
[i
]);
12375 char *ptr
= (char *) ikepsk
->msg_buf
;
12377 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12378 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12379 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12380 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12381 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12382 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12386 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12388 ptr
= (char *) ikepsk
->nr_buf
;
12390 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12391 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12395 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12398 * Store to database
12403 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12404 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12405 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12406 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12407 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12409 salt
->salt_len
= 32;
12411 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12412 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12413 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12414 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12415 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12416 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12417 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12418 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12420 return (PARSER_OK
);
12423 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12425 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12427 u32
*digest
= (u32
*) hash_buf
->digest
;
12429 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12430 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12431 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12432 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12433 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12435 digest
[0] = byte_swap_32 (digest
[0]);
12436 digest
[1] = byte_swap_32 (digest
[1]);
12437 digest
[2] = byte_swap_32 (digest
[2]);
12438 digest
[3] = byte_swap_32 (digest
[3]);
12439 digest
[4] = byte_swap_32 (digest
[4]);
12441 return (PARSER_OK
);
12444 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12446 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12448 u32
*digest
= (u32
*) hash_buf
->digest
;
12450 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12451 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12452 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12453 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12454 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12455 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12456 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12457 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12458 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12459 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12460 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12461 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12462 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12463 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12464 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12465 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12467 return (PARSER_OK
);
12470 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12472 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12474 u32
*digest
= (u32
*) hash_buf
->digest
;
12476 salt_t
*salt
= hash_buf
->salt
;
12478 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12479 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12480 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12481 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12482 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12484 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12486 uint salt_len
= input_len
- 40 - 1;
12488 char *salt_buf
= input_buf
+ 40 + 1;
12490 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12492 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12494 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12496 salt
->salt_len
= salt_len
;
12498 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12500 return (PARSER_OK
);
12503 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12505 u32
*digest
= (u32
*) hash_buf
->digest
;
12507 salt_t
*salt
= hash_buf
->salt
;
12509 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12511 if (input_len
== 0)
12513 log_error ("TrueCrypt container not specified");
12518 FILE *fp
= fopen (input_buf
, "rb");
12522 log_error ("%s: %s", input_buf
, strerror (errno
));
12527 char buf
[512] = { 0 };
12529 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12533 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12535 memcpy (tc
->salt_buf
, buf
, 64);
12537 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12539 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12541 salt
->salt_len
= 4;
12543 salt
->salt_iter
= 1000 - 1;
12545 digest
[0] = tc
->data_buf
[0];
12547 return (PARSER_OK
);
12550 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12552 u32
*digest
= (u32
*) hash_buf
->digest
;
12554 salt_t
*salt
= hash_buf
->salt
;
12556 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12558 if (input_len
== 0)
12560 log_error ("TrueCrypt container not specified");
12565 FILE *fp
= fopen (input_buf
, "rb");
12569 log_error ("%s: %s", input_buf
, strerror (errno
));
12574 char buf
[512] = { 0 };
12576 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12580 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12582 memcpy (tc
->salt_buf
, buf
, 64);
12584 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12586 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12588 salt
->salt_len
= 4;
12590 salt
->salt_iter
= 2000 - 1;
12592 digest
[0] = tc
->data_buf
[0];
12594 return (PARSER_OK
);
12597 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12599 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12601 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12603 u32
*digest
= (u32
*) hash_buf
->digest
;
12605 salt_t
*salt
= hash_buf
->salt
;
12607 char *salt_pos
= input_buf
+ 6;
12609 char *hash_pos
= strchr (salt_pos
, '$');
12611 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12613 uint salt_len
= hash_pos
- salt_pos
;
12615 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12617 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12619 salt
->salt_len
= salt_len
;
12621 salt
->salt_iter
= 1000;
12625 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12627 return (PARSER_OK
);
12630 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12632 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12634 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12636 u32
*digest
= (u32
*) hash_buf
->digest
;
12638 salt_t
*salt
= hash_buf
->salt
;
12640 char *iter_pos
= input_buf
+ 7;
12642 char *salt_pos
= strchr (iter_pos
, '$');
12644 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12648 char *hash_pos
= strchr (salt_pos
, '$');
12650 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12652 uint salt_len
= hash_pos
- salt_pos
;
12654 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12656 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12658 salt
->salt_len
= salt_len
;
12660 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12662 salt
->salt_sign
[0] = atoi (salt_iter
);
12664 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12668 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12670 digest
[0] = byte_swap_32 (digest
[0]);
12671 digest
[1] = byte_swap_32 (digest
[1]);
12672 digest
[2] = byte_swap_32 (digest
[2]);
12673 digest
[3] = byte_swap_32 (digest
[3]);
12674 digest
[4] = byte_swap_32 (digest
[4]);
12676 return (PARSER_OK
);
12679 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12681 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12683 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12685 u32
*digest
= (u32
*) hash_buf
->digest
;
12687 salt_t
*salt
= hash_buf
->salt
;
12689 char *iter_pos
= input_buf
+ 9;
12691 char *salt_pos
= strchr (iter_pos
, '$');
12693 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12697 char *hash_pos
= strchr (salt_pos
, '$');
12699 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12701 uint salt_len
= hash_pos
- salt_pos
;
12703 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12705 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12707 salt
->salt_len
= salt_len
;
12709 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12711 salt
->salt_sign
[0] = atoi (salt_iter
);
12713 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12717 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12719 digest
[0] = byte_swap_32 (digest
[0]);
12720 digest
[1] = byte_swap_32 (digest
[1]);
12721 digest
[2] = byte_swap_32 (digest
[2]);
12722 digest
[3] = byte_swap_32 (digest
[3]);
12723 digest
[4] = byte_swap_32 (digest
[4]);
12724 digest
[5] = byte_swap_32 (digest
[5]);
12725 digest
[6] = byte_swap_32 (digest
[6]);
12726 digest
[7] = byte_swap_32 (digest
[7]);
12728 return (PARSER_OK
);
12731 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12733 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12735 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12737 u64
*digest
= (u64
*) hash_buf
->digest
;
12739 salt_t
*salt
= hash_buf
->salt
;
12741 char *iter_pos
= input_buf
+ 9;
12743 char *salt_pos
= strchr (iter_pos
, '$');
12745 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12749 char *hash_pos
= strchr (salt_pos
, '$');
12751 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12753 uint salt_len
= hash_pos
- salt_pos
;
12755 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12757 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12759 salt
->salt_len
= salt_len
;
12761 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12763 salt
->salt_sign
[0] = atoi (salt_iter
);
12765 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12769 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12771 digest
[0] = byte_swap_64 (digest
[0]);
12772 digest
[1] = byte_swap_64 (digest
[1]);
12773 digest
[2] = byte_swap_64 (digest
[2]);
12774 digest
[3] = byte_swap_64 (digest
[3]);
12775 digest
[4] = byte_swap_64 (digest
[4]);
12776 digest
[5] = byte_swap_64 (digest
[5]);
12777 digest
[6] = byte_swap_64 (digest
[6]);
12778 digest
[7] = byte_swap_64 (digest
[7]);
12780 return (PARSER_OK
);
12783 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12785 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12787 u32
*digest
= (u32
*) hash_buf
->digest
;
12789 salt_t
*salt
= hash_buf
->salt
;
12791 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12797 char *iterations_pos
= input_buf
;
12799 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12801 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12803 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12805 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12809 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12811 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12813 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12815 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12817 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12819 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12824 * pbkdf2 iterations
12827 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12830 * handle salt encoding
12833 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12835 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12837 const char p0
= saltbuf_pos
[i
+ 0];
12838 const char p1
= saltbuf_pos
[i
+ 1];
12840 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12841 | hex_convert (p0
) << 4;
12844 salt
->salt_len
= saltbuf_len
/ 2;
12847 * handle cipher encoding
12850 uint
*tmp
= (uint
*) mymalloc (32);
12852 char *cipherbuf_ptr
= (char *) tmp
;
12854 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12856 const char p0
= cipherbuf_pos
[i
+ 0];
12857 const char p1
= cipherbuf_pos
[i
+ 1];
12859 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12860 | hex_convert (p0
) << 4;
12863 // iv is stored at salt_buf 4 (length 16)
12864 // data is stored at salt_buf 8 (length 16)
12866 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12867 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12868 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12869 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12871 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12872 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12873 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12874 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12878 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12880 const char p0
= cipherbuf_pos
[j
+ 0];
12881 const char p1
= cipherbuf_pos
[j
+ 1];
12883 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12884 | hex_convert (p0
) << 4;
12891 digest
[0] = 0x10101010;
12892 digest
[1] = 0x10101010;
12893 digest
[2] = 0x10101010;
12894 digest
[3] = 0x10101010;
12896 return (PARSER_OK
);
12899 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12901 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12903 u32
*digest
= (u32
*) hash_buf
->digest
;
12905 salt_t
*salt
= hash_buf
->salt
;
12907 char *hashbuf_pos
= input_buf
;
12909 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12911 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12913 uint hash_len
= iterations_pos
- hashbuf_pos
;
12915 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12919 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12921 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12923 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12927 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12929 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12931 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12933 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12935 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12937 salt
->salt_len
= salt_len
;
12939 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12941 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
12942 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
12943 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
12944 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
12946 return (PARSER_OK
);
12949 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12951 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12953 u32
*digest
= (u32
*) hash_buf
->digest
;
12955 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12956 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12957 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12958 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12959 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12960 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12961 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12962 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12964 digest
[0] = byte_swap_32 (digest
[0]);
12965 digest
[1] = byte_swap_32 (digest
[1]);
12966 digest
[2] = byte_swap_32 (digest
[2]);
12967 digest
[3] = byte_swap_32 (digest
[3]);
12968 digest
[4] = byte_swap_32 (digest
[4]);
12969 digest
[5] = byte_swap_32 (digest
[5]);
12970 digest
[6] = byte_swap_32 (digest
[6]);
12971 digest
[7] = byte_swap_32 (digest
[7]);
12973 return (PARSER_OK
);
12976 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12978 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12980 u32
*digest
= (u32
*) hash_buf
->digest
;
12982 salt_t
*salt
= hash_buf
->salt
;
12984 char *salt_pos
= input_buf
+ 3;
12986 uint iterations_len
= 0;
12988 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12992 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12994 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12995 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12999 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13003 iterations_len
+= 8;
13007 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13010 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13012 char *hash_pos
= strchr (salt_pos
, '$');
13014 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13016 uint salt_len
= hash_pos
- salt_pos
;
13018 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13020 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13022 salt
->salt_len
= salt_len
;
13026 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13028 return (PARSER_OK
);
13031 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13033 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13035 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13037 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13039 u64
*digest
= (u64
*) hash_buf
->digest
;
13041 salt_t
*salt
= hash_buf
->salt
;
13043 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13045 char *iter_pos
= input_buf
+ 4;
13047 char *salt_pos
= strchr (iter_pos
, '$');
13049 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13053 char *hash_pos
= strchr (salt_pos
, '$');
13055 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13057 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13061 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13062 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13063 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13064 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13065 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13066 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13067 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13068 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13070 uint salt_len
= hash_pos
- salt_pos
- 1;
13072 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13074 salt
->salt_len
= salt_len
/ 2;
13076 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13077 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13078 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13079 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13080 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13081 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13082 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13083 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13085 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13086 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13087 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13088 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13089 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13090 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13091 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13092 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13093 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13094 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13096 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13098 salt
->salt_iter
= atoi (iter_pos
) - 1;
13100 return (PARSER_OK
);
13103 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13105 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13107 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13109 u32
*digest
= (u32
*) hash_buf
->digest
;
13111 salt_t
*salt
= hash_buf
->salt
;
13113 char *salt_pos
= input_buf
+ 14;
13115 char *hash_pos
= strchr (salt_pos
, '*');
13117 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13121 uint salt_len
= hash_pos
- salt_pos
- 1;
13123 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13125 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13127 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13129 salt
->salt_len
= salt_len
;
13131 u8 tmp_buf
[100] = { 0 };
13133 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13135 memcpy (digest
, tmp_buf
, 32);
13137 digest
[0] = byte_swap_32 (digest
[0]);
13138 digest
[1] = byte_swap_32 (digest
[1]);
13139 digest
[2] = byte_swap_32 (digest
[2]);
13140 digest
[3] = byte_swap_32 (digest
[3]);
13141 digest
[4] = byte_swap_32 (digest
[4]);
13142 digest
[5] = byte_swap_32 (digest
[5]);
13143 digest
[6] = byte_swap_32 (digest
[6]);
13144 digest
[7] = byte_swap_32 (digest
[7]);
13146 digest
[0] -= SHA256M_A
;
13147 digest
[1] -= SHA256M_B
;
13148 digest
[2] -= SHA256M_C
;
13149 digest
[3] -= SHA256M_D
;
13150 digest
[4] -= SHA256M_E
;
13151 digest
[5] -= SHA256M_F
;
13152 digest
[6] -= SHA256M_G
;
13153 digest
[7] -= SHA256M_H
;
13155 return (PARSER_OK
);
13158 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13160 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13162 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13164 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13166 u64
*digest
= (u64
*) hash_buf
->digest
;
13168 salt_t
*salt
= hash_buf
->salt
;
13170 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13172 char *iter_pos
= input_buf
+ 19;
13174 char *salt_pos
= strchr (iter_pos
, '.');
13176 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13180 char *hash_pos
= strchr (salt_pos
, '.');
13182 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13184 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13188 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13189 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13190 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13191 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13192 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13193 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13194 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13195 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13197 uint salt_len
= hash_pos
- salt_pos
- 1;
13201 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13205 for (i
= 0; i
< salt_len
; i
++)
13207 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13210 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13211 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13213 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13215 salt
->salt_len
= salt_len
;
13217 salt
->salt_iter
= atoi (iter_pos
) - 1;
13219 return (PARSER_OK
);
13222 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13224 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13226 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13228 u64
*digest
= (u64
*) hash_buf
->digest
;
13230 salt_t
*salt
= hash_buf
->salt
;
13232 u8 tmp_buf
[120] = { 0 };
13234 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13236 memcpy (digest
, tmp_buf
, 64);
13238 digest
[0] = byte_swap_64 (digest
[0]);
13239 digest
[1] = byte_swap_64 (digest
[1]);
13240 digest
[2] = byte_swap_64 (digest
[2]);
13241 digest
[3] = byte_swap_64 (digest
[3]);
13242 digest
[4] = byte_swap_64 (digest
[4]);
13243 digest
[5] = byte_swap_64 (digest
[5]);
13244 digest
[6] = byte_swap_64 (digest
[6]);
13245 digest
[7] = byte_swap_64 (digest
[7]);
13247 digest
[0] -= SHA512M_A
;
13248 digest
[1] -= SHA512M_B
;
13249 digest
[2] -= SHA512M_C
;
13250 digest
[3] -= SHA512M_D
;
13251 digest
[4] -= SHA512M_E
;
13252 digest
[5] -= SHA512M_F
;
13253 digest
[6] -= SHA512M_G
;
13254 digest
[7] -= SHA512M_H
;
13256 salt
->salt_len
= tmp_len
- 64;
13258 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13260 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13262 char *ptr
= (char *) salt
->salt_buf
;
13264 ptr
[salt
->salt_len
] = 0x80;
13267 return (PARSER_OK
);
13270 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13272 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13274 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13278 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13281 u32
*digest
= (u32
*) hash_buf
->digest
;
13283 salt_t
*salt
= hash_buf
->salt
;
13285 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13286 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13287 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13288 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13290 digest
[0] = byte_swap_32 (digest
[0]);
13291 digest
[1] = byte_swap_32 (digest
[1]);
13292 digest
[2] = byte_swap_32 (digest
[2]);
13293 digest
[3] = byte_swap_32 (digest
[3]);
13295 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13297 uint salt_len
= input_len
- 32 - 1;
13299 char *salt_buf
= input_buf
+ 32 + 1;
13301 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13303 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13305 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13307 salt
->salt_len
= salt_len
;
13309 return (PARSER_OK
);
13312 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13314 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13316 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13320 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13323 u32
*digest
= (u32
*) hash_buf
->digest
;
13325 salt_t
*salt
= hash_buf
->salt
;
13327 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13328 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13329 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13330 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13331 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13333 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13335 uint salt_len
= input_len
- 40 - 1;
13337 char *salt_buf
= input_buf
+ 40 + 1;
13339 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13341 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13343 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13345 salt
->salt_len
= salt_len
;
13347 return (PARSER_OK
);
13350 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13352 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13354 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13358 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13361 u32
*digest
= (u32
*) hash_buf
->digest
;
13363 salt_t
*salt
= hash_buf
->salt
;
13365 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13366 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13367 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13368 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13369 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13370 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13371 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13372 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13374 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13376 uint salt_len
= input_len
- 64 - 1;
13378 char *salt_buf
= input_buf
+ 64 + 1;
13380 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13382 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13384 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13386 salt
->salt_len
= salt_len
;
13388 return (PARSER_OK
);
13391 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13393 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13395 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13399 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13402 u64
*digest
= (u64
*) hash_buf
->digest
;
13404 salt_t
*salt
= hash_buf
->salt
;
13406 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13407 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13408 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13409 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13410 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13411 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13412 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13413 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13415 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13417 uint salt_len
= input_len
- 128 - 1;
13419 char *salt_buf
= input_buf
+ 128 + 1;
13421 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13423 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13425 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13427 salt
->salt_len
= salt_len
;
13429 return (PARSER_OK
);
13432 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13434 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13436 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13438 u32
*digest
= (u32
*) hash_buf
->digest
;
13440 salt_t
*salt
= hash_buf
->salt
;
13442 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13448 char *user_pos
= input_buf
+ 10 + 1;
13450 char *realm_pos
= strchr (user_pos
, '$');
13452 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13454 uint user_len
= realm_pos
- user_pos
;
13456 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13460 char *salt_pos
= strchr (realm_pos
, '$');
13462 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13464 uint realm_len
= salt_pos
- realm_pos
;
13466 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13470 char *data_pos
= strchr (salt_pos
, '$');
13472 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13474 uint salt_len
= data_pos
- salt_pos
;
13476 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13480 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13482 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13488 memcpy (krb5pa
->user
, user_pos
, user_len
);
13489 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13490 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13492 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13494 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13496 const char p0
= data_pos
[i
+ 0];
13497 const char p1
= data_pos
[i
+ 1];
13499 *timestamp_ptr
++ = hex_convert (p1
) << 0
13500 | hex_convert (p0
) << 4;
13503 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13505 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13507 const char p0
= data_pos
[i
+ 0];
13508 const char p1
= data_pos
[i
+ 1];
13510 *checksum_ptr
++ = hex_convert (p1
) << 0
13511 | hex_convert (p0
) << 4;
13515 * copy some data to generic buffers to make sorting happy
13518 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13519 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13520 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13521 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13522 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13523 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13524 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13525 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13526 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13528 salt
->salt_len
= 36;
13530 digest
[0] = krb5pa
->checksum
[0];
13531 digest
[1] = krb5pa
->checksum
[1];
13532 digest
[2] = krb5pa
->checksum
[2];
13533 digest
[3] = krb5pa
->checksum
[3];
13535 return (PARSER_OK
);
13538 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13540 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13542 u32
*digest
= (u32
*) hash_buf
->digest
;
13544 salt_t
*salt
= hash_buf
->salt
;
13550 char *salt_pos
= input_buf
;
13552 char *hash_pos
= strchr (salt_pos
, '$');
13554 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13556 uint salt_len
= hash_pos
- salt_pos
;
13558 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13562 uint hash_len
= input_len
- 1 - salt_len
;
13564 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13572 for (uint i
= 0; i
< salt_len
; i
++)
13574 if (salt_pos
[i
] == ' ') continue;
13579 // SAP user names cannot be longer than 12 characters
13580 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13582 // SAP user name cannot start with ! or ?
13583 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13589 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13591 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13593 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13595 salt
->salt_len
= salt_len
;
13597 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13598 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13602 digest
[0] = byte_swap_32 (digest
[0]);
13603 digest
[1] = byte_swap_32 (digest
[1]);
13605 return (PARSER_OK
);
13608 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13610 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13612 u32
*digest
= (u32
*) hash_buf
->digest
;
13614 salt_t
*salt
= hash_buf
->salt
;
13620 char *salt_pos
= input_buf
;
13622 char *hash_pos
= strchr (salt_pos
, '$');
13624 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13626 uint salt_len
= hash_pos
- salt_pos
;
13628 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13632 uint hash_len
= input_len
- 1 - salt_len
;
13634 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13642 for (uint i
= 0; i
< salt_len
; i
++)
13644 if (salt_pos
[i
] == ' ') continue;
13649 // SAP user names cannot be longer than 12 characters
13650 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13651 // so far nobody complained so we stay with this because it helps in optimization
13652 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13654 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13656 // SAP user name cannot start with ! or ?
13657 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13663 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13665 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13667 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13669 salt
->salt_len
= salt_len
;
13671 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13672 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13673 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13674 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13675 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13677 return (PARSER_OK
);
13680 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13682 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13684 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13686 u64
*digest
= (u64
*) hash_buf
->digest
;
13688 salt_t
*salt
= hash_buf
->salt
;
13690 char *iter_pos
= input_buf
+ 3;
13692 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13694 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13696 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13698 salt
->salt_iter
= salt_iter
;
13700 char *salt_pos
= iter_pos
+ 1;
13704 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13706 salt
->salt_len
= salt_len
;
13708 char *hash_pos
= salt_pos
+ salt_len
;
13710 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13714 char *tmp
= (char *) salt
->salt_buf_pc
;
13716 tmp
[0] = hash_pos
[42];
13720 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13721 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13722 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13723 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13729 return (PARSER_OK
);
13732 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13734 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13736 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13738 u32
*digest
= (u32
*) hash_buf
->digest
;
13740 salt_t
*salt
= hash_buf
->salt
;
13742 char *salt_buf
= input_buf
+ 6;
13744 uint salt_len
= 16;
13746 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13748 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13750 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13752 salt
->salt_len
= salt_len
;
13754 char *hash_pos
= input_buf
+ 6 + 16;
13756 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13757 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13758 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13759 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13760 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13761 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13762 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13763 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13765 return (PARSER_OK
);
13768 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13770 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13772 u32
*digest
= (u32
*) hash_buf
->digest
;
13774 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13775 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13779 return (PARSER_OK
);
13782 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13784 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13786 u32
*digest
= (u32
*) hash_buf
->digest
;
13788 salt_t
*salt
= hash_buf
->salt
;
13790 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13792 char *saltbuf_pos
= input_buf
;
13794 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13796 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13798 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13800 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13801 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13803 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13807 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13809 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13811 char *salt_ptr
= (char *) saltbuf_pos
;
13812 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13817 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13819 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13822 rakp_ptr
[j
] = 0x80;
13824 rakp
->salt_len
= j
;
13826 for (i
= 0; i
< 64; i
++)
13828 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13831 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13832 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13833 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13834 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13835 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13836 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13837 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13838 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13840 salt
->salt_len
= 32; // muss min. 32 haben
13842 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13843 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13844 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13845 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13846 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13848 return (PARSER_OK
);
13851 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13853 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13855 u32
*digest
= (u32
*) hash_buf
->digest
;
13857 salt_t
*salt
= hash_buf
->salt
;
13859 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13861 char *salt_pos
= input_buf
+ 1;
13863 memcpy (salt
->salt_buf
, salt_pos
, 8);
13865 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13866 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13868 salt
->salt_len
= 8;
13870 char *hash_pos
= salt_pos
+ 8;
13872 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13873 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13874 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13875 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13876 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13878 digest
[0] -= SHA1M_A
;
13879 digest
[1] -= SHA1M_B
;
13880 digest
[2] -= SHA1M_C
;
13881 digest
[3] -= SHA1M_D
;
13882 digest
[4] -= SHA1M_E
;
13884 return (PARSER_OK
);
13887 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13889 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13891 u32
*digest
= (u32
*) hash_buf
->digest
;
13893 salt_t
*salt
= hash_buf
->salt
;
13895 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13896 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13897 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13898 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13900 digest
[0] = byte_swap_32 (digest
[0]);
13901 digest
[1] = byte_swap_32 (digest
[1]);
13902 digest
[2] = byte_swap_32 (digest
[2]);
13903 digest
[3] = byte_swap_32 (digest
[3]);
13905 digest
[0] -= MD5M_A
;
13906 digest
[1] -= MD5M_B
;
13907 digest
[2] -= MD5M_C
;
13908 digest
[3] -= MD5M_D
;
13910 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13912 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13914 u32
*salt_buf
= salt
->salt_buf
;
13916 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
13917 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
13918 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
13919 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
13921 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13922 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13923 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13924 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13926 salt
->salt_len
= 16 + 1;
13928 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13930 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13932 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
13934 return (PARSER_OK
);
13937 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13939 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13941 u32
*digest
= (u32
*) hash_buf
->digest
;
13943 salt_t
*salt
= hash_buf
->salt
;
13945 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13951 char *hashbuf_pos
= input_buf
;
13953 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13955 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13957 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13959 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13963 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13965 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13967 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13969 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13973 char *databuf_pos
= strchr (iteration_pos
, ':');
13975 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13977 const uint iteration_len
= databuf_pos
- iteration_pos
;
13979 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13980 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13982 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13984 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13985 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13991 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13992 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13993 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13994 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13995 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13996 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
13997 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
13998 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14002 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14004 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14006 const char p0
= saltbuf_pos
[i
+ 0];
14007 const char p1
= saltbuf_pos
[i
+ 1];
14009 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14010 | hex_convert (p0
) << 4;
14013 salt
->salt_buf
[4] = 0x01000000;
14014 salt
->salt_buf
[5] = 0x80;
14016 salt
->salt_len
= saltbuf_len
/ 2;
14020 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14024 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14026 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14028 const char p0
= databuf_pos
[i
+ 0];
14029 const char p1
= databuf_pos
[i
+ 1];
14031 *databuf_ptr
++ = hex_convert (p1
) << 0
14032 | hex_convert (p0
) << 4;
14035 *databuf_ptr
++ = 0x80;
14037 for (uint i
= 0; i
< 512; i
++)
14039 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14042 cloudkey
->data_len
= databuf_len
/ 2;
14044 return (PARSER_OK
);
14047 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14049 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14051 u32
*digest
= (u32
*) hash_buf
->digest
;
14053 salt_t
*salt
= hash_buf
->salt
;
14059 char *hashbuf_pos
= input_buf
;
14061 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14063 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14065 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14067 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14071 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14073 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14075 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14077 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14079 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14083 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14085 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14087 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14089 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14091 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14095 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14097 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14098 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14100 // ok, the plan for this algorithm is the following:
14101 // we have 2 salts here, the domain-name and a random salt
14102 // while both are used in the initial transformation,
14103 // only the random salt is used in the following iterations
14104 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14105 // and one that includes only the real salt (stored into salt_buf[]).
14106 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14108 u8 tmp_buf
[100] = { 0 };
14110 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14112 memcpy (digest
, tmp_buf
, 20);
14114 digest
[0] = byte_swap_32 (digest
[0]);
14115 digest
[1] = byte_swap_32 (digest
[1]);
14116 digest
[2] = byte_swap_32 (digest
[2]);
14117 digest
[3] = byte_swap_32 (digest
[3]);
14118 digest
[4] = byte_swap_32 (digest
[4]);
14122 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14124 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14126 char *len_ptr
= NULL
;
14128 for (uint i
= 0; i
< domainbuf_len
; i
++)
14130 if (salt_buf_pc_ptr
[i
] == '.')
14132 len_ptr
= &salt_buf_pc_ptr
[i
];
14142 salt
->salt_buf_pc
[7] = domainbuf_len
;
14146 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14148 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14150 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14152 salt
->salt_len
= salt_len
;
14156 salt
->salt_iter
= atoi (iteration_pos
);
14158 return (PARSER_OK
);
14161 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14163 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14165 u32
*digest
= (u32
*) hash_buf
->digest
;
14167 salt_t
*salt
= hash_buf
->salt
;
14169 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14170 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14171 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14172 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14173 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14175 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14177 uint salt_len
= input_len
- 40 - 1;
14179 char *salt_buf
= input_buf
+ 40 + 1;
14181 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14183 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14185 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14187 salt
->salt_len
= salt_len
;
14189 return (PARSER_OK
);
14192 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14194 const u8 ascii_to_ebcdic
[] =
14196 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14197 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14198 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14199 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14200 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14201 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14202 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14203 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14204 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14205 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14206 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14207 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14208 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14209 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14210 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14211 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14214 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14216 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14218 u32
*digest
= (u32
*) hash_buf
->digest
;
14220 salt_t
*salt
= hash_buf
->salt
;
14222 char *salt_pos
= input_buf
+ 6 + 1;
14224 char *digest_pos
= strchr (salt_pos
, '*');
14226 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14228 uint salt_len
= digest_pos
- salt_pos
;
14230 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14232 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14234 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14238 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14239 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14241 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14243 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14245 salt
->salt_len
= salt_len
;
14247 for (uint i
= 0; i
< salt_len
; i
++)
14249 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14251 for (uint i
= salt_len
; i
< 8; i
++)
14253 salt_buf_pc_ptr
[i
] = 0x40;
14258 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14260 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14261 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14263 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14264 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14266 digest
[0] = byte_swap_32 (digest
[0]);
14267 digest
[1] = byte_swap_32 (digest
[1]);
14269 IP (digest
[0], digest
[1], tt
);
14271 digest
[0] = rotr32 (digest
[0], 29);
14272 digest
[1] = rotr32 (digest
[1], 29);
14276 return (PARSER_OK
);
14279 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14281 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14283 u32
*digest
= (u32
*) hash_buf
->digest
;
14285 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14286 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14287 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14288 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14290 digest
[0] = byte_swap_32 (digest
[0]);
14291 digest
[1] = byte_swap_32 (digest
[1]);
14292 digest
[2] = byte_swap_32 (digest
[2]);
14293 digest
[3] = byte_swap_32 (digest
[3]);
14295 return (PARSER_OK
);
14298 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14300 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14302 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14304 u32
*digest
= (u32
*) hash_buf
->digest
;
14306 salt_t
*salt
= hash_buf
->salt
;
14308 u8 tmp_buf
[120] = { 0 };
14310 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14312 tmp_buf
[3] += -4; // dont ask!
14314 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14316 salt
->salt_len
= 5;
14318 memcpy (digest
, tmp_buf
+ 5, 9);
14320 // yes, only 9 byte are needed to crack, but 10 to display
14322 salt
->salt_buf_pc
[7] = input_buf
[20];
14324 return (PARSER_OK
);
14327 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14329 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14331 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14333 u32
*digest
= (u32
*) hash_buf
->digest
;
14335 salt_t
*salt
= hash_buf
->salt
;
14337 u8 tmp_buf
[120] = { 0 };
14339 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14341 tmp_buf
[3] += -4; // dont ask!
14345 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14347 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)
14351 char tmp_iter_buf
[11] = { 0 };
14353 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14355 tmp_iter_buf
[10] = 0;
14357 salt
->salt_iter
= atoi (tmp_iter_buf
);
14359 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14361 return (PARSER_SALT_ITERATION
);
14364 salt
->salt_iter
--; // first round in init
14366 // 2 additional bytes for display only
14368 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14369 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14373 memcpy (digest
, tmp_buf
+ 28, 8);
14375 digest
[0] = byte_swap_32 (digest
[0]);
14376 digest
[1] = byte_swap_32 (digest
[1]);
14380 return (PARSER_OK
);
14383 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14385 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14387 u32
*digest
= (u32
*) hash_buf
->digest
;
14389 salt_t
*salt
= hash_buf
->salt
;
14391 char *salt_buf_pos
= input_buf
;
14393 char *hash_buf_pos
= salt_buf_pos
+ 6;
14395 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14396 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14397 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14398 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14399 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14400 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14401 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14402 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14404 digest
[0] -= SHA256M_A
;
14405 digest
[1] -= SHA256M_B
;
14406 digest
[2] -= SHA256M_C
;
14407 digest
[3] -= SHA256M_D
;
14408 digest
[4] -= SHA256M_E
;
14409 digest
[5] -= SHA256M_F
;
14410 digest
[6] -= SHA256M_G
;
14411 digest
[7] -= SHA256M_H
;
14413 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14415 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14417 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14419 salt
->salt_len
= salt_len
;
14421 return (PARSER_OK
);
14424 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14426 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14428 u32
*digest
= (u32
*) hash_buf
->digest
;
14430 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14432 salt_t
*salt
= hash_buf
->salt
;
14434 char *salt_buf
= input_buf
+ 6;
14436 char *digest_buf
= strchr (salt_buf
, '$');
14438 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14440 uint salt_len
= digest_buf
- salt_buf
;
14442 digest_buf
++; // skip the '$' symbol
14444 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14446 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14448 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14450 salt
->salt_len
= salt_len
;
14452 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14453 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14454 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14455 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14457 digest
[0] = byte_swap_32 (digest
[0]);
14458 digest
[1] = byte_swap_32 (digest
[1]);
14459 digest
[2] = byte_swap_32 (digest
[2]);
14460 digest
[3] = byte_swap_32 (digest
[3]);
14462 digest
[0] -= MD5M_A
;
14463 digest
[1] -= MD5M_B
;
14464 digest
[2] -= MD5M_C
;
14465 digest
[3] -= MD5M_D
;
14467 return (PARSER_OK
);
14470 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14472 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14474 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14476 u32
*digest
= (u32
*) hash_buf
->digest
;
14478 salt_t
*salt
= hash_buf
->salt
;
14480 char *salt_buf
= input_buf
+ 3;
14482 char *digest_buf
= strchr (salt_buf
, '$');
14484 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14486 uint salt_len
= digest_buf
- salt_buf
;
14488 digest_buf
++; // skip the '$' symbol
14490 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14492 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14494 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14496 salt_buf_ptr
[salt_len
] = 0x2d;
14498 salt
->salt_len
= salt_len
+ 1;
14500 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14501 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14502 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14503 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14505 digest
[0] = byte_swap_32 (digest
[0]);
14506 digest
[1] = byte_swap_32 (digest
[1]);
14507 digest
[2] = byte_swap_32 (digest
[2]);
14508 digest
[3] = byte_swap_32 (digest
[3]);
14510 digest
[0] -= MD5M_A
;
14511 digest
[1] -= MD5M_B
;
14512 digest
[2] -= MD5M_C
;
14513 digest
[3] -= MD5M_D
;
14515 return (PARSER_OK
);
14518 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14520 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14522 u32
*digest
= (u32
*) hash_buf
->digest
;
14524 u8 tmp_buf
[100] = { 0 };
14526 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14528 memcpy (digest
, tmp_buf
, 20);
14530 digest
[0] = byte_swap_32 (digest
[0]);
14531 digest
[1] = byte_swap_32 (digest
[1]);
14532 digest
[2] = byte_swap_32 (digest
[2]);
14533 digest
[3] = byte_swap_32 (digest
[3]);
14534 digest
[4] = byte_swap_32 (digest
[4]);
14536 digest
[0] -= SHA1M_A
;
14537 digest
[1] -= SHA1M_B
;
14538 digest
[2] -= SHA1M_C
;
14539 digest
[3] -= SHA1M_D
;
14540 digest
[4] -= SHA1M_E
;
14542 return (PARSER_OK
);
14545 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14547 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14549 u32
*digest
= (u32
*) hash_buf
->digest
;
14551 salt_t
*salt
= hash_buf
->salt
;
14553 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14554 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14555 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14556 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14558 digest
[0] = byte_swap_32 (digest
[0]);
14559 digest
[1] = byte_swap_32 (digest
[1]);
14560 digest
[2] = byte_swap_32 (digest
[2]);
14561 digest
[3] = byte_swap_32 (digest
[3]);
14563 digest
[0] -= MD5M_A
;
14564 digest
[1] -= MD5M_B
;
14565 digest
[2] -= MD5M_C
;
14566 digest
[3] -= MD5M_D
;
14568 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14570 uint salt_len
= input_len
- 32 - 1;
14572 char *salt_buf
= input_buf
+ 32 + 1;
14574 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14576 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14578 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14581 * add static "salt" part
14584 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14588 salt
->salt_len
= salt_len
;
14590 return (PARSER_OK
);
14593 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14595 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14597 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14599 u32
*digest
= (u32
*) hash_buf
->digest
;
14601 salt_t
*salt
= hash_buf
->salt
;
14603 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14609 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14611 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14613 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14615 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14617 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14621 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14623 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14625 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14627 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14631 char *keybuf_pos
= strchr (keylen_pos
, '$');
14633 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14635 uint keylen_len
= keybuf_pos
- keylen_pos
;
14637 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14641 char *databuf_pos
= strchr (keybuf_pos
, '$');
14643 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14645 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14647 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14651 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14653 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14659 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14660 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14661 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14662 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14664 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14665 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14666 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14667 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14669 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14670 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14671 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14672 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14674 salt
->salt_len
= 16;
14675 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14677 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14679 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14682 return (PARSER_OK
);
14685 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14687 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14689 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14691 u32
*digest
= (u32
*) hash_buf
->digest
;
14693 salt_t
*salt
= hash_buf
->salt
;
14699 // first is the N salt parameter
14701 char *N_pos
= input_buf
+ 6;
14703 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14707 salt
->scrypt_N
= atoi (N_pos
);
14711 char *r_pos
= strchr (N_pos
, ':');
14713 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14717 salt
->scrypt_r
= atoi (r_pos
);
14721 char *p_pos
= strchr (r_pos
, ':');
14723 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14727 salt
->scrypt_p
= atoi (p_pos
);
14731 char *saltbuf_pos
= strchr (p_pos
, ':');
14733 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14737 char *hash_pos
= strchr (saltbuf_pos
, ':');
14739 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14745 u8 tmp_buf
[33] = { 0 };
14747 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14749 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14751 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14753 salt
->salt_len
= tmp_len
;
14754 salt
->salt_iter
= 1;
14756 // digest - base64 decode
14758 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14760 tmp_len
= input_len
- (hash_pos
- input_buf
);
14762 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14764 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14766 memcpy (digest
, tmp_buf
, 32);
14768 return (PARSER_OK
);
14771 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14773 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14775 u32
*digest
= (u32
*) hash_buf
->digest
;
14777 salt_t
*salt
= hash_buf
->salt
;
14783 char decrypted
[76] = { 0 }; // iv + hash
14785 juniper_decrypt_hash (input_buf
, decrypted
);
14787 char *md5crypt_hash
= decrypted
+ 12;
14789 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14791 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14793 char *salt_pos
= md5crypt_hash
+ 3;
14795 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14797 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14799 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14803 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14805 return (PARSER_OK
);
14808 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14810 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14812 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14814 u32
*digest
= (u32
*) hash_buf
->digest
;
14816 salt_t
*salt
= hash_buf
->salt
;
14818 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14824 // first is *raw* salt
14826 char *salt_pos
= input_buf
+ 3;
14828 char *hash_pos
= strchr (salt_pos
, '$');
14830 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14832 uint salt_len
= hash_pos
- salt_pos
;
14834 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14838 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14840 memcpy (salt_buf_ptr
, salt_pos
, 14);
14842 salt_buf_ptr
[17] = 0x01;
14843 salt_buf_ptr
[18] = 0x80;
14845 // add some stuff to normal salt to make sorted happy
14847 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14848 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14849 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14850 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14852 salt
->salt_len
= salt_len
;
14853 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14855 // base64 decode hash
14857 u8 tmp_buf
[100] = { 0 };
14859 uint hash_len
= input_len
- 3 - salt_len
- 1;
14861 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14863 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14865 memcpy (digest
, tmp_buf
, 32);
14867 digest
[0] = byte_swap_32 (digest
[0]);
14868 digest
[1] = byte_swap_32 (digest
[1]);
14869 digest
[2] = byte_swap_32 (digest
[2]);
14870 digest
[3] = byte_swap_32 (digest
[3]);
14871 digest
[4] = byte_swap_32 (digest
[4]);
14872 digest
[5] = byte_swap_32 (digest
[5]);
14873 digest
[6] = byte_swap_32 (digest
[6]);
14874 digest
[7] = byte_swap_32 (digest
[7]);
14876 return (PARSER_OK
);
14879 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14881 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14883 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14885 u32
*digest
= (u32
*) hash_buf
->digest
;
14887 salt_t
*salt
= hash_buf
->salt
;
14893 // first is *raw* salt
14895 char *salt_pos
= input_buf
+ 3;
14897 char *hash_pos
= strchr (salt_pos
, '$');
14899 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14901 uint salt_len
= hash_pos
- salt_pos
;
14903 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14905 salt
->salt_len
= salt_len
;
14908 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14910 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14911 salt_buf_ptr
[salt_len
] = 0;
14913 // base64 decode hash
14915 u8 tmp_buf
[100] = { 0 };
14917 uint hash_len
= input_len
- 3 - salt_len
- 1;
14919 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14921 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14923 memcpy (digest
, tmp_buf
, 32);
14926 salt
->scrypt_N
= 16384;
14927 salt
->scrypt_r
= 1;
14928 salt
->scrypt_p
= 1;
14929 salt
->salt_iter
= 1;
14931 return (PARSER_OK
);
14934 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14936 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14938 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14940 u32
*digest
= (u32
*) hash_buf
->digest
;
14942 salt_t
*salt
= hash_buf
->salt
;
14944 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14950 char *version_pos
= input_buf
+ 8 + 1;
14952 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14954 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14956 u32 version_len
= verifierHashSize_pos
- version_pos
;
14958 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14960 verifierHashSize_pos
++;
14962 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14964 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14966 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14968 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14972 char *saltSize_pos
= strchr (keySize_pos
, '*');
14974 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14976 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14978 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14982 char *osalt_pos
= strchr (saltSize_pos
, '*');
14984 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14986 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14988 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14992 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14994 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14996 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14998 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15000 encryptedVerifier_pos
++;
15002 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15004 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15006 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15008 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15010 encryptedVerifierHash_pos
++;
15012 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;
15014 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15016 const uint version
= atoi (version_pos
);
15018 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15020 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15022 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15024 const uint keySize
= atoi (keySize_pos
);
15026 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15028 office2007
->keySize
= keySize
;
15030 const uint saltSize
= atoi (saltSize_pos
);
15032 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15038 salt
->salt_len
= 16;
15039 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15041 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15042 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15043 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15044 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15050 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15051 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15052 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15053 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15055 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15056 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15057 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15058 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15059 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15065 digest
[0] = office2007
->encryptedVerifierHash
[0];
15066 digest
[1] = office2007
->encryptedVerifierHash
[1];
15067 digest
[2] = office2007
->encryptedVerifierHash
[2];
15068 digest
[3] = office2007
->encryptedVerifierHash
[3];
15070 return (PARSER_OK
);
15073 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15075 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15077 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15079 u32
*digest
= (u32
*) hash_buf
->digest
;
15081 salt_t
*salt
= hash_buf
->salt
;
15083 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15089 char *version_pos
= input_buf
+ 8 + 1;
15091 char *spinCount_pos
= strchr (version_pos
, '*');
15093 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15095 u32 version_len
= spinCount_pos
- version_pos
;
15097 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15101 char *keySize_pos
= strchr (spinCount_pos
, '*');
15103 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15105 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15107 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15111 char *saltSize_pos
= strchr (keySize_pos
, '*');
15113 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15115 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15117 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15121 char *osalt_pos
= strchr (saltSize_pos
, '*');
15123 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15125 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15127 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15131 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15133 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15135 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15137 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15139 encryptedVerifier_pos
++;
15141 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15143 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15145 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15147 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15149 encryptedVerifierHash_pos
++;
15151 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;
15153 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15155 const uint version
= atoi (version_pos
);
15157 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15159 const uint spinCount
= atoi (spinCount_pos
);
15161 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15163 const uint keySize
= atoi (keySize_pos
);
15165 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15167 const uint saltSize
= atoi (saltSize_pos
);
15169 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15175 salt
->salt_len
= 16;
15176 salt
->salt_iter
= spinCount
;
15178 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15179 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15180 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15181 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15187 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15188 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15189 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15190 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15192 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15193 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15194 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15195 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15196 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15197 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15198 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15199 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15205 digest
[0] = office2010
->encryptedVerifierHash
[0];
15206 digest
[1] = office2010
->encryptedVerifierHash
[1];
15207 digest
[2] = office2010
->encryptedVerifierHash
[2];
15208 digest
[3] = office2010
->encryptedVerifierHash
[3];
15210 return (PARSER_OK
);
15213 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15215 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15217 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15219 u32
*digest
= (u32
*) hash_buf
->digest
;
15221 salt_t
*salt
= hash_buf
->salt
;
15223 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15229 char *version_pos
= input_buf
+ 8 + 1;
15231 char *spinCount_pos
= strchr (version_pos
, '*');
15233 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15235 u32 version_len
= spinCount_pos
- version_pos
;
15237 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15241 char *keySize_pos
= strchr (spinCount_pos
, '*');
15243 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15245 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15247 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15251 char *saltSize_pos
= strchr (keySize_pos
, '*');
15253 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15255 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15257 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15261 char *osalt_pos
= strchr (saltSize_pos
, '*');
15263 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15265 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15267 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15271 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15273 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15275 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15277 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15279 encryptedVerifier_pos
++;
15281 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15283 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15285 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15287 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15289 encryptedVerifierHash_pos
++;
15291 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;
15293 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15295 const uint version
= atoi (version_pos
);
15297 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15299 const uint spinCount
= atoi (spinCount_pos
);
15301 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15303 const uint keySize
= atoi (keySize_pos
);
15305 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15307 const uint saltSize
= atoi (saltSize_pos
);
15309 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15315 salt
->salt_len
= 16;
15316 salt
->salt_iter
= spinCount
;
15318 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15319 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15320 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15321 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15327 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15328 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15329 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15330 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15332 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15333 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15334 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15335 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15336 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15337 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15338 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15339 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15345 digest
[0] = office2013
->encryptedVerifierHash
[0];
15346 digest
[1] = office2013
->encryptedVerifierHash
[1];
15347 digest
[2] = office2013
->encryptedVerifierHash
[2];
15348 digest
[3] = office2013
->encryptedVerifierHash
[3];
15350 return (PARSER_OK
);
15353 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15355 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15357 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15359 u32
*digest
= (u32
*) hash_buf
->digest
;
15361 salt_t
*salt
= hash_buf
->salt
;
15363 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15369 char *version_pos
= input_buf
+ 11;
15371 char *osalt_pos
= strchr (version_pos
, '*');
15373 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15375 u32 version_len
= osalt_pos
- version_pos
;
15377 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15381 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15383 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15385 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15387 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15389 encryptedVerifier_pos
++;
15391 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15393 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15395 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15397 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15399 encryptedVerifierHash_pos
++;
15401 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15403 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15405 const uint version
= *version_pos
- 0x30;
15407 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15413 oldoffice01
->version
= version
;
15415 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15416 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15417 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15418 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15420 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15421 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15422 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15423 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15425 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15426 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15427 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15428 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15430 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15431 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15432 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15433 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15439 salt
->salt_len
= 16;
15441 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15442 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15443 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15444 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15446 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15447 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15448 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15449 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15451 // this is a workaround as office produces multiple documents with the same salt
15453 salt
->salt_len
+= 32;
15455 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15456 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15457 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15458 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15459 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15460 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15461 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15462 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15468 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15469 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15470 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15471 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15473 return (PARSER_OK
);
15476 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15478 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15481 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15483 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15485 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15487 u32
*digest
= (u32
*) hash_buf
->digest
;
15489 salt_t
*salt
= hash_buf
->salt
;
15491 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15497 char *version_pos
= input_buf
+ 11;
15499 char *osalt_pos
= strchr (version_pos
, '*');
15501 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15503 u32 version_len
= osalt_pos
- version_pos
;
15505 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15509 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15511 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15513 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15515 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15517 encryptedVerifier_pos
++;
15519 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15521 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15523 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15525 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15527 encryptedVerifierHash_pos
++;
15529 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15531 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15533 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15535 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15539 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15541 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15543 const uint version
= *version_pos
- 0x30;
15545 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15551 oldoffice01
->version
= version
;
15553 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15554 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15555 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15556 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15558 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15559 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15560 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15561 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15563 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15564 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15565 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15566 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15568 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15569 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15570 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15571 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15573 oldoffice01
->rc4key
[1] = 0;
15574 oldoffice01
->rc4key
[0] = 0;
15576 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15577 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15578 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15579 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15580 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15581 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15582 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15583 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15584 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15585 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15587 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15588 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15594 salt
->salt_len
= 16;
15596 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15597 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15598 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15599 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15601 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15602 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15603 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15604 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15606 // this is a workaround as office produces multiple documents with the same salt
15608 salt
->salt_len
+= 32;
15610 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15611 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15612 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15613 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15614 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15615 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15616 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15617 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15623 digest
[0] = oldoffice01
->rc4key
[0];
15624 digest
[1] = oldoffice01
->rc4key
[1];
15628 return (PARSER_OK
);
15631 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15633 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15635 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15637 u32
*digest
= (u32
*) hash_buf
->digest
;
15639 salt_t
*salt
= hash_buf
->salt
;
15641 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15647 char *version_pos
= input_buf
+ 11;
15649 char *osalt_pos
= strchr (version_pos
, '*');
15651 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15653 u32 version_len
= osalt_pos
- version_pos
;
15655 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15659 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15661 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15663 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15665 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15667 encryptedVerifier_pos
++;
15669 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15671 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15673 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15675 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15677 encryptedVerifierHash_pos
++;
15679 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15681 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15683 const uint version
= *version_pos
- 0x30;
15685 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15691 oldoffice34
->version
= version
;
15693 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15694 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15695 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15696 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15698 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15699 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15700 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15701 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15703 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15704 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15705 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15706 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15707 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15709 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15710 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15711 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15712 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15713 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15719 salt
->salt_len
= 16;
15721 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15722 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15723 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15724 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15726 // this is a workaround as office produces multiple documents with the same salt
15728 salt
->salt_len
+= 32;
15730 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15731 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15732 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15733 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15734 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15735 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15736 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15737 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15743 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15744 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15745 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15746 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15748 return (PARSER_OK
);
15751 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15753 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15755 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15758 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15760 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15762 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15764 u32
*digest
= (u32
*) hash_buf
->digest
;
15766 salt_t
*salt
= hash_buf
->salt
;
15768 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15774 char *version_pos
= input_buf
+ 11;
15776 char *osalt_pos
= strchr (version_pos
, '*');
15778 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15780 u32 version_len
= osalt_pos
- version_pos
;
15782 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15786 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15788 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15790 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15792 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15794 encryptedVerifier_pos
++;
15796 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15798 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15800 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15802 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15804 encryptedVerifierHash_pos
++;
15806 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15808 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15810 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15812 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15816 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15818 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15820 const uint version
= *version_pos
- 0x30;
15822 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15828 oldoffice34
->version
= version
;
15830 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15831 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15832 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15833 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15835 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15836 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15837 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15838 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15840 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15841 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15842 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15843 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15844 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15846 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15847 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15848 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15849 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15850 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15852 oldoffice34
->rc4key
[1] = 0;
15853 oldoffice34
->rc4key
[0] = 0;
15855 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15856 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15857 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15858 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15859 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15860 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15861 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15862 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15863 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15864 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15866 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15867 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15873 salt
->salt_len
= 16;
15875 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15876 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15877 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15878 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15880 // this is a workaround as office produces multiple documents with the same salt
15882 salt
->salt_len
+= 32;
15884 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15885 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15886 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15887 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15888 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15889 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15890 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15891 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15897 digest
[0] = oldoffice34
->rc4key
[0];
15898 digest
[1] = oldoffice34
->rc4key
[1];
15902 return (PARSER_OK
);
15905 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15907 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15909 u32
*digest
= (u32
*) hash_buf
->digest
;
15911 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15912 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15913 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15914 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15916 digest
[0] = byte_swap_32 (digest
[0]);
15917 digest
[1] = byte_swap_32 (digest
[1]);
15918 digest
[2] = byte_swap_32 (digest
[2]);
15919 digest
[3] = byte_swap_32 (digest
[3]);
15921 return (PARSER_OK
);
15924 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15926 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15928 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15930 u32
*digest
= (u32
*) hash_buf
->digest
;
15932 salt_t
*salt
= hash_buf
->salt
;
15934 char *signature_pos
= input_buf
;
15936 char *salt_pos
= strchr (signature_pos
, '$');
15938 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15940 u32 signature_len
= salt_pos
- signature_pos
;
15942 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15946 char *hash_pos
= strchr (salt_pos
, '$');
15948 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15950 u32 salt_len
= hash_pos
- salt_pos
;
15952 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15956 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15958 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15960 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
15961 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
15962 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
15963 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
15964 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
15966 digest
[0] -= SHA1M_A
;
15967 digest
[1] -= SHA1M_B
;
15968 digest
[2] -= SHA1M_C
;
15969 digest
[3] -= SHA1M_D
;
15970 digest
[4] -= SHA1M_E
;
15972 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15974 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15976 salt
->salt_len
= salt_len
;
15978 return (PARSER_OK
);
15981 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15983 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15985 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15987 u32
*digest
= (u32
*) hash_buf
->digest
;
15989 salt_t
*salt
= hash_buf
->salt
;
15991 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15997 char *iter_pos
= input_buf
+ 14;
15999 const int iter
= atoi (iter_pos
);
16001 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16003 salt
->salt_iter
= iter
- 1;
16005 char *salt_pos
= strchr (iter_pos
, '$');
16007 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16011 char *hash_pos
= strchr (salt_pos
, '$');
16013 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16015 const uint salt_len
= hash_pos
- salt_pos
;
16019 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16021 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16023 salt
->salt_len
= salt_len
;
16025 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16026 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16028 // add some stuff to normal salt to make sorted happy
16030 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16031 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16032 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16033 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16034 salt
->salt_buf
[4] = salt
->salt_iter
;
16036 // base64 decode hash
16038 u8 tmp_buf
[100] = { 0 };
16040 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16042 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16044 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16046 memcpy (digest
, tmp_buf
, 32);
16048 digest
[0] = byte_swap_32 (digest
[0]);
16049 digest
[1] = byte_swap_32 (digest
[1]);
16050 digest
[2] = byte_swap_32 (digest
[2]);
16051 digest
[3] = byte_swap_32 (digest
[3]);
16052 digest
[4] = byte_swap_32 (digest
[4]);
16053 digest
[5] = byte_swap_32 (digest
[5]);
16054 digest
[6] = byte_swap_32 (digest
[6]);
16055 digest
[7] = byte_swap_32 (digest
[7]);
16057 return (PARSER_OK
);
16060 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16062 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16064 u32
*digest
= (u32
*) hash_buf
->digest
;
16066 salt_t
*salt
= hash_buf
->salt
;
16068 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16069 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16073 digest
[0] = byte_swap_32 (digest
[0]);
16074 digest
[1] = byte_swap_32 (digest
[1]);
16076 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16077 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16078 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16080 char iter_c
= input_buf
[17];
16081 char iter_d
= input_buf
[19];
16083 // atm only defaults, let's see if there's more request
16084 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16085 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16087 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16089 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16090 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16091 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16092 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16094 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16095 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16096 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16097 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16099 salt
->salt_len
= 16;
16101 return (PARSER_OK
);
16104 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16106 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16108 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16110 u32
*digest
= (u32
*) hash_buf
->digest
;
16112 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16114 salt_t
*salt
= hash_buf
->salt
;
16116 char *salt_pos
= input_buf
+ 10;
16118 char *hash_pos
= strchr (salt_pos
, '$');
16120 uint salt_len
= hash_pos
- salt_pos
;
16122 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16126 uint hash_len
= input_len
- 10 - salt_len
- 1;
16128 // base64 decode salt
16130 u8 tmp_buf
[100] = { 0 };
16132 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16134 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16136 tmp_buf
[salt_len
] = 0x80;
16138 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16140 salt
->salt_len
= salt_len
;
16142 // base64 decode salt
16144 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16146 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16148 uint user_len
= hash_len
- 32;
16150 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16152 user_len
--; // skip the trailing space
16154 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16155 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16156 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16157 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16159 digest
[0] = byte_swap_32 (digest
[0]);
16160 digest
[1] = byte_swap_32 (digest
[1]);
16161 digest
[2] = byte_swap_32 (digest
[2]);
16162 digest
[3] = byte_swap_32 (digest
[3]);
16164 // store username for host only (output hash if cracked)
16166 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16167 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16169 return (PARSER_OK
);
16172 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16174 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16176 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16178 u32
*digest
= (u32
*) hash_buf
->digest
;
16180 salt_t
*salt
= hash_buf
->salt
;
16182 char *iter_pos
= input_buf
+ 10;
16184 u32 iter
= atoi (iter_pos
);
16188 return (PARSER_SALT_ITERATION
);
16191 iter
--; // first iteration is special
16193 salt
->salt_iter
= iter
;
16195 char *base64_pos
= strchr (iter_pos
, '}');
16197 if (base64_pos
== NULL
)
16199 return (PARSER_SIGNATURE_UNMATCHED
);
16204 // base64 decode salt
16206 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16208 u8 tmp_buf
[100] = { 0 };
16210 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16212 if (decoded_len
< 24)
16214 return (PARSER_SALT_LENGTH
);
16219 uint salt_len
= decoded_len
- 20;
16221 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16222 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16224 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16226 salt
->salt_len
= salt_len
;
16230 u32
*digest_ptr
= (u32
*) tmp_buf
;
16232 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16233 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16234 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16235 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16236 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16238 return (PARSER_OK
);
16241 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16243 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16245 u32
*digest
= (u32
*) hash_buf
->digest
;
16247 salt_t
*salt
= hash_buf
->salt
;
16249 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16250 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16251 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16252 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16253 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16255 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16257 uint salt_len
= input_len
- 40 - 1;
16259 char *salt_buf
= input_buf
+ 40 + 1;
16261 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16263 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16265 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16267 salt
->salt_len
= salt_len
;
16269 return (PARSER_OK
);
16272 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16274 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16276 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16278 u32
*digest
= (u32
*) hash_buf
->digest
;
16280 salt_t
*salt
= hash_buf
->salt
;
16282 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16288 char *V_pos
= input_buf
+ 5;
16290 char *R_pos
= strchr (V_pos
, '*');
16292 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16294 u32 V_len
= R_pos
- V_pos
;
16298 char *bits_pos
= strchr (R_pos
, '*');
16300 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16302 u32 R_len
= bits_pos
- R_pos
;
16306 char *P_pos
= strchr (bits_pos
, '*');
16308 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16310 u32 bits_len
= P_pos
- bits_pos
;
16314 char *enc_md_pos
= strchr (P_pos
, '*');
16316 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16318 u32 P_len
= enc_md_pos
- P_pos
;
16322 char *id_len_pos
= strchr (enc_md_pos
, '*');
16324 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16326 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16330 char *id_buf_pos
= strchr (id_len_pos
, '*');
16332 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16334 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16338 char *u_len_pos
= strchr (id_buf_pos
, '*');
16340 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16342 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16344 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16348 char *u_buf_pos
= strchr (u_len_pos
, '*');
16350 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16352 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16356 char *o_len_pos
= strchr (u_buf_pos
, '*');
16358 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16360 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16362 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16366 char *o_buf_pos
= strchr (o_len_pos
, '*');
16368 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16370 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16374 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;
16376 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16380 const int V
= atoi (V_pos
);
16381 const int R
= atoi (R_pos
);
16382 const int P
= atoi (P_pos
);
16384 if (V
!= 1) return (PARSER_SALT_VALUE
);
16385 if (R
!= 2) return (PARSER_SALT_VALUE
);
16387 const int enc_md
= atoi (enc_md_pos
);
16389 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16391 const int id_len
= atoi (id_len_pos
);
16392 const int u_len
= atoi (u_len_pos
);
16393 const int o_len
= atoi (o_len_pos
);
16395 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16396 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16397 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16399 const int bits
= atoi (bits_pos
);
16401 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16403 // copy data to esalt
16409 pdf
->enc_md
= enc_md
;
16411 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16412 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16413 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16414 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16415 pdf
->id_len
= id_len
;
16417 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16418 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16419 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16420 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16421 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16422 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16423 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16424 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16425 pdf
->u_len
= u_len
;
16427 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16428 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16429 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16430 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16431 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16432 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16433 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16434 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16435 pdf
->o_len
= o_len
;
16437 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16438 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16439 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16440 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16442 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16443 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16444 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16445 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16446 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16447 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16448 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16449 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16451 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16452 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16453 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16454 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16455 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16456 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16457 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16458 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16460 // we use ID for salt, maybe needs to change, we will see...
16462 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16463 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16464 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16465 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16466 salt
->salt_len
= pdf
->id_len
;
16468 digest
[0] = pdf
->u_buf
[0];
16469 digest
[1] = pdf
->u_buf
[1];
16470 digest
[2] = pdf
->u_buf
[2];
16471 digest
[3] = pdf
->u_buf
[3];
16473 return (PARSER_OK
);
16476 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16478 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16481 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16483 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16485 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16487 u32
*digest
= (u32
*) hash_buf
->digest
;
16489 salt_t
*salt
= hash_buf
->salt
;
16491 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16497 char *V_pos
= input_buf
+ 5;
16499 char *R_pos
= strchr (V_pos
, '*');
16501 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16503 u32 V_len
= R_pos
- V_pos
;
16507 char *bits_pos
= strchr (R_pos
, '*');
16509 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16511 u32 R_len
= bits_pos
- R_pos
;
16515 char *P_pos
= strchr (bits_pos
, '*');
16517 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16519 u32 bits_len
= P_pos
- bits_pos
;
16523 char *enc_md_pos
= strchr (P_pos
, '*');
16525 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16527 u32 P_len
= enc_md_pos
- P_pos
;
16531 char *id_len_pos
= strchr (enc_md_pos
, '*');
16533 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16535 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16539 char *id_buf_pos
= strchr (id_len_pos
, '*');
16541 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16543 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16547 char *u_len_pos
= strchr (id_buf_pos
, '*');
16549 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16551 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16553 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16557 char *u_buf_pos
= strchr (u_len_pos
, '*');
16559 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16561 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16565 char *o_len_pos
= strchr (u_buf_pos
, '*');
16567 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16569 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16571 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16575 char *o_buf_pos
= strchr (o_len_pos
, '*');
16577 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16579 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16583 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16585 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16587 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16589 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16593 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;
16595 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16599 const int V
= atoi (V_pos
);
16600 const int R
= atoi (R_pos
);
16601 const int P
= atoi (P_pos
);
16603 if (V
!= 1) return (PARSER_SALT_VALUE
);
16604 if (R
!= 2) return (PARSER_SALT_VALUE
);
16606 const int enc_md
= atoi (enc_md_pos
);
16608 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16610 const int id_len
= atoi (id_len_pos
);
16611 const int u_len
= atoi (u_len_pos
);
16612 const int o_len
= atoi (o_len_pos
);
16614 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16615 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16616 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16618 const int bits
= atoi (bits_pos
);
16620 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16622 // copy data to esalt
16628 pdf
->enc_md
= enc_md
;
16630 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16631 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16632 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16633 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16634 pdf
->id_len
= id_len
;
16636 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16637 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16638 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16639 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16640 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16641 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16642 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16643 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16644 pdf
->u_len
= u_len
;
16646 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16647 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16648 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16649 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16650 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16651 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16652 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16653 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16654 pdf
->o_len
= o_len
;
16656 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16657 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16658 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16659 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16661 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16662 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16663 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16664 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16665 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16666 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16667 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16668 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16670 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16671 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16672 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16673 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16674 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16675 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16676 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16677 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16679 pdf
->rc4key
[1] = 0;
16680 pdf
->rc4key
[0] = 0;
16682 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16683 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16684 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16685 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16686 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16687 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16688 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16689 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16690 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16691 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16693 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16694 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16696 // we use ID for salt, maybe needs to change, we will see...
16698 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16699 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16700 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16701 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16702 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16703 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16704 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16705 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16706 salt
->salt_len
= pdf
->id_len
+ 16;
16708 digest
[0] = pdf
->rc4key
[0];
16709 digest
[1] = pdf
->rc4key
[1];
16713 return (PARSER_OK
);
16716 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16718 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16720 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16722 u32
*digest
= (u32
*) hash_buf
->digest
;
16724 salt_t
*salt
= hash_buf
->salt
;
16726 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16732 char *V_pos
= input_buf
+ 5;
16734 char *R_pos
= strchr (V_pos
, '*');
16736 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16738 u32 V_len
= R_pos
- V_pos
;
16742 char *bits_pos
= strchr (R_pos
, '*');
16744 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16746 u32 R_len
= bits_pos
- R_pos
;
16750 char *P_pos
= strchr (bits_pos
, '*');
16752 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16754 u32 bits_len
= P_pos
- bits_pos
;
16758 char *enc_md_pos
= strchr (P_pos
, '*');
16760 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16762 u32 P_len
= enc_md_pos
- P_pos
;
16766 char *id_len_pos
= strchr (enc_md_pos
, '*');
16768 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16770 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16774 char *id_buf_pos
= strchr (id_len_pos
, '*');
16776 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16778 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16782 char *u_len_pos
= strchr (id_buf_pos
, '*');
16784 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16786 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16788 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16792 char *u_buf_pos
= strchr (u_len_pos
, '*');
16794 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16796 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16800 char *o_len_pos
= strchr (u_buf_pos
, '*');
16802 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16804 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16806 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16810 char *o_buf_pos
= strchr (o_len_pos
, '*');
16812 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16814 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16818 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;
16820 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16824 const int V
= atoi (V_pos
);
16825 const int R
= atoi (R_pos
);
16826 const int P
= atoi (P_pos
);
16830 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16831 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16833 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16835 const int id_len
= atoi (id_len_pos
);
16836 const int u_len
= atoi (u_len_pos
);
16837 const int o_len
= atoi (o_len_pos
);
16839 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16841 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16842 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16844 const int bits
= atoi (bits_pos
);
16846 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16852 enc_md
= atoi (enc_md_pos
);
16855 // copy data to esalt
16861 pdf
->enc_md
= enc_md
;
16863 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16864 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16865 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16866 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16870 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
16871 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
16872 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
16873 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
16876 pdf
->id_len
= id_len
;
16878 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16879 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16880 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16881 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16882 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16883 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16884 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16885 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16886 pdf
->u_len
= u_len
;
16888 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16889 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16890 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16891 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16892 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16893 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16894 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16895 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16896 pdf
->o_len
= o_len
;
16898 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16899 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16900 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16901 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16905 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16906 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16907 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16908 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16911 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16912 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16913 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16914 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16915 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16916 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16917 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16918 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16920 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16921 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16922 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16923 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16924 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16925 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16926 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16927 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16929 // precompute rc4 data for later use
16945 uint salt_pc_block
[32] = { 0 };
16947 char *salt_pc_ptr
= (char *) salt_pc_block
;
16949 memcpy (salt_pc_ptr
, padding
, 32);
16950 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16952 uint salt_pc_digest
[4] = { 0 };
16954 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16956 pdf
->rc4data
[0] = salt_pc_digest
[0];
16957 pdf
->rc4data
[1] = salt_pc_digest
[1];
16959 // we use ID for salt, maybe needs to change, we will see...
16961 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16962 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16963 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16964 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16965 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16966 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16967 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16968 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16969 salt
->salt_len
= pdf
->id_len
+ 16;
16971 salt
->salt_iter
= ROUNDS_PDF14
;
16973 digest
[0] = pdf
->u_buf
[0];
16974 digest
[1] = pdf
->u_buf
[1];
16978 return (PARSER_OK
);
16981 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16983 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16985 if (ret
!= PARSER_OK
)
16990 u32
*digest
= (u32
*) hash_buf
->digest
;
16992 salt_t
*salt
= hash_buf
->salt
;
16994 digest
[0] -= SHA256M_A
;
16995 digest
[1] -= SHA256M_B
;
16996 digest
[2] -= SHA256M_C
;
16997 digest
[3] -= SHA256M_D
;
16998 digest
[4] -= SHA256M_E
;
16999 digest
[5] -= SHA256M_F
;
17000 digest
[6] -= SHA256M_G
;
17001 digest
[7] -= SHA256M_H
;
17003 salt
->salt_buf
[2] = 0x80;
17005 return (PARSER_OK
);
17008 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17010 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17012 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17014 u32
*digest
= (u32
*) hash_buf
->digest
;
17016 salt_t
*salt
= hash_buf
->salt
;
17018 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17024 char *V_pos
= input_buf
+ 5;
17026 char *R_pos
= strchr (V_pos
, '*');
17028 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17030 u32 V_len
= R_pos
- V_pos
;
17034 char *bits_pos
= strchr (R_pos
, '*');
17036 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17038 u32 R_len
= bits_pos
- R_pos
;
17042 char *P_pos
= strchr (bits_pos
, '*');
17044 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17046 u32 bits_len
= P_pos
- bits_pos
;
17050 char *enc_md_pos
= strchr (P_pos
, '*');
17052 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17054 u32 P_len
= enc_md_pos
- P_pos
;
17058 char *id_len_pos
= strchr (enc_md_pos
, '*');
17060 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17062 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17066 char *id_buf_pos
= strchr (id_len_pos
, '*');
17068 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17070 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17074 char *u_len_pos
= strchr (id_buf_pos
, '*');
17076 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17078 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17082 char *u_buf_pos
= strchr (u_len_pos
, '*');
17084 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17086 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17090 char *o_len_pos
= strchr (u_buf_pos
, '*');
17092 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17094 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17098 char *o_buf_pos
= strchr (o_len_pos
, '*');
17100 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17102 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17106 char *last
= strchr (o_buf_pos
, '*');
17108 if (last
== NULL
) last
= input_buf
+ input_len
;
17110 u32 o_buf_len
= last
- o_buf_pos
;
17114 const int V
= atoi (V_pos
);
17115 const int R
= atoi (R_pos
);
17119 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17120 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17122 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17124 const int bits
= atoi (bits_pos
);
17126 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17128 int enc_md
= atoi (enc_md_pos
);
17130 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17132 const uint id_len
= atoi (id_len_pos
);
17133 const uint u_len
= atoi (u_len_pos
);
17134 const uint o_len
= atoi (o_len_pos
);
17136 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17137 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17138 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17139 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17140 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17141 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17142 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17143 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17145 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17146 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17147 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17149 // copy data to esalt
17151 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17153 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17155 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17158 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17159 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17161 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17162 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17164 salt
->salt_len
= 8;
17165 salt
->salt_iter
= ROUNDS_PDF17L8
;
17167 digest
[0] = pdf
->u_buf
[0];
17168 digest
[1] = pdf
->u_buf
[1];
17169 digest
[2] = pdf
->u_buf
[2];
17170 digest
[3] = pdf
->u_buf
[3];
17171 digest
[4] = pdf
->u_buf
[4];
17172 digest
[5] = pdf
->u_buf
[5];
17173 digest
[6] = pdf
->u_buf
[6];
17174 digest
[7] = pdf
->u_buf
[7];
17176 return (PARSER_OK
);
17179 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17181 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17183 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17185 u32
*digest
= (u32
*) hash_buf
->digest
;
17187 salt_t
*salt
= hash_buf
->salt
;
17189 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17197 char *iter_pos
= input_buf
+ 7;
17199 u32 iter
= atoi (iter_pos
);
17201 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17202 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17204 // first is *raw* salt
17206 char *salt_pos
= strchr (iter_pos
, ':');
17208 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17212 char *hash_pos
= strchr (salt_pos
, ':');
17214 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17216 u32 salt_len
= hash_pos
- salt_pos
;
17218 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17222 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17224 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17228 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17230 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17232 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17234 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17235 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17237 salt
->salt_len
= salt_len
;
17238 salt
->salt_iter
= iter
- 1;
17242 u8 tmp_buf
[100] = { 0 };
17244 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17246 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17248 memcpy (digest
, tmp_buf
, 16);
17250 digest
[0] = byte_swap_32 (digest
[0]);
17251 digest
[1] = byte_swap_32 (digest
[1]);
17252 digest
[2] = byte_swap_32 (digest
[2]);
17253 digest
[3] = byte_swap_32 (digest
[3]);
17255 // add some stuff to normal salt to make sorted happy
17257 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17258 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17259 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17260 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17261 salt
->salt_buf
[4] = salt
->salt_iter
;
17263 return (PARSER_OK
);
17266 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17268 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17270 u32
*digest
= (u32
*) hash_buf
->digest
;
17272 salt_t
*salt
= hash_buf
->salt
;
17274 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17275 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17276 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17277 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17279 digest
[0] = byte_swap_32 (digest
[0]);
17280 digest
[1] = byte_swap_32 (digest
[1]);
17281 digest
[2] = byte_swap_32 (digest
[2]);
17282 digest
[3] = byte_swap_32 (digest
[3]);
17284 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17286 uint salt_len
= input_len
- 32 - 1;
17288 char *salt_buf
= input_buf
+ 32 + 1;
17290 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17292 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17294 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17296 salt
->salt_len
= salt_len
;
17298 return (PARSER_OK
);
17301 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17303 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17305 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17307 u32
*digest
= (u32
*) hash_buf
->digest
;
17309 salt_t
*salt
= hash_buf
->salt
;
17311 char *user_pos
= input_buf
+ 10;
17313 char *salt_pos
= strchr (user_pos
, '*');
17315 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17319 char *hash_pos
= strchr (salt_pos
, '*');
17323 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17325 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17327 uint user_len
= salt_pos
- user_pos
- 1;
17329 uint salt_len
= hash_pos
- salt_pos
- 1;
17331 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17337 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17338 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17339 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17340 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17342 digest
[0] = byte_swap_32 (digest
[0]);
17343 digest
[1] = byte_swap_32 (digest
[1]);
17344 digest
[2] = byte_swap_32 (digest
[2]);
17345 digest
[3] = byte_swap_32 (digest
[3]);
17347 digest
[0] -= MD5M_A
;
17348 digest
[1] -= MD5M_B
;
17349 digest
[2] -= MD5M_C
;
17350 digest
[3] -= MD5M_D
;
17356 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17358 // first 4 bytes are the "challenge"
17360 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17361 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17362 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17363 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17365 // append the user name
17367 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17369 salt
->salt_len
= 4 + user_len
;
17371 return (PARSER_OK
);
17374 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17376 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17378 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17380 u32
*digest
= (u32
*) hash_buf
->digest
;
17382 salt_t
*salt
= hash_buf
->salt
;
17384 char *salt_pos
= input_buf
+ 9;
17386 char *hash_pos
= strchr (salt_pos
, '*');
17388 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17392 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17394 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17396 uint salt_len
= hash_pos
- salt_pos
- 1;
17398 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17404 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17405 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17406 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17407 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17408 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17414 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17416 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17418 salt
->salt_len
= salt_len
;
17420 return (PARSER_OK
);
17423 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17425 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17427 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17429 u32
*digest
= (u32
*) hash_buf
->digest
;
17431 salt_t
*salt
= hash_buf
->salt
;
17433 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17439 char *cry_master_len_pos
= input_buf
+ 9;
17441 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17443 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17445 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17447 cry_master_buf_pos
++;
17449 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17451 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17453 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17455 cry_salt_len_pos
++;
17457 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17459 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17461 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17463 cry_salt_buf_pos
++;
17465 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17467 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17469 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17473 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17475 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17477 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17481 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17483 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17485 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17489 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17491 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17493 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17495 public_key_len_pos
++;
17497 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17499 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17501 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17503 public_key_buf_pos
++;
17505 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;
17507 const uint cry_master_len
= atoi (cry_master_len_pos
);
17508 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17509 const uint ckey_len
= atoi (ckey_len_pos
);
17510 const uint public_key_len
= atoi (public_key_len_pos
);
17512 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17513 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17514 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17515 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17517 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17519 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17521 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17524 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17526 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17528 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17531 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17533 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17535 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17538 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17539 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17540 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17543 * store digest (should be unique enought, hopefully)
17546 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17547 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17548 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17549 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17555 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17557 const uint cry_rounds
= atoi (cry_rounds_pos
);
17559 salt
->salt_iter
= cry_rounds
- 1;
17561 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17563 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17565 salt
->salt_len
= salt_len
;
17567 return (PARSER_OK
);
17570 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17572 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17574 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17576 u32
*digest
= (u32
*) hash_buf
->digest
;
17578 salt_t
*salt
= hash_buf
->salt
;
17580 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17582 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17584 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17586 memcpy (temp_input_buf
, input_buf
, input_len
);
17590 char *URI_server_pos
= temp_input_buf
+ 6;
17592 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17594 if (URI_client_pos
== NULL
)
17596 myfree (temp_input_buf
);
17598 return (PARSER_SEPARATOR_UNMATCHED
);
17601 URI_client_pos
[0] = 0;
17604 uint URI_server_len
= strlen (URI_server_pos
);
17606 if (URI_server_len
> 512)
17608 myfree (temp_input_buf
);
17610 return (PARSER_SALT_LENGTH
);
17615 char *user_pos
= strchr (URI_client_pos
, '*');
17617 if (user_pos
== NULL
)
17619 myfree (temp_input_buf
);
17621 return (PARSER_SEPARATOR_UNMATCHED
);
17627 uint URI_client_len
= strlen (URI_client_pos
);
17629 if (URI_client_len
> 512)
17631 myfree (temp_input_buf
);
17633 return (PARSER_SALT_LENGTH
);
17638 char *realm_pos
= strchr (user_pos
, '*');
17640 if (realm_pos
== NULL
)
17642 myfree (temp_input_buf
);
17644 return (PARSER_SEPARATOR_UNMATCHED
);
17650 uint user_len
= strlen (user_pos
);
17652 if (user_len
> 116)
17654 myfree (temp_input_buf
);
17656 return (PARSER_SALT_LENGTH
);
17661 char *method_pos
= strchr (realm_pos
, '*');
17663 if (method_pos
== NULL
)
17665 myfree (temp_input_buf
);
17667 return (PARSER_SEPARATOR_UNMATCHED
);
17673 uint realm_len
= strlen (realm_pos
);
17675 if (realm_len
> 116)
17677 myfree (temp_input_buf
);
17679 return (PARSER_SALT_LENGTH
);
17684 char *URI_prefix_pos
= strchr (method_pos
, '*');
17686 if (URI_prefix_pos
== NULL
)
17688 myfree (temp_input_buf
);
17690 return (PARSER_SEPARATOR_UNMATCHED
);
17693 URI_prefix_pos
[0] = 0;
17696 uint method_len
= strlen (method_pos
);
17698 if (method_len
> 246)
17700 myfree (temp_input_buf
);
17702 return (PARSER_SALT_LENGTH
);
17707 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17709 if (URI_resource_pos
== NULL
)
17711 myfree (temp_input_buf
);
17713 return (PARSER_SEPARATOR_UNMATCHED
);
17716 URI_resource_pos
[0] = 0;
17717 URI_resource_pos
++;
17719 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17721 if (URI_prefix_len
> 245)
17723 myfree (temp_input_buf
);
17725 return (PARSER_SALT_LENGTH
);
17730 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17732 if (URI_suffix_pos
== NULL
)
17734 myfree (temp_input_buf
);
17736 return (PARSER_SEPARATOR_UNMATCHED
);
17739 URI_suffix_pos
[0] = 0;
17742 uint URI_resource_len
= strlen (URI_resource_pos
);
17744 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17746 myfree (temp_input_buf
);
17748 return (PARSER_SALT_LENGTH
);
17753 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17755 if (nonce_pos
== NULL
)
17757 myfree (temp_input_buf
);
17759 return (PARSER_SEPARATOR_UNMATCHED
);
17765 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17767 if (URI_suffix_len
> 245)
17769 myfree (temp_input_buf
);
17771 return (PARSER_SALT_LENGTH
);
17776 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17778 if (nonce_client_pos
== NULL
)
17780 myfree (temp_input_buf
);
17782 return (PARSER_SEPARATOR_UNMATCHED
);
17785 nonce_client_pos
[0] = 0;
17786 nonce_client_pos
++;
17788 uint nonce_len
= strlen (nonce_pos
);
17790 if (nonce_len
< 1 || nonce_len
> 50)
17792 myfree (temp_input_buf
);
17794 return (PARSER_SALT_LENGTH
);
17799 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17801 if (nonce_count_pos
== NULL
)
17803 myfree (temp_input_buf
);
17805 return (PARSER_SEPARATOR_UNMATCHED
);
17808 nonce_count_pos
[0] = 0;
17811 uint nonce_client_len
= strlen (nonce_client_pos
);
17813 if (nonce_client_len
> 50)
17815 myfree (temp_input_buf
);
17817 return (PARSER_SALT_LENGTH
);
17822 char *qop_pos
= strchr (nonce_count_pos
, '*');
17824 if (qop_pos
== NULL
)
17826 myfree (temp_input_buf
);
17828 return (PARSER_SEPARATOR_UNMATCHED
);
17834 uint nonce_count_len
= strlen (nonce_count_pos
);
17836 if (nonce_count_len
> 50)
17838 myfree (temp_input_buf
);
17840 return (PARSER_SALT_LENGTH
);
17845 char *directive_pos
= strchr (qop_pos
, '*');
17847 if (directive_pos
== NULL
)
17849 myfree (temp_input_buf
);
17851 return (PARSER_SEPARATOR_UNMATCHED
);
17854 directive_pos
[0] = 0;
17857 uint qop_len
= strlen (qop_pos
);
17861 myfree (temp_input_buf
);
17863 return (PARSER_SALT_LENGTH
);
17868 char *digest_pos
= strchr (directive_pos
, '*');
17870 if (digest_pos
== NULL
)
17872 myfree (temp_input_buf
);
17874 return (PARSER_SEPARATOR_UNMATCHED
);
17880 uint directive_len
= strlen (directive_pos
);
17882 if (directive_len
!= 3)
17884 myfree (temp_input_buf
);
17886 return (PARSER_SALT_LENGTH
);
17889 if (memcmp (directive_pos
, "MD5", 3))
17891 log_info ("ERROR: only the MD5 directive is currently supported\n");
17893 myfree (temp_input_buf
);
17895 return (PARSER_SIP_AUTH_DIRECTIVE
);
17899 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17904 uint md5_max_len
= 4 * 64;
17906 uint md5_remaining_len
= md5_max_len
;
17908 uint tmp_md5_buf
[64] = { 0 };
17910 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17912 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17914 md5_len
+= method_len
+ 1;
17915 tmp_md5_ptr
+= method_len
+ 1;
17917 if (URI_prefix_len
> 0)
17919 md5_remaining_len
= md5_max_len
- md5_len
;
17921 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17923 md5_len
+= URI_prefix_len
+ 1;
17924 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17927 md5_remaining_len
= md5_max_len
- md5_len
;
17929 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17931 md5_len
+= URI_resource_len
;
17932 tmp_md5_ptr
+= URI_resource_len
;
17934 if (URI_suffix_len
> 0)
17936 md5_remaining_len
= md5_max_len
- md5_len
;
17938 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17940 md5_len
+= 1 + URI_suffix_len
;
17943 uint tmp_digest
[4] = { 0 };
17945 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17947 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17948 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17949 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17950 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17956 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17958 uint esalt_len
= 0;
17960 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17962 // there are 2 possibilities for the esalt:
17964 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17966 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17968 if (esalt_len
> max_esalt_len
)
17970 myfree (temp_input_buf
);
17972 return (PARSER_SALT_LENGTH
);
17975 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17987 esalt_len
= 1 + nonce_len
+ 1 + 32;
17989 if (esalt_len
> max_esalt_len
)
17991 myfree (temp_input_buf
);
17993 return (PARSER_SALT_LENGTH
);
17996 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18004 // add 0x80 to esalt
18006 esalt_buf_ptr
[esalt_len
] = 0x80;
18008 sip
->esalt_len
= esalt_len
;
18014 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18016 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18018 uint max_salt_len
= 119;
18020 if (salt_len
> max_salt_len
)
18022 myfree (temp_input_buf
);
18024 return (PARSER_SALT_LENGTH
);
18027 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18029 sip
->salt_len
= salt_len
;
18032 * fake salt (for sorting)
18035 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18039 uint fake_salt_len
= salt_len
;
18041 if (fake_salt_len
> max_salt_len
)
18043 fake_salt_len
= max_salt_len
;
18046 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18048 salt
->salt_len
= fake_salt_len
;
18054 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18055 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18056 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18057 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18059 digest
[0] = byte_swap_32 (digest
[0]);
18060 digest
[1] = byte_swap_32 (digest
[1]);
18061 digest
[2] = byte_swap_32 (digest
[2]);
18062 digest
[3] = byte_swap_32 (digest
[3]);
18064 myfree (temp_input_buf
);
18066 return (PARSER_OK
);
18069 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18071 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18073 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18075 u32
*digest
= (u32
*) hash_buf
->digest
;
18077 salt_t
*salt
= hash_buf
->salt
;
18081 char *digest_pos
= input_buf
;
18083 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18090 char *salt_buf
= input_buf
+ 8 + 1;
18094 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18096 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18098 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18100 salt
->salt_len
= salt_len
;
18102 return (PARSER_OK
);
18105 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18107 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18109 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18111 u32
*digest
= (u32
*) hash_buf
->digest
;
18113 salt_t
*salt
= hash_buf
->salt
;
18115 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18121 char *p_buf_pos
= input_buf
+ 4;
18123 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18125 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18127 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18129 NumCyclesPower_pos
++;
18131 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18133 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18135 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18139 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18141 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18143 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18147 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18149 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18151 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18155 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18157 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18159 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18163 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18165 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18167 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18171 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18173 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18175 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18179 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18181 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18183 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18187 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18189 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18191 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18195 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;
18197 const uint iter
= atoi (NumCyclesPower_pos
);
18198 const uint crc
= atoi (crc_buf_pos
);
18199 const uint p_buf
= atoi (p_buf_pos
);
18200 const uint salt_len
= atoi (salt_len_pos
);
18201 const uint iv_len
= atoi (iv_len_pos
);
18202 const uint unpack_size
= atoi (unpack_size_pos
);
18203 const uint data_len
= atoi (data_len_pos
);
18209 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18210 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18212 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18214 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18216 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18222 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18223 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18224 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18225 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18227 seven_zip
->iv_len
= iv_len
;
18229 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18231 seven_zip
->salt_len
= 0;
18233 seven_zip
->crc
= crc
;
18235 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18237 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18239 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18242 seven_zip
->data_len
= data_len
;
18244 seven_zip
->unpack_size
= unpack_size
;
18248 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18249 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18250 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18251 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18253 salt
->salt_len
= 16;
18255 salt
->salt_sign
[0] = iter
;
18257 salt
->salt_iter
= 1 << iter
;
18268 return (PARSER_OK
);
18271 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18273 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18275 u32
*digest
= (u32
*) hash_buf
->digest
;
18277 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18278 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18279 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18280 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18281 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18282 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18283 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18284 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18286 digest
[0] = byte_swap_32 (digest
[0]);
18287 digest
[1] = byte_swap_32 (digest
[1]);
18288 digest
[2] = byte_swap_32 (digest
[2]);
18289 digest
[3] = byte_swap_32 (digest
[3]);
18290 digest
[4] = byte_swap_32 (digest
[4]);
18291 digest
[5] = byte_swap_32 (digest
[5]);
18292 digest
[6] = byte_swap_32 (digest
[6]);
18293 digest
[7] = byte_swap_32 (digest
[7]);
18295 return (PARSER_OK
);
18298 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18300 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18302 u32
*digest
= (u32
*) hash_buf
->digest
;
18304 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18305 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18306 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18307 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18308 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18309 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18310 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18311 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18312 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18313 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18314 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18315 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18316 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18317 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18318 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18319 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18321 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18322 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18323 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18324 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18325 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18326 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18327 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18328 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18329 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18330 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18331 digest
[10] = byte_swap_32 (digest
[10]);
18332 digest
[11] = byte_swap_32 (digest
[11]);
18333 digest
[12] = byte_swap_32 (digest
[12]);
18334 digest
[13] = byte_swap_32 (digest
[13]);
18335 digest
[14] = byte_swap_32 (digest
[14]);
18336 digest
[15] = byte_swap_32 (digest
[15]);
18338 return (PARSER_OK
);
18341 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18343 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18345 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18347 u32
*digest
= (u32
*) hash_buf
->digest
;
18349 salt_t
*salt
= hash_buf
->salt
;
18351 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18359 char *iter_pos
= input_buf
+ 4;
18361 u32 iter
= atoi (iter_pos
);
18363 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18364 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18366 // first is *raw* salt
18368 char *salt_pos
= strchr (iter_pos
, ':');
18370 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18374 char *hash_pos
= strchr (salt_pos
, ':');
18376 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18378 u32 salt_len
= hash_pos
- salt_pos
;
18380 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18384 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18386 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18390 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18392 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18394 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18396 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18397 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18399 salt
->salt_len
= salt_len
;
18400 salt
->salt_iter
= iter
- 1;
18404 u8 tmp_buf
[100] = { 0 };
18406 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18408 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18410 memcpy (digest
, tmp_buf
, 16);
18412 // add some stuff to normal salt to make sorted happy
18414 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18415 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18416 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18417 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18418 salt
->salt_buf
[4] = salt
->salt_iter
;
18420 return (PARSER_OK
);
18423 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18425 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18427 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18429 u32
*digest
= (u32
*) hash_buf
->digest
;
18431 salt_t
*salt
= hash_buf
->salt
;
18433 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18441 char *iter_pos
= input_buf
+ 5;
18443 u32 iter
= atoi (iter_pos
);
18445 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18446 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18448 // first is *raw* salt
18450 char *salt_pos
= strchr (iter_pos
, ':');
18452 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18456 char *hash_pos
= strchr (salt_pos
, ':');
18458 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18460 u32 salt_len
= hash_pos
- salt_pos
;
18462 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18466 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18468 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18472 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18474 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18476 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18478 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18479 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18481 salt
->salt_len
= salt_len
;
18482 salt
->salt_iter
= iter
- 1;
18486 u8 tmp_buf
[100] = { 0 };
18488 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18490 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18492 memcpy (digest
, tmp_buf
, 16);
18494 digest
[0] = byte_swap_32 (digest
[0]);
18495 digest
[1] = byte_swap_32 (digest
[1]);
18496 digest
[2] = byte_swap_32 (digest
[2]);
18497 digest
[3] = byte_swap_32 (digest
[3]);
18499 // add some stuff to normal salt to make sorted happy
18501 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18502 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18503 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18504 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18505 salt
->salt_buf
[4] = salt
->salt_iter
;
18507 return (PARSER_OK
);
18510 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18512 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18514 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18516 u64
*digest
= (u64
*) hash_buf
->digest
;
18518 salt_t
*salt
= hash_buf
->salt
;
18520 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18528 char *iter_pos
= input_buf
+ 7;
18530 u32 iter
= atoi (iter_pos
);
18532 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18533 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18535 // first is *raw* salt
18537 char *salt_pos
= strchr (iter_pos
, ':');
18539 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18543 char *hash_pos
= strchr (salt_pos
, ':');
18545 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18547 u32 salt_len
= hash_pos
- salt_pos
;
18549 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18553 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18555 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18559 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18561 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18563 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18565 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18566 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18568 salt
->salt_len
= salt_len
;
18569 salt
->salt_iter
= iter
- 1;
18573 u8 tmp_buf
[100] = { 0 };
18575 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18577 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18579 memcpy (digest
, tmp_buf
, 64);
18581 digest
[0] = byte_swap_64 (digest
[0]);
18582 digest
[1] = byte_swap_64 (digest
[1]);
18583 digest
[2] = byte_swap_64 (digest
[2]);
18584 digest
[3] = byte_swap_64 (digest
[3]);
18585 digest
[4] = byte_swap_64 (digest
[4]);
18586 digest
[5] = byte_swap_64 (digest
[5]);
18587 digest
[6] = byte_swap_64 (digest
[6]);
18588 digest
[7] = byte_swap_64 (digest
[7]);
18590 // add some stuff to normal salt to make sorted happy
18592 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18593 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18594 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18595 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18596 salt
->salt_buf
[4] = salt
->salt_iter
;
18598 return (PARSER_OK
);
18601 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18603 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18605 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18607 uint
*digest
= (uint
*) hash_buf
->digest
;
18609 salt_t
*salt
= hash_buf
->salt
;
18615 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18617 char *hash_pos
= strchr (salt_pos
, '$');
18619 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18621 u32 salt_len
= hash_pos
- salt_pos
;
18623 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18627 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18629 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18633 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18634 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18652 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18653 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18655 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18656 salt
->salt_len
= 8;
18658 return (PARSER_OK
);
18661 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18663 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18665 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18667 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18669 if (c19
& 3) return (PARSER_HASH_VALUE
);
18671 salt_t
*salt
= hash_buf
->salt
;
18673 u32
*digest
= (u32
*) hash_buf
->digest
;
18677 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18678 | itoa64_to_int (input_buf
[2]) << 6
18679 | itoa64_to_int (input_buf
[3]) << 12
18680 | itoa64_to_int (input_buf
[4]) << 18;
18684 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18685 | itoa64_to_int (input_buf
[6]) << 6
18686 | itoa64_to_int (input_buf
[7]) << 12
18687 | itoa64_to_int (input_buf
[8]) << 18;
18689 salt
->salt_len
= 4;
18691 u8 tmp_buf
[100] = { 0 };
18693 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18695 memcpy (digest
, tmp_buf
, 8);
18699 IP (digest
[0], digest
[1], tt
);
18701 digest
[0] = rotr32 (digest
[0], 31);
18702 digest
[1] = rotr32 (digest
[1], 31);
18706 return (PARSER_OK
);
18709 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18711 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18713 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18715 u32
*digest
= (u32
*) hash_buf
->digest
;
18717 salt_t
*salt
= hash_buf
->salt
;
18723 char *type_pos
= input_buf
+ 6 + 1;
18725 char *salt_pos
= strchr (type_pos
, '*');
18727 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18729 u32 type_len
= salt_pos
- type_pos
;
18731 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18735 char *crypted_pos
= strchr (salt_pos
, '*');
18737 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18739 u32 salt_len
= crypted_pos
- salt_pos
;
18741 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18745 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18747 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18753 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18754 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18756 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18757 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18759 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18760 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18761 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18762 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18764 salt
->salt_len
= 24;
18765 salt
->salt_iter
= ROUNDS_RAR3
;
18767 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18768 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18770 digest
[0] = 0xc43d7b00;
18771 digest
[1] = 0x40070000;
18775 return (PARSER_OK
);
18778 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18780 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18782 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18784 u32
*digest
= (u32
*) hash_buf
->digest
;
18786 salt_t
*salt
= hash_buf
->salt
;
18788 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18794 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18796 char *param1_pos
= strchr (param0_pos
, '$');
18798 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18800 u32 param0_len
= param1_pos
- param0_pos
;
18804 char *param2_pos
= strchr (param1_pos
, '$');
18806 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18808 u32 param1_len
= param2_pos
- param1_pos
;
18812 char *param3_pos
= strchr (param2_pos
, '$');
18814 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18816 u32 param2_len
= param3_pos
- param2_pos
;
18820 char *param4_pos
= strchr (param3_pos
, '$');
18822 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18824 u32 param3_len
= param4_pos
- param3_pos
;
18828 char *param5_pos
= strchr (param4_pos
, '$');
18830 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18832 u32 param4_len
= param5_pos
- param4_pos
;
18836 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18838 char *salt_buf
= param1_pos
;
18839 char *iv
= param3_pos
;
18840 char *pswcheck
= param5_pos
;
18842 const uint salt_len
= atoi (param0_pos
);
18843 const uint iterations
= atoi (param2_pos
);
18844 const uint pswcheck_len
= atoi (param4_pos
);
18850 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18851 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18852 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18854 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18855 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18856 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18862 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18863 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18864 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18865 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
18867 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
18868 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
18869 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
18870 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
18872 salt
->salt_len
= 16;
18874 salt
->salt_sign
[0] = iterations
;
18876 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18882 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
18883 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
18887 return (PARSER_OK
);
18890 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18892 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18894 u32
*digest
= (u32
*) hash_buf
->digest
;
18896 salt_t
*salt
= hash_buf
->salt
;
18898 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18899 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18900 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18901 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18902 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18903 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18904 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18905 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18907 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18909 uint salt_len
= input_len
- 64 - 1;
18911 char *salt_buf
= input_buf
+ 64 + 1;
18913 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18915 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18917 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18919 salt
->salt_len
= salt_len
;
18922 * we can precompute the first sha256 transform
18925 uint w
[16] = { 0 };
18927 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18928 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18929 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18930 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18931 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18932 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18933 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18934 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18935 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18936 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18937 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18938 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18939 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18940 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18941 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18942 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18944 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
18946 sha256_64 (w
, pc256
);
18948 salt
->salt_buf_pc
[0] = pc256
[0];
18949 salt
->salt_buf_pc
[1] = pc256
[1];
18950 salt
->salt_buf_pc
[2] = pc256
[2];
18951 salt
->salt_buf_pc
[3] = pc256
[3];
18952 salt
->salt_buf_pc
[4] = pc256
[4];
18953 salt
->salt_buf_pc
[5] = pc256
[5];
18954 salt
->salt_buf_pc
[6] = pc256
[6];
18955 salt
->salt_buf_pc
[7] = pc256
[7];
18957 digest
[0] -= pc256
[0];
18958 digest
[1] -= pc256
[1];
18959 digest
[2] -= pc256
[2];
18960 digest
[3] -= pc256
[3];
18961 digest
[4] -= pc256
[4];
18962 digest
[5] -= pc256
[5];
18963 digest
[6] -= pc256
[6];
18964 digest
[7] -= pc256
[7];
18966 return (PARSER_OK
);
18969 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18971 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18973 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18975 u32
*digest
= (u32
*) hash_buf
->digest
;
18977 salt_t
*salt
= hash_buf
->salt
;
18983 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18985 char *data_buf_pos
= strchr (data_len_pos
, '$');
18987 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18989 u32 data_len_len
= data_buf_pos
- data_len_pos
;
18991 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18992 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18996 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18998 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
19000 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
19002 u32 data_len
= atoi (data_len_pos
);
19004 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
19010 char *salt_pos
= data_buf_pos
;
19012 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19013 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19014 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
19015 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
19017 // this is actually the CT, which is also the hash later (if matched)
19019 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
19020 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
19021 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
19022 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
19024 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
19026 salt
->salt_iter
= 10 - 1;
19032 digest
[0] = salt
->salt_buf
[4];
19033 digest
[1] = salt
->salt_buf
[5];
19034 digest
[2] = salt
->salt_buf
[6];
19035 digest
[3] = salt
->salt_buf
[7];
19037 return (PARSER_OK
);
19040 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19042 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
19044 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19046 u32
*digest
= (u32
*) hash_buf
->digest
;
19048 salt_t
*salt
= hash_buf
->salt
;
19054 char *salt_pos
= input_buf
+ 11 + 1;
19056 char *iter_pos
= strchr (salt_pos
, ',');
19058 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19060 u32 salt_len
= iter_pos
- salt_pos
;
19062 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
19066 char *hash_pos
= strchr (iter_pos
, ',');
19068 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19070 u32 iter_len
= hash_pos
- iter_pos
;
19072 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
19076 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
19078 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
19084 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19085 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19086 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
19087 salt
->salt_buf
[3] = 0x00018000;
19089 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19090 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19091 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
19092 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
19094 salt
->salt_len
= salt_len
/ 2;
19096 salt
->salt_iter
= atoi (iter_pos
) - 1;
19102 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19103 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19104 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19105 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19106 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19107 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19108 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19109 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19111 return (PARSER_OK
);
19114 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19116 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
19118 u32
*digest
= (u32
*) hash_buf
->digest
;
19120 salt_t
*salt
= hash_buf
->salt
;
19126 char *hash_pos
= input_buf
+ 64;
19127 char *salt1_pos
= input_buf
+ 128;
19128 char *salt2_pos
= input_buf
;
19134 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
19135 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
19136 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
19137 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
19139 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
19140 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
19141 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
19142 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
19144 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
19145 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
19146 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
19147 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
19149 salt
->salt_len
= 48;
19151 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
19157 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19158 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19159 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19160 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19161 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19162 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19163 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19164 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19166 return (PARSER_OK
);
19170 * parallel running threads
19175 BOOL WINAPI
sigHandler_default (DWORD sig
)
19179 case CTRL_CLOSE_EVENT
:
19182 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
19183 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
19184 * function otherwise it is too late (e.g. after returning from this function)
19189 SetConsoleCtrlHandler (NULL
, TRUE
);
19196 case CTRL_LOGOFF_EVENT
:
19197 case CTRL_SHUTDOWN_EVENT
:
19201 SetConsoleCtrlHandler (NULL
, TRUE
);
19209 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19213 case CTRL_CLOSE_EVENT
:
19217 SetConsoleCtrlHandler (NULL
, TRUE
);
19224 case CTRL_LOGOFF_EVENT
:
19225 case CTRL_SHUTDOWN_EVENT
:
19229 SetConsoleCtrlHandler (NULL
, TRUE
);
19237 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19239 if (callback
== NULL
)
19241 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19245 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19251 void sigHandler_default (int sig
)
19255 signal (sig
, NULL
);
19258 void sigHandler_benchmark (int sig
)
19262 signal (sig
, NULL
);
19265 void hc_signal (void (callback
) (int))
19267 if (callback
== NULL
) callback
= SIG_DFL
;
19269 signal (SIGINT
, callback
);
19270 signal (SIGTERM
, callback
);
19271 signal (SIGABRT
, callback
);
19276 void status_display ();
19278 void *thread_keypress (void *p
)
19280 int benchmark
= *((int *) p
);
19282 uint quiet
= data
.quiet
;
19286 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19288 int ch
= tty_getchar();
19290 if (ch
== -1) break;
19292 if (ch
== 0) continue;
19298 hc_thread_mutex_lock (mux_display
);
19313 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19314 if (quiet
== 0) fflush (stdout
);
19326 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19327 if (quiet
== 0) fflush (stdout
);
19339 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19340 if (quiet
== 0) fflush (stdout
);
19352 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19353 if (quiet
== 0) fflush (stdout
);
19361 if (benchmark
== 1) break;
19363 stop_at_checkpoint ();
19367 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19368 if (quiet
== 0) fflush (stdout
);
19376 if (benchmark
== 1)
19388 hc_thread_mutex_unlock (mux_display
);
19400 bool class_num (const u8 c
)
19402 return ((c
>= '0') && (c
<= '9'));
19405 bool class_lower (const u8 c
)
19407 return ((c
>= 'a') && (c
<= 'z'));
19410 bool class_upper (const u8 c
)
19412 return ((c
>= 'A') && (c
<= 'Z'));
19415 bool class_alpha (const u8 c
)
19417 return (class_lower (c
) || class_upper (c
));
19420 int conv_ctoi (const u8 c
)
19426 else if (class_upper (c
))
19428 return c
- 'A' + 10;
19434 int conv_itoc (const u8 c
)
19442 return c
+ 'A' - 10;
19452 #define INCR_POS if (++rule_pos == rule_len) return (-1)
19453 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
19454 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
19455 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
19456 #define MAX_KERNEL_RULES 255
19457 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
19458 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19459 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19461 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
19462 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
19463 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19464 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19466 int cpu_rule_to_kernel_rule (char rule_buf
[BUFSIZ
], uint rule_len
, kernel_rule_t
*rule
)
19471 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19473 switch (rule_buf
[rule_pos
])
19479 case RULE_OP_MANGLE_NOOP
:
19480 SET_NAME (rule
, rule_buf
[rule_pos
]);
19483 case RULE_OP_MANGLE_LREST
:
19484 SET_NAME (rule
, rule_buf
[rule_pos
]);
19487 case RULE_OP_MANGLE_UREST
:
19488 SET_NAME (rule
, rule_buf
[rule_pos
]);
19491 case RULE_OP_MANGLE_LREST_UFIRST
:
19492 SET_NAME (rule
, rule_buf
[rule_pos
]);
19495 case RULE_OP_MANGLE_UREST_LFIRST
:
19496 SET_NAME (rule
, rule_buf
[rule_pos
]);
19499 case RULE_OP_MANGLE_TREST
:
19500 SET_NAME (rule
, rule_buf
[rule_pos
]);
19503 case RULE_OP_MANGLE_TOGGLE_AT
:
19504 SET_NAME (rule
, rule_buf
[rule_pos
]);
19505 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19508 case RULE_OP_MANGLE_REVERSE
:
19509 SET_NAME (rule
, rule_buf
[rule_pos
]);
19512 case RULE_OP_MANGLE_DUPEWORD
:
19513 SET_NAME (rule
, rule_buf
[rule_pos
]);
19516 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19517 SET_NAME (rule
, rule_buf
[rule_pos
]);
19518 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19521 case RULE_OP_MANGLE_REFLECT
:
19522 SET_NAME (rule
, rule_buf
[rule_pos
]);
19525 case RULE_OP_MANGLE_ROTATE_LEFT
:
19526 SET_NAME (rule
, rule_buf
[rule_pos
]);
19529 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19530 SET_NAME (rule
, rule_buf
[rule_pos
]);
19533 case RULE_OP_MANGLE_APPEND
:
19534 SET_NAME (rule
, rule_buf
[rule_pos
]);
19535 SET_P0 (rule
, rule_buf
[rule_pos
]);
19538 case RULE_OP_MANGLE_PREPEND
:
19539 SET_NAME (rule
, rule_buf
[rule_pos
]);
19540 SET_P0 (rule
, rule_buf
[rule_pos
]);
19543 case RULE_OP_MANGLE_DELETE_FIRST
:
19544 SET_NAME (rule
, rule_buf
[rule_pos
]);
19547 case RULE_OP_MANGLE_DELETE_LAST
:
19548 SET_NAME (rule
, rule_buf
[rule_pos
]);
19551 case RULE_OP_MANGLE_DELETE_AT
:
19552 SET_NAME (rule
, rule_buf
[rule_pos
]);
19553 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19556 case RULE_OP_MANGLE_EXTRACT
:
19557 SET_NAME (rule
, rule_buf
[rule_pos
]);
19558 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19559 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19562 case RULE_OP_MANGLE_OMIT
:
19563 SET_NAME (rule
, rule_buf
[rule_pos
]);
19564 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19565 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19568 case RULE_OP_MANGLE_INSERT
:
19569 SET_NAME (rule
, rule_buf
[rule_pos
]);
19570 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19571 SET_P1 (rule
, rule_buf
[rule_pos
]);
19574 case RULE_OP_MANGLE_OVERSTRIKE
:
19575 SET_NAME (rule
, rule_buf
[rule_pos
]);
19576 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19577 SET_P1 (rule
, rule_buf
[rule_pos
]);
19580 case RULE_OP_MANGLE_TRUNCATE_AT
:
19581 SET_NAME (rule
, rule_buf
[rule_pos
]);
19582 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19585 case RULE_OP_MANGLE_REPLACE
:
19586 SET_NAME (rule
, rule_buf
[rule_pos
]);
19587 SET_P0 (rule
, rule_buf
[rule_pos
]);
19588 SET_P1 (rule
, rule_buf
[rule_pos
]);
19591 case RULE_OP_MANGLE_PURGECHAR
:
19595 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19599 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19600 SET_NAME (rule
, rule_buf
[rule_pos
]);
19601 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19604 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19605 SET_NAME (rule
, rule_buf
[rule_pos
]);
19606 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19609 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19610 SET_NAME (rule
, rule_buf
[rule_pos
]);
19613 case RULE_OP_MANGLE_SWITCH_FIRST
:
19614 SET_NAME (rule
, rule_buf
[rule_pos
]);
19617 case RULE_OP_MANGLE_SWITCH_LAST
:
19618 SET_NAME (rule
, rule_buf
[rule_pos
]);
19621 case RULE_OP_MANGLE_SWITCH_AT
:
19622 SET_NAME (rule
, rule_buf
[rule_pos
]);
19623 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19624 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19627 case RULE_OP_MANGLE_CHR_SHIFTL
:
19628 SET_NAME (rule
, rule_buf
[rule_pos
]);
19629 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19632 case RULE_OP_MANGLE_CHR_SHIFTR
:
19633 SET_NAME (rule
, rule_buf
[rule_pos
]);
19634 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19637 case RULE_OP_MANGLE_CHR_INCR
:
19638 SET_NAME (rule
, rule_buf
[rule_pos
]);
19639 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19642 case RULE_OP_MANGLE_CHR_DECR
:
19643 SET_NAME (rule
, rule_buf
[rule_pos
]);
19644 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19647 case RULE_OP_MANGLE_REPLACE_NP1
:
19648 SET_NAME (rule
, rule_buf
[rule_pos
]);
19649 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19652 case RULE_OP_MANGLE_REPLACE_NM1
:
19653 SET_NAME (rule
, rule_buf
[rule_pos
]);
19654 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19657 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19658 SET_NAME (rule
, rule_buf
[rule_pos
]);
19659 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19662 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19663 SET_NAME (rule
, rule_buf
[rule_pos
]);
19664 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19667 case RULE_OP_MANGLE_TITLE
:
19668 SET_NAME (rule
, rule_buf
[rule_pos
]);
19677 if (rule_pos
< rule_len
) return (-1);
19682 int kernel_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], kernel_rule_t
*rule
)
19686 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19690 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19694 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19698 case RULE_OP_MANGLE_NOOP
:
19699 rule_buf
[rule_pos
] = rule_cmd
;
19702 case RULE_OP_MANGLE_LREST
:
19703 rule_buf
[rule_pos
] = rule_cmd
;
19706 case RULE_OP_MANGLE_UREST
:
19707 rule_buf
[rule_pos
] = rule_cmd
;
19710 case RULE_OP_MANGLE_LREST_UFIRST
:
19711 rule_buf
[rule_pos
] = rule_cmd
;
19714 case RULE_OP_MANGLE_UREST_LFIRST
:
19715 rule_buf
[rule_pos
] = rule_cmd
;
19718 case RULE_OP_MANGLE_TREST
:
19719 rule_buf
[rule_pos
] = rule_cmd
;
19722 case RULE_OP_MANGLE_TOGGLE_AT
:
19723 rule_buf
[rule_pos
] = rule_cmd
;
19724 GET_P0_CONV (rule
);
19727 case RULE_OP_MANGLE_REVERSE
:
19728 rule_buf
[rule_pos
] = rule_cmd
;
19731 case RULE_OP_MANGLE_DUPEWORD
:
19732 rule_buf
[rule_pos
] = rule_cmd
;
19735 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19736 rule_buf
[rule_pos
] = rule_cmd
;
19737 GET_P0_CONV (rule
);
19740 case RULE_OP_MANGLE_REFLECT
:
19741 rule_buf
[rule_pos
] = rule_cmd
;
19744 case RULE_OP_MANGLE_ROTATE_LEFT
:
19745 rule_buf
[rule_pos
] = rule_cmd
;
19748 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19749 rule_buf
[rule_pos
] = rule_cmd
;
19752 case RULE_OP_MANGLE_APPEND
:
19753 rule_buf
[rule_pos
] = rule_cmd
;
19757 case RULE_OP_MANGLE_PREPEND
:
19758 rule_buf
[rule_pos
] = rule_cmd
;
19762 case RULE_OP_MANGLE_DELETE_FIRST
:
19763 rule_buf
[rule_pos
] = rule_cmd
;
19766 case RULE_OP_MANGLE_DELETE_LAST
:
19767 rule_buf
[rule_pos
] = rule_cmd
;
19770 case RULE_OP_MANGLE_DELETE_AT
:
19771 rule_buf
[rule_pos
] = rule_cmd
;
19772 GET_P0_CONV (rule
);
19775 case RULE_OP_MANGLE_EXTRACT
:
19776 rule_buf
[rule_pos
] = rule_cmd
;
19777 GET_P0_CONV (rule
);
19778 GET_P1_CONV (rule
);
19781 case RULE_OP_MANGLE_OMIT
:
19782 rule_buf
[rule_pos
] = rule_cmd
;
19783 GET_P0_CONV (rule
);
19784 GET_P1_CONV (rule
);
19787 case RULE_OP_MANGLE_INSERT
:
19788 rule_buf
[rule_pos
] = rule_cmd
;
19789 GET_P0_CONV (rule
);
19793 case RULE_OP_MANGLE_OVERSTRIKE
:
19794 rule_buf
[rule_pos
] = rule_cmd
;
19795 GET_P0_CONV (rule
);
19799 case RULE_OP_MANGLE_TRUNCATE_AT
:
19800 rule_buf
[rule_pos
] = rule_cmd
;
19801 GET_P0_CONV (rule
);
19804 case RULE_OP_MANGLE_REPLACE
:
19805 rule_buf
[rule_pos
] = rule_cmd
;
19810 case RULE_OP_MANGLE_PURGECHAR
:
19814 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19818 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19819 rule_buf
[rule_pos
] = rule_cmd
;
19820 GET_P0_CONV (rule
);
19823 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19824 rule_buf
[rule_pos
] = rule_cmd
;
19825 GET_P0_CONV (rule
);
19828 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19829 rule_buf
[rule_pos
] = rule_cmd
;
19832 case RULE_OP_MANGLE_SWITCH_FIRST
:
19833 rule_buf
[rule_pos
] = rule_cmd
;
19836 case RULE_OP_MANGLE_SWITCH_LAST
:
19837 rule_buf
[rule_pos
] = rule_cmd
;
19840 case RULE_OP_MANGLE_SWITCH_AT
:
19841 rule_buf
[rule_pos
] = rule_cmd
;
19842 GET_P0_CONV (rule
);
19843 GET_P1_CONV (rule
);
19846 case RULE_OP_MANGLE_CHR_SHIFTL
:
19847 rule_buf
[rule_pos
] = rule_cmd
;
19848 GET_P0_CONV (rule
);
19851 case RULE_OP_MANGLE_CHR_SHIFTR
:
19852 rule_buf
[rule_pos
] = rule_cmd
;
19853 GET_P0_CONV (rule
);
19856 case RULE_OP_MANGLE_CHR_INCR
:
19857 rule_buf
[rule_pos
] = rule_cmd
;
19858 GET_P0_CONV (rule
);
19861 case RULE_OP_MANGLE_CHR_DECR
:
19862 rule_buf
[rule_pos
] = rule_cmd
;
19863 GET_P0_CONV (rule
);
19866 case RULE_OP_MANGLE_REPLACE_NP1
:
19867 rule_buf
[rule_pos
] = rule_cmd
;
19868 GET_P0_CONV (rule
);
19871 case RULE_OP_MANGLE_REPLACE_NM1
:
19872 rule_buf
[rule_pos
] = rule_cmd
;
19873 GET_P0_CONV (rule
);
19876 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19877 rule_buf
[rule_pos
] = rule_cmd
;
19878 GET_P0_CONV (rule
);
19881 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19882 rule_buf
[rule_pos
] = rule_cmd
;
19883 GET_P0_CONV (rule
);
19886 case RULE_OP_MANGLE_TITLE
:
19887 rule_buf
[rule_pos
] = rule_cmd
;
19891 return rule_pos
- 1;
19909 * CPU rules : this is from hashcat sources, cpu based rules
19912 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19913 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19915 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19916 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19917 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19919 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19920 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19921 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19923 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19927 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19932 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19936 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19941 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19945 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19950 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19955 for (l
= 0; l
< arr_len
; l
++)
19957 r
= arr_len
- 1 - l
;
19961 MANGLE_SWITCH (arr
, l
, r
);
19967 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19969 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19971 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19973 return (arr_len
* 2);
19976 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19978 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19980 int orig_len
= arr_len
;
19984 for (i
= 0; i
< times
; i
++)
19986 memcpy (&arr
[arr_len
], arr
, orig_len
);
19988 arr_len
+= orig_len
;
19994 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19996 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19998 mangle_double (arr
, arr_len
);
20000 mangle_reverse (arr
+ arr_len
, arr_len
);
20002 return (arr_len
* 2);
20005 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
20010 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
20012 MANGLE_SWITCH (arr
, l
, r
);
20018 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
20023 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
20025 MANGLE_SWITCH (arr
, l
, r
);
20031 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20033 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20037 return (arr_len
+ 1);
20040 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20042 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20046 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20048 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20053 return (arr_len
+ 1);
20056 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20058 if (upos
>= arr_len
) return (arr_len
);
20062 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
20064 arr
[arr_pos
] = arr
[arr_pos
+ 1];
20067 return (arr_len
- 1);
20070 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20072 if (upos
>= arr_len
) return (arr_len
);
20074 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
20078 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
20080 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
20086 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20088 if (upos
>= arr_len
) return (arr_len
);
20090 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
20094 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
20096 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
20099 return (arr_len
- ulen
);
20102 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20104 if (upos
>= arr_len
) return (arr_len
);
20106 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20110 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
20112 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20117 return (arr_len
+ 1);
20120 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
)
20122 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20124 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
20126 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
20128 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
20130 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
20132 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
20134 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
20136 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
20138 return (arr_len
+ arr2_cpy
);
20141 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20143 if (upos
>= arr_len
) return (arr_len
);
20150 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20152 if (upos
>= arr_len
) return (arr_len
);
20154 memset (arr
+ upos
, 0, arr_len
- upos
);
20159 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
20163 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20165 if (arr
[arr_pos
] != oldc
) continue;
20167 arr
[arr_pos
] = newc
;
20173 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20179 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20181 if (arr
[arr_pos
] == c
) continue;
20183 arr
[ret_len
] = arr
[arr_pos
];
20191 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20193 if (ulen
> arr_len
) return (arr_len
);
20195 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20197 char cs
[100] = { 0 };
20199 memcpy (cs
, arr
, ulen
);
20203 for (i
= 0; i
< ulen
; i
++)
20207 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20213 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20215 if (ulen
> arr_len
) return (arr_len
);
20217 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20219 int upos
= arr_len
- ulen
;
20223 for (i
= 0; i
< ulen
; i
++)
20225 char c
= arr
[upos
+ i
];
20227 arr_len
= mangle_append (arr
, arr_len
, c
);
20233 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20235 if ( arr_len
== 0) return (arr_len
);
20236 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20238 char c
= arr
[upos
];
20242 for (i
= 0; i
< ulen
; i
++)
20244 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20250 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20252 if ( arr_len
== 0) return (arr_len
);
20253 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20257 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20259 int new_pos
= arr_pos
* 2;
20261 arr
[new_pos
] = arr
[arr_pos
];
20263 arr
[new_pos
+ 1] = arr
[arr_pos
];
20266 return (arr_len
* 2);
20269 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20271 if (upos
>= arr_len
) return (arr_len
);
20272 if (upos2
>= arr_len
) return (arr_len
);
20274 MANGLE_SWITCH (arr
, upos
, upos2
);
20279 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20281 MANGLE_SWITCH (arr
, upos
, upos2
);
20286 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20288 if (upos
>= arr_len
) return (arr_len
);
20295 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20297 if (upos
>= arr_len
) return (arr_len
);
20304 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20306 if (upos
>= arr_len
) return (arr_len
);
20313 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20315 if (upos
>= arr_len
) return (arr_len
);
20322 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20324 int upper_next
= 1;
20328 for (pos
= 0; pos
< arr_len
; pos
++)
20330 if (arr
[pos
] == ' ')
20341 MANGLE_UPPER_AT (arr
, pos
);
20345 MANGLE_LOWER_AT (arr
, pos
);
20352 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20354 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20360 for (j
= 0; j
< rp_gen_num
; j
++)
20367 switch ((char) get_random_num (0, 9))
20370 r
= get_random_num (0, sizeof (grp_op_nop
));
20371 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20375 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20376 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20377 p1
= get_random_num (0, sizeof (grp_pos
));
20378 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20382 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20383 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20384 p1
= get_random_num (1, 6);
20385 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20389 r
= get_random_num (0, sizeof (grp_op_chr
));
20390 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20391 p1
= get_random_num (0x20, 0x7e);
20392 rule_buf
[rule_pos
++] = (char) p1
;
20396 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20397 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20398 p1
= get_random_num (0x20, 0x7e);
20399 rule_buf
[rule_pos
++] = (char) p1
;
20400 p2
= get_random_num (0x20, 0x7e);
20402 p2
= get_random_num (0x20, 0x7e);
20403 rule_buf
[rule_pos
++] = (char) p2
;
20407 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20408 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20409 p1
= get_random_num (0, sizeof (grp_pos
));
20410 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20411 p2
= get_random_num (0x20, 0x7e);
20412 rule_buf
[rule_pos
++] = (char) p2
;
20416 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20417 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20418 p1
= get_random_num (0, sizeof (grp_pos
));
20419 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20420 p2
= get_random_num (0, sizeof (grp_pos
));
20422 p2
= get_random_num (0, sizeof (grp_pos
));
20423 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20427 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20428 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
20429 p1
= get_random_num (0, sizeof (grp_pos
));
20430 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20431 p2
= get_random_num (1, sizeof (grp_pos
));
20433 p2
= get_random_num (1, sizeof (grp_pos
));
20434 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20438 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
20439 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
20440 p1
= get_random_num (0, sizeof (grp_pos
));
20441 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20442 p2
= get_random_num (1, sizeof (grp_pos
));
20443 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20444 p3
= get_random_num (0, sizeof (grp_pos
));
20445 rule_buf
[rule_pos
++] = grp_pos
[p3
];
20453 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
20455 char mem
[BLOCK_SIZE
] = { 0 };
20457 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
20459 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
20461 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20463 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
20465 int out_len
= in_len
;
20466 int mem_len
= in_len
;
20468 memcpy (out
, in
, out_len
);
20472 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
20477 switch (rule
[rule_pos
])
20482 case RULE_OP_MANGLE_NOOP
:
20485 case RULE_OP_MANGLE_LREST
:
20486 out_len
= mangle_lrest (out
, out_len
);
20489 case RULE_OP_MANGLE_UREST
:
20490 out_len
= mangle_urest (out
, out_len
);
20493 case RULE_OP_MANGLE_LREST_UFIRST
:
20494 out_len
= mangle_lrest (out
, out_len
);
20495 if (out_len
) MANGLE_UPPER_AT (out
, 0);
20498 case RULE_OP_MANGLE_UREST_LFIRST
:
20499 out_len
= mangle_urest (out
, out_len
);
20500 if (out_len
) MANGLE_LOWER_AT (out
, 0);
20503 case RULE_OP_MANGLE_TREST
:
20504 out_len
= mangle_trest (out
, out_len
);
20507 case RULE_OP_MANGLE_TOGGLE_AT
:
20508 NEXT_RULEPOS (rule_pos
);
20509 NEXT_RPTOI (rule
, rule_pos
, upos
);
20510 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
20513 case RULE_OP_MANGLE_REVERSE
:
20514 out_len
= mangle_reverse (out
, out_len
);
20517 case RULE_OP_MANGLE_DUPEWORD
:
20518 out_len
= mangle_double (out
, out_len
);
20521 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20522 NEXT_RULEPOS (rule_pos
);
20523 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20524 out_len
= mangle_double_times (out
, out_len
, ulen
);
20527 case RULE_OP_MANGLE_REFLECT
:
20528 out_len
= mangle_reflect (out
, out_len
);
20531 case RULE_OP_MANGLE_ROTATE_LEFT
:
20532 mangle_rotate_left (out
, out_len
);
20535 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20536 mangle_rotate_right (out
, out_len
);
20539 case RULE_OP_MANGLE_APPEND
:
20540 NEXT_RULEPOS (rule_pos
);
20541 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
20544 case RULE_OP_MANGLE_PREPEND
:
20545 NEXT_RULEPOS (rule_pos
);
20546 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
20549 case RULE_OP_MANGLE_DELETE_FIRST
:
20550 out_len
= mangle_delete_at (out
, out_len
, 0);
20553 case RULE_OP_MANGLE_DELETE_LAST
:
20554 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
20557 case RULE_OP_MANGLE_DELETE_AT
:
20558 NEXT_RULEPOS (rule_pos
);
20559 NEXT_RPTOI (rule
, rule_pos
, upos
);
20560 out_len
= mangle_delete_at (out
, out_len
, upos
);
20563 case RULE_OP_MANGLE_EXTRACT
:
20564 NEXT_RULEPOS (rule_pos
);
20565 NEXT_RPTOI (rule
, rule_pos
, upos
);
20566 NEXT_RULEPOS (rule_pos
);
20567 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20568 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
20571 case RULE_OP_MANGLE_OMIT
:
20572 NEXT_RULEPOS (rule_pos
);
20573 NEXT_RPTOI (rule
, rule_pos
, upos
);
20574 NEXT_RULEPOS (rule_pos
);
20575 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20576 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
20579 case RULE_OP_MANGLE_INSERT
:
20580 NEXT_RULEPOS (rule_pos
);
20581 NEXT_RPTOI (rule
, rule_pos
, upos
);
20582 NEXT_RULEPOS (rule_pos
);
20583 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
20586 case RULE_OP_MANGLE_OVERSTRIKE
:
20587 NEXT_RULEPOS (rule_pos
);
20588 NEXT_RPTOI (rule
, rule_pos
, upos
);
20589 NEXT_RULEPOS (rule_pos
);
20590 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20593 case RULE_OP_MANGLE_TRUNCATE_AT
:
20594 NEXT_RULEPOS (rule_pos
);
20595 NEXT_RPTOI (rule
, rule_pos
, upos
);
20596 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20599 case RULE_OP_MANGLE_REPLACE
:
20600 NEXT_RULEPOS (rule_pos
);
20601 NEXT_RULEPOS (rule_pos
);
20602 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20605 case RULE_OP_MANGLE_PURGECHAR
:
20606 NEXT_RULEPOS (rule_pos
);
20607 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20610 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20614 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20615 NEXT_RULEPOS (rule_pos
);
20616 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20617 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20620 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20621 NEXT_RULEPOS (rule_pos
);
20622 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20623 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20626 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20627 out_len
= mangle_dupechar (out
, out_len
);
20630 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20631 NEXT_RULEPOS (rule_pos
);
20632 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20633 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20636 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20637 NEXT_RULEPOS (rule_pos
);
20638 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20639 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20642 case RULE_OP_MANGLE_SWITCH_FIRST
:
20643 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20646 case RULE_OP_MANGLE_SWITCH_LAST
:
20647 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20650 case RULE_OP_MANGLE_SWITCH_AT
:
20651 NEXT_RULEPOS (rule_pos
);
20652 NEXT_RPTOI (rule
, rule_pos
, upos
);
20653 NEXT_RULEPOS (rule_pos
);
20654 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20655 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20658 case RULE_OP_MANGLE_CHR_SHIFTL
:
20659 NEXT_RULEPOS (rule_pos
);
20660 NEXT_RPTOI (rule
, rule_pos
, upos
);
20661 mangle_chr_shiftl (out
, out_len
, upos
);
20664 case RULE_OP_MANGLE_CHR_SHIFTR
:
20665 NEXT_RULEPOS (rule_pos
);
20666 NEXT_RPTOI (rule
, rule_pos
, upos
);
20667 mangle_chr_shiftr (out
, out_len
, upos
);
20670 case RULE_OP_MANGLE_CHR_INCR
:
20671 NEXT_RULEPOS (rule_pos
);
20672 NEXT_RPTOI (rule
, rule_pos
, upos
);
20673 mangle_chr_incr (out
, out_len
, upos
);
20676 case RULE_OP_MANGLE_CHR_DECR
:
20677 NEXT_RULEPOS (rule_pos
);
20678 NEXT_RPTOI (rule
, rule_pos
, upos
);
20679 mangle_chr_decr (out
, out_len
, upos
);
20682 case RULE_OP_MANGLE_REPLACE_NP1
:
20683 NEXT_RULEPOS (rule_pos
);
20684 NEXT_RPTOI (rule
, rule_pos
, upos
);
20685 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20688 case RULE_OP_MANGLE_REPLACE_NM1
:
20689 NEXT_RULEPOS (rule_pos
);
20690 NEXT_RPTOI (rule
, rule_pos
, upos
);
20691 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20694 case RULE_OP_MANGLE_TITLE
:
20695 out_len
= mangle_title (out
, out_len
);
20698 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20699 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20700 NEXT_RULEPOS (rule_pos
);
20701 NEXT_RPTOI (rule
, rule_pos
, upos
);
20702 NEXT_RULEPOS (rule_pos
);
20703 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20704 NEXT_RULEPOS (rule_pos
);
20705 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20706 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20709 case RULE_OP_MANGLE_APPEND_MEMORY
:
20710 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20711 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20712 memcpy (out
+ out_len
, mem
, mem_len
);
20713 out_len
+= mem_len
;
20716 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20717 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20718 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20719 memcpy (mem
+ mem_len
, out
, out_len
);
20720 out_len
+= mem_len
;
20721 memcpy (out
, mem
, out_len
);
20724 case RULE_OP_MEMORIZE_WORD
:
20725 memcpy (mem
, out
, out_len
);
20729 case RULE_OP_REJECT_LESS
:
20730 NEXT_RULEPOS (rule_pos
);
20731 NEXT_RPTOI (rule
, rule_pos
, upos
);
20732 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20735 case RULE_OP_REJECT_GREATER
:
20736 NEXT_RULEPOS (rule_pos
);
20737 NEXT_RPTOI (rule
, rule_pos
, upos
);
20738 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20741 case RULE_OP_REJECT_CONTAIN
:
20742 NEXT_RULEPOS (rule_pos
);
20743 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20746 case RULE_OP_REJECT_NOT_CONTAIN
:
20747 NEXT_RULEPOS (rule_pos
);
20748 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20751 case RULE_OP_REJECT_EQUAL_FIRST
:
20752 NEXT_RULEPOS (rule_pos
);
20753 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20756 case RULE_OP_REJECT_EQUAL_LAST
:
20757 NEXT_RULEPOS (rule_pos
);
20758 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20761 case RULE_OP_REJECT_EQUAL_AT
:
20762 NEXT_RULEPOS (rule_pos
);
20763 NEXT_RPTOI (rule
, rule_pos
, upos
);
20764 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20765 NEXT_RULEPOS (rule_pos
);
20766 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20769 case RULE_OP_REJECT_CONTAINS
:
20770 NEXT_RULEPOS (rule_pos
);
20771 NEXT_RPTOI (rule
, rule_pos
, upos
);
20772 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20773 NEXT_RULEPOS (rule_pos
);
20774 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20775 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20778 case RULE_OP_REJECT_MEMORY
:
20779 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20783 return (RULE_RC_SYNTAX_ERROR
);
20788 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);