2 * Author......: Jens Steube <jens.steube@gmail.com>
13 #define GET_ACCEL(x) KERNEL_ACCEL_ ## x
14 #define GET_LOOPS(x) KERNEL_LOOPS_ ## x
20 u32
rotl32 (const u32 a
, const u32 n
)
22 return ((a
<< n
) | (a
>> (32 - n
)));
25 u32
rotr32 (const u32 a
, const u32 n
)
27 return ((a
>> n
) | (a
<< (32 - n
)));
30 u64
rotl64 (const u64 a
, const u64 n
)
32 return ((a
<< n
) | (a
>> (64 - n
)));
35 u64
rotr64 (const u64 a
, const u64 n
)
37 return ((a
>> n
) | (a
<< (64 - n
)));
40 u32
byte_swap_32 (const u32 n
)
42 return (n
& 0xff000000) >> 24
43 | (n
& 0x00ff0000) >> 8
44 | (n
& 0x0000ff00) << 8
45 | (n
& 0x000000ff) << 24;
48 u64
byte_swap_64 (const u64 n
)
50 return (n
& 0xff00000000000000ULL
) >> 56
51 | (n
& 0x00ff000000000000ULL
) >> 40
52 | (n
& 0x0000ff0000000000ULL
) >> 24
53 | (n
& 0x000000ff00000000ULL
) >> 8
54 | (n
& 0x00000000ff000000ULL
) << 8
55 | (n
& 0x0000000000ff0000ULL
) << 24
56 | (n
& 0x000000000000ff00ULL
) << 40
57 | (n
& 0x00000000000000ffULL
) << 56;
61 * ciphers for use on cpu
68 * hashes for use on cpu
72 #include "cpu-sha256.c"
80 void log_final (FILE *fp
, const char *fmt
, va_list ap
)
86 for (int i
= 0; i
< last_len
; i
++)
96 int max_len
= (int) sizeof (s
);
98 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
100 if (len
> max_len
) len
= max_len
;
102 fwrite (s
, len
, 1, fp
);
109 void log_out_nn (FILE *fp
, const char *fmt
, ...)
111 if (SUPPRESS_OUTPUT
) return;
117 log_final (fp
, fmt
, ap
);
122 void log_info_nn (const char *fmt
, ...)
124 if (SUPPRESS_OUTPUT
) return;
130 log_final (stdout
, fmt
, ap
);
135 void log_error_nn (const char *fmt
, ...)
137 if (SUPPRESS_OUTPUT
) return;
143 log_final (stderr
, fmt
, ap
);
148 void log_out (FILE *fp
, const char *fmt
, ...)
150 if (SUPPRESS_OUTPUT
) return;
156 log_final (fp
, fmt
, ap
);
165 void log_info (const char *fmt
, ...)
167 if (SUPPRESS_OUTPUT
) return;
173 log_final (stdout
, fmt
, ap
);
177 fputc ('\n', stdout
);
182 void log_error (const char *fmt
, ...)
184 if (SUPPRESS_OUTPUT
) return;
186 fputc ('\n', stderr
);
187 fputc ('\n', stderr
);
193 log_final (stderr
, fmt
, ap
);
197 fputc ('\n', stderr
);
198 fputc ('\n', stderr
);
207 u8
int_to_base32 (const u8 c
)
209 static const u8 tbl
[0x20] =
211 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
212 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
218 u8
base32_to_int (const u8 c
)
220 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
221 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
226 u8
int_to_itoa32 (const u8 c
)
228 static const u8 tbl
[0x20] =
230 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
231 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
237 u8
itoa32_to_int (const u8 c
)
239 if ((c
>= '0') && (c
<= '9')) return c
- '0';
240 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
245 u8
int_to_itoa64 (const u8 c
)
247 static const u8 tbl
[0x40] =
249 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
250 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
251 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
252 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
258 u8
itoa64_to_int (const u8 c
)
260 static const u8 tbl
[0x100] =
262 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
263 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
264 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
265 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
266 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
267 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
268 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
269 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
270 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
271 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
272 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
273 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
274 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
275 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
276 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
277 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
283 u8
int_to_base64 (const u8 c
)
285 static const u8 tbl
[0x40] =
287 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
288 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
289 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
290 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
296 u8
base64_to_int (const u8 c
)
298 static const u8 tbl
[0x100] =
300 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
301 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
302 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
303 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
304 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
305 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
306 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
307 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
308 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
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, 0x00, 0x00, 0x00, 0x00, 0x00,
312 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
313 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
314 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
315 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
321 u8
int_to_bf64 (const u8 c
)
323 static const u8 tbl
[0x40] =
325 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
326 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
327 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
328 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
334 u8
bf64_to_int (const u8 c
)
336 static const u8 tbl
[0x100] =
338 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
339 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
340 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
341 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
342 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
343 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
344 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
345 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
346 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
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, 0x00,
350 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
351 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
352 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
353 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
359 u8
int_to_lotus64 (const u8 c
)
361 if (c
< 10) return '0' + c
;
362 else if (c
< 36) return 'A' + c
- 10;
363 else if (c
< 62) return 'a' + c
- 36;
364 else if (c
== 62) return '+';
365 else if (c
== 63) return '/';
370 u8
lotus64_to_int (const u8 c
)
372 if ((c
>= '0') && (c
<= '9')) return c
- '0';
373 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
374 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
375 else if (c
== '+') return 62;
376 else if (c
== '/') return 63;
382 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
384 const u8
*in_ptr
= in_buf
;
386 u8
*out_ptr
= out_buf
;
388 for (int i
= 0; i
< in_len
; i
+= 8)
390 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
391 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
392 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
393 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
394 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
395 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
396 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
397 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
399 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
400 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
401 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
402 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
403 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
409 for (int i
= 0; i
< in_len
; i
++)
411 if (in_buf
[i
] != '=') continue;
416 int out_len
= (in_len
* 5) / 8;
421 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
423 const u8
*in_ptr
= in_buf
;
425 u8
*out_ptr
= out_buf
;
427 for (int i
= 0; i
< in_len
; i
+= 5)
429 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
430 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
431 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
432 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
433 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
434 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
435 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
436 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
438 out_ptr
[0] = out_val0
& 0x7f;
439 out_ptr
[1] = out_val1
& 0x7f;
440 out_ptr
[2] = out_val2
& 0x7f;
441 out_ptr
[3] = out_val3
& 0x7f;
442 out_ptr
[4] = out_val4
& 0x7f;
443 out_ptr
[5] = out_val5
& 0x7f;
444 out_ptr
[6] = out_val6
& 0x7f;
445 out_ptr
[7] = out_val7
& 0x7f;
451 int out_len
= (in_len
* 8) / 5;
453 for (int i
= 0; i
< (7 - (in_len
% 7)); i
++)
457 out_buf
[out_len
] = '=';
463 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
465 const u8
*in_ptr
= in_buf
;
467 u8
*out_ptr
= out_buf
;
469 for (int i
= 0; i
< in_len
; i
+= 4)
471 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
472 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
473 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
474 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
476 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
477 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
478 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
484 for (int i
= 0; i
< in_len
; i
++)
486 if (in_buf
[i
] != '=') continue;
491 int out_len
= (in_len
* 6) / 8;
496 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
498 const u8
*in_ptr
= in_buf
;
500 u8
*out_ptr
= out_buf
;
502 for (int i
= 0; i
< in_len
; i
+= 3)
504 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
505 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
506 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
507 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
509 out_ptr
[0] = out_val0
& 0x7f;
510 out_ptr
[1] = out_val1
& 0x7f;
511 out_ptr
[2] = out_val2
& 0x7f;
512 out_ptr
[3] = out_val3
& 0x7f;
518 int out_len
= (in_len
* 8) / 6;
520 for (int i
= 0; i
< (3 - (in_len
% 3)); i
++)
524 out_buf
[out_len
] = '=';
530 int is_valid_hex_char (const u8 c
)
532 if ((c
>= '0') && (c
<= '9')) return 1;
533 if ((c
>= 'A') && (c
<= 'F')) return 1;
534 if ((c
>= 'a') && (c
<= 'f')) return 1;
539 u8
hex_convert (const u8 c
)
541 return (c
& 15) + (c
>> 6) * 9;
544 u8
hex_to_u8 (const u8 hex
[2])
548 v
|= (hex_convert (hex
[1]) << 0);
549 v
|= (hex_convert (hex
[0]) << 4);
554 u32
hex_to_u32 (const u8 hex
[8])
558 v
|= ((u32
) hex_convert (hex
[7])) << 0;
559 v
|= ((u32
) hex_convert (hex
[6])) << 4;
560 v
|= ((u32
) hex_convert (hex
[5])) << 8;
561 v
|= ((u32
) hex_convert (hex
[4])) << 12;
562 v
|= ((u32
) hex_convert (hex
[3])) << 16;
563 v
|= ((u32
) hex_convert (hex
[2])) << 20;
564 v
|= ((u32
) hex_convert (hex
[1])) << 24;
565 v
|= ((u32
) hex_convert (hex
[0])) << 28;
570 u64
hex_to_u64 (const u8 hex
[16])
574 v
|= ((u64
) hex_convert (hex
[15]) << 0);
575 v
|= ((u64
) hex_convert (hex
[14]) << 4);
576 v
|= ((u64
) hex_convert (hex
[13]) << 8);
577 v
|= ((u64
) hex_convert (hex
[12]) << 12);
578 v
|= ((u64
) hex_convert (hex
[11]) << 16);
579 v
|= ((u64
) hex_convert (hex
[10]) << 20);
580 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
581 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
582 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
583 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
584 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
585 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
586 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
587 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
588 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
589 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
594 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
596 hex
[0] = v
>> 28 & 15;
597 hex
[1] = v
>> 24 & 15;
598 hex
[2] = v
>> 20 & 15;
599 hex
[3] = v
>> 16 & 15;
600 hex
[4] = v
>> 12 & 15;
601 hex
[5] = v
>> 8 & 15;
602 hex
[6] = v
>> 4 & 15;
603 hex
[7] = v
>> 0 & 15;
607 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
608 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
609 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
610 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
611 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
612 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
613 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
614 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
621 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
625 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
634 for (int i
= 0; i
< 16; i
+= 4)
644 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
651 out
[i
+ 0] = _out
[0];
652 out
[i
+ 1] = _out
[1];
653 out
[i
+ 2] = _out
[2];
654 out
[i
+ 3] = _out
[3];
663 static void juniper_decrypt_hash (char *in
, char *out
)
669 memset (base64_buf
, 0, sizeof (base64_buf
));
671 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
675 u32 juniper_iv
[4] = { 0 };
677 memcpy (juniper_iv
, base64_buf
, 12);
679 memcpy (out
, juniper_iv
, 12);
685 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
686 juniper_key
[1] = byte_swap_32 (0x8df91059);
687 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
688 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
692 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
693 u32
*out_ptr
= (u32
*) (out
+ 12);
695 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
698 void phpass_decode (u8 digest
[16], u8 buf
[22])
702 l
= itoa64_to_int (buf
[ 0]) << 0;
703 l
|= itoa64_to_int (buf
[ 1]) << 6;
704 l
|= itoa64_to_int (buf
[ 2]) << 12;
705 l
|= itoa64_to_int (buf
[ 3]) << 18;
707 digest
[ 0] = (l
>> 0) & 0xff;
708 digest
[ 1] = (l
>> 8) & 0xff;
709 digest
[ 2] = (l
>> 16) & 0xff;
711 l
= itoa64_to_int (buf
[ 4]) << 0;
712 l
|= itoa64_to_int (buf
[ 5]) << 6;
713 l
|= itoa64_to_int (buf
[ 6]) << 12;
714 l
|= itoa64_to_int (buf
[ 7]) << 18;
716 digest
[ 3] = (l
>> 0) & 0xff;
717 digest
[ 4] = (l
>> 8) & 0xff;
718 digest
[ 5] = (l
>> 16) & 0xff;
720 l
= itoa64_to_int (buf
[ 8]) << 0;
721 l
|= itoa64_to_int (buf
[ 9]) << 6;
722 l
|= itoa64_to_int (buf
[10]) << 12;
723 l
|= itoa64_to_int (buf
[11]) << 18;
725 digest
[ 6] = (l
>> 0) & 0xff;
726 digest
[ 7] = (l
>> 8) & 0xff;
727 digest
[ 8] = (l
>> 16) & 0xff;
729 l
= itoa64_to_int (buf
[12]) << 0;
730 l
|= itoa64_to_int (buf
[13]) << 6;
731 l
|= itoa64_to_int (buf
[14]) << 12;
732 l
|= itoa64_to_int (buf
[15]) << 18;
734 digest
[ 9] = (l
>> 0) & 0xff;
735 digest
[10] = (l
>> 8) & 0xff;
736 digest
[11] = (l
>> 16) & 0xff;
738 l
= itoa64_to_int (buf
[16]) << 0;
739 l
|= itoa64_to_int (buf
[17]) << 6;
740 l
|= itoa64_to_int (buf
[18]) << 12;
741 l
|= itoa64_to_int (buf
[19]) << 18;
743 digest
[12] = (l
>> 0) & 0xff;
744 digest
[13] = (l
>> 8) & 0xff;
745 digest
[14] = (l
>> 16) & 0xff;
747 l
= itoa64_to_int (buf
[20]) << 0;
748 l
|= itoa64_to_int (buf
[21]) << 6;
750 digest
[15] = (l
>> 0) & 0xff;
753 void phpass_encode (u8 digest
[16], u8 buf
[22])
757 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
759 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
760 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
761 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
762 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
764 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
766 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
767 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
768 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
769 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
771 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
773 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
774 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
775 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
776 buf
[11] = int_to_itoa64 (l
& 0x3f);
778 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
780 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
781 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
782 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
783 buf
[15] = int_to_itoa64 (l
& 0x3f);
785 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
787 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
788 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
789 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
790 buf
[19] = int_to_itoa64 (l
& 0x3f);
792 l
= (digest
[15] << 0);
794 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
795 buf
[21] = int_to_itoa64 (l
& 0x3f);
798 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
802 l
= itoa64_to_int (buf
[ 0]) << 0;
803 l
|= itoa64_to_int (buf
[ 1]) << 6;
804 l
|= itoa64_to_int (buf
[ 2]) << 12;
805 l
|= itoa64_to_int (buf
[ 3]) << 18;
807 digest
[ 0] = (l
>> 16) & 0xff;
808 digest
[ 6] = (l
>> 8) & 0xff;
809 digest
[12] = (l
>> 0) & 0xff;
811 l
= itoa64_to_int (buf
[ 4]) << 0;
812 l
|= itoa64_to_int (buf
[ 5]) << 6;
813 l
|= itoa64_to_int (buf
[ 6]) << 12;
814 l
|= itoa64_to_int (buf
[ 7]) << 18;
816 digest
[ 1] = (l
>> 16) & 0xff;
817 digest
[ 7] = (l
>> 8) & 0xff;
818 digest
[13] = (l
>> 0) & 0xff;
820 l
= itoa64_to_int (buf
[ 8]) << 0;
821 l
|= itoa64_to_int (buf
[ 9]) << 6;
822 l
|= itoa64_to_int (buf
[10]) << 12;
823 l
|= itoa64_to_int (buf
[11]) << 18;
825 digest
[ 2] = (l
>> 16) & 0xff;
826 digest
[ 8] = (l
>> 8) & 0xff;
827 digest
[14] = (l
>> 0) & 0xff;
829 l
= itoa64_to_int (buf
[12]) << 0;
830 l
|= itoa64_to_int (buf
[13]) << 6;
831 l
|= itoa64_to_int (buf
[14]) << 12;
832 l
|= itoa64_to_int (buf
[15]) << 18;
834 digest
[ 3] = (l
>> 16) & 0xff;
835 digest
[ 9] = (l
>> 8) & 0xff;
836 digest
[15] = (l
>> 0) & 0xff;
838 l
= itoa64_to_int (buf
[16]) << 0;
839 l
|= itoa64_to_int (buf
[17]) << 6;
840 l
|= itoa64_to_int (buf
[18]) << 12;
841 l
|= itoa64_to_int (buf
[19]) << 18;
843 digest
[ 4] = (l
>> 16) & 0xff;
844 digest
[10] = (l
>> 8) & 0xff;
845 digest
[ 5] = (l
>> 0) & 0xff;
847 l
= itoa64_to_int (buf
[20]) << 0;
848 l
|= itoa64_to_int (buf
[21]) << 6;
850 digest
[11] = (l
>> 0) & 0xff;
853 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
857 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
859 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
860 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
861 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
862 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
864 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
866 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
867 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
868 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
869 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
871 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
873 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
874 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
875 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
876 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
880 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
881 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
882 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
883 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
887 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
888 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
889 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
890 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 l
= (digest
[11] << 0);
894 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
895 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
898 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
902 l
= itoa64_to_int (buf
[ 0]) << 0;
903 l
|= itoa64_to_int (buf
[ 1]) << 6;
904 l
|= itoa64_to_int (buf
[ 2]) << 12;
905 l
|= itoa64_to_int (buf
[ 3]) << 18;
907 digest
[ 0] = (l
>> 16) & 0xff;
908 digest
[21] = (l
>> 8) & 0xff;
909 digest
[42] = (l
>> 0) & 0xff;
911 l
= itoa64_to_int (buf
[ 4]) << 0;
912 l
|= itoa64_to_int (buf
[ 5]) << 6;
913 l
|= itoa64_to_int (buf
[ 6]) << 12;
914 l
|= itoa64_to_int (buf
[ 7]) << 18;
916 digest
[22] = (l
>> 16) & 0xff;
917 digest
[43] = (l
>> 8) & 0xff;
918 digest
[ 1] = (l
>> 0) & 0xff;
920 l
= itoa64_to_int (buf
[ 8]) << 0;
921 l
|= itoa64_to_int (buf
[ 9]) << 6;
922 l
|= itoa64_to_int (buf
[10]) << 12;
923 l
|= itoa64_to_int (buf
[11]) << 18;
925 digest
[44] = (l
>> 16) & 0xff;
926 digest
[ 2] = (l
>> 8) & 0xff;
927 digest
[23] = (l
>> 0) & 0xff;
929 l
= itoa64_to_int (buf
[12]) << 0;
930 l
|= itoa64_to_int (buf
[13]) << 6;
931 l
|= itoa64_to_int (buf
[14]) << 12;
932 l
|= itoa64_to_int (buf
[15]) << 18;
934 digest
[ 3] = (l
>> 16) & 0xff;
935 digest
[24] = (l
>> 8) & 0xff;
936 digest
[45] = (l
>> 0) & 0xff;
938 l
= itoa64_to_int (buf
[16]) << 0;
939 l
|= itoa64_to_int (buf
[17]) << 6;
940 l
|= itoa64_to_int (buf
[18]) << 12;
941 l
|= itoa64_to_int (buf
[19]) << 18;
943 digest
[25] = (l
>> 16) & 0xff;
944 digest
[46] = (l
>> 8) & 0xff;
945 digest
[ 4] = (l
>> 0) & 0xff;
947 l
= itoa64_to_int (buf
[20]) << 0;
948 l
|= itoa64_to_int (buf
[21]) << 6;
949 l
|= itoa64_to_int (buf
[22]) << 12;
950 l
|= itoa64_to_int (buf
[23]) << 18;
952 digest
[47] = (l
>> 16) & 0xff;
953 digest
[ 5] = (l
>> 8) & 0xff;
954 digest
[26] = (l
>> 0) & 0xff;
956 l
= itoa64_to_int (buf
[24]) << 0;
957 l
|= itoa64_to_int (buf
[25]) << 6;
958 l
|= itoa64_to_int (buf
[26]) << 12;
959 l
|= itoa64_to_int (buf
[27]) << 18;
961 digest
[ 6] = (l
>> 16) & 0xff;
962 digest
[27] = (l
>> 8) & 0xff;
963 digest
[48] = (l
>> 0) & 0xff;
965 l
= itoa64_to_int (buf
[28]) << 0;
966 l
|= itoa64_to_int (buf
[29]) << 6;
967 l
|= itoa64_to_int (buf
[30]) << 12;
968 l
|= itoa64_to_int (buf
[31]) << 18;
970 digest
[28] = (l
>> 16) & 0xff;
971 digest
[49] = (l
>> 8) & 0xff;
972 digest
[ 7] = (l
>> 0) & 0xff;
974 l
= itoa64_to_int (buf
[32]) << 0;
975 l
|= itoa64_to_int (buf
[33]) << 6;
976 l
|= itoa64_to_int (buf
[34]) << 12;
977 l
|= itoa64_to_int (buf
[35]) << 18;
979 digest
[50] = (l
>> 16) & 0xff;
980 digest
[ 8] = (l
>> 8) & 0xff;
981 digest
[29] = (l
>> 0) & 0xff;
983 l
= itoa64_to_int (buf
[36]) << 0;
984 l
|= itoa64_to_int (buf
[37]) << 6;
985 l
|= itoa64_to_int (buf
[38]) << 12;
986 l
|= itoa64_to_int (buf
[39]) << 18;
988 digest
[ 9] = (l
>> 16) & 0xff;
989 digest
[30] = (l
>> 8) & 0xff;
990 digest
[51] = (l
>> 0) & 0xff;
992 l
= itoa64_to_int (buf
[40]) << 0;
993 l
|= itoa64_to_int (buf
[41]) << 6;
994 l
|= itoa64_to_int (buf
[42]) << 12;
995 l
|= itoa64_to_int (buf
[43]) << 18;
997 digest
[31] = (l
>> 16) & 0xff;
998 digest
[52] = (l
>> 8) & 0xff;
999 digest
[10] = (l
>> 0) & 0xff;
1001 l
= itoa64_to_int (buf
[44]) << 0;
1002 l
|= itoa64_to_int (buf
[45]) << 6;
1003 l
|= itoa64_to_int (buf
[46]) << 12;
1004 l
|= itoa64_to_int (buf
[47]) << 18;
1006 digest
[53] = (l
>> 16) & 0xff;
1007 digest
[11] = (l
>> 8) & 0xff;
1008 digest
[32] = (l
>> 0) & 0xff;
1010 l
= itoa64_to_int (buf
[48]) << 0;
1011 l
|= itoa64_to_int (buf
[49]) << 6;
1012 l
|= itoa64_to_int (buf
[50]) << 12;
1013 l
|= itoa64_to_int (buf
[51]) << 18;
1015 digest
[12] = (l
>> 16) & 0xff;
1016 digest
[33] = (l
>> 8) & 0xff;
1017 digest
[54] = (l
>> 0) & 0xff;
1019 l
= itoa64_to_int (buf
[52]) << 0;
1020 l
|= itoa64_to_int (buf
[53]) << 6;
1021 l
|= itoa64_to_int (buf
[54]) << 12;
1022 l
|= itoa64_to_int (buf
[55]) << 18;
1024 digest
[34] = (l
>> 16) & 0xff;
1025 digest
[55] = (l
>> 8) & 0xff;
1026 digest
[13] = (l
>> 0) & 0xff;
1028 l
= itoa64_to_int (buf
[56]) << 0;
1029 l
|= itoa64_to_int (buf
[57]) << 6;
1030 l
|= itoa64_to_int (buf
[58]) << 12;
1031 l
|= itoa64_to_int (buf
[59]) << 18;
1033 digest
[56] = (l
>> 16) & 0xff;
1034 digest
[14] = (l
>> 8) & 0xff;
1035 digest
[35] = (l
>> 0) & 0xff;
1037 l
= itoa64_to_int (buf
[60]) << 0;
1038 l
|= itoa64_to_int (buf
[61]) << 6;
1039 l
|= itoa64_to_int (buf
[62]) << 12;
1040 l
|= itoa64_to_int (buf
[63]) << 18;
1042 digest
[15] = (l
>> 16) & 0xff;
1043 digest
[36] = (l
>> 8) & 0xff;
1044 digest
[57] = (l
>> 0) & 0xff;
1046 l
= itoa64_to_int (buf
[64]) << 0;
1047 l
|= itoa64_to_int (buf
[65]) << 6;
1048 l
|= itoa64_to_int (buf
[66]) << 12;
1049 l
|= itoa64_to_int (buf
[67]) << 18;
1051 digest
[37] = (l
>> 16) & 0xff;
1052 digest
[58] = (l
>> 8) & 0xff;
1053 digest
[16] = (l
>> 0) & 0xff;
1055 l
= itoa64_to_int (buf
[68]) << 0;
1056 l
|= itoa64_to_int (buf
[69]) << 6;
1057 l
|= itoa64_to_int (buf
[70]) << 12;
1058 l
|= itoa64_to_int (buf
[71]) << 18;
1060 digest
[59] = (l
>> 16) & 0xff;
1061 digest
[17] = (l
>> 8) & 0xff;
1062 digest
[38] = (l
>> 0) & 0xff;
1064 l
= itoa64_to_int (buf
[72]) << 0;
1065 l
|= itoa64_to_int (buf
[73]) << 6;
1066 l
|= itoa64_to_int (buf
[74]) << 12;
1067 l
|= itoa64_to_int (buf
[75]) << 18;
1069 digest
[18] = (l
>> 16) & 0xff;
1070 digest
[39] = (l
>> 8) & 0xff;
1071 digest
[60] = (l
>> 0) & 0xff;
1073 l
= itoa64_to_int (buf
[76]) << 0;
1074 l
|= itoa64_to_int (buf
[77]) << 6;
1075 l
|= itoa64_to_int (buf
[78]) << 12;
1076 l
|= itoa64_to_int (buf
[79]) << 18;
1078 digest
[40] = (l
>> 16) & 0xff;
1079 digest
[61] = (l
>> 8) & 0xff;
1080 digest
[19] = (l
>> 0) & 0xff;
1082 l
= itoa64_to_int (buf
[80]) << 0;
1083 l
|= itoa64_to_int (buf
[81]) << 6;
1084 l
|= itoa64_to_int (buf
[82]) << 12;
1085 l
|= itoa64_to_int (buf
[83]) << 18;
1087 digest
[62] = (l
>> 16) & 0xff;
1088 digest
[20] = (l
>> 8) & 0xff;
1089 digest
[41] = (l
>> 0) & 0xff;
1091 l
= itoa64_to_int (buf
[84]) << 0;
1092 l
|= itoa64_to_int (buf
[85]) << 6;
1094 digest
[63] = (l
>> 0) & 0xff;
1097 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1101 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1103 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1104 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1105 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1106 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1108 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1110 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1111 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1112 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1113 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1115 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1117 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1118 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1119 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1120 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1124 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1125 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1126 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1127 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1131 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1132 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1133 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1134 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1138 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1139 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1140 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1141 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1145 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1146 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1147 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1148 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1152 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1153 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1154 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1155 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1159 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1160 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1161 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1162 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1166 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1167 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1168 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1169 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1173 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1174 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1175 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1176 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1180 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1181 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1182 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1183 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1187 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1188 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1189 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1190 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1194 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1195 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1196 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1197 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1201 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1202 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1203 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1204 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1208 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1209 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1210 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1211 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1215 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1216 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1217 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1218 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1222 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1223 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1224 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1225 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1229 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1230 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1231 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1232 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1236 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1237 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1238 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1239 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1243 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1244 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1245 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1246 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 l
= 0 | 0 | (digest
[63] << 0);
1250 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1251 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1254 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1258 l
= itoa64_to_int (buf
[ 0]) << 0;
1259 l
|= itoa64_to_int (buf
[ 1]) << 6;
1260 l
|= itoa64_to_int (buf
[ 2]) << 12;
1261 l
|= itoa64_to_int (buf
[ 3]) << 18;
1263 digest
[ 2] = (l
>> 0) & 0xff;
1264 digest
[ 1] = (l
>> 8) & 0xff;
1265 digest
[ 0] = (l
>> 16) & 0xff;
1267 l
= itoa64_to_int (buf
[ 4]) << 0;
1268 l
|= itoa64_to_int (buf
[ 5]) << 6;
1269 l
|= itoa64_to_int (buf
[ 6]) << 12;
1270 l
|= itoa64_to_int (buf
[ 7]) << 18;
1272 digest
[ 5] = (l
>> 0) & 0xff;
1273 digest
[ 4] = (l
>> 8) & 0xff;
1274 digest
[ 3] = (l
>> 16) & 0xff;
1276 l
= itoa64_to_int (buf
[ 8]) << 0;
1277 l
|= itoa64_to_int (buf
[ 9]) << 6;
1278 l
|= itoa64_to_int (buf
[10]) << 12;
1279 l
|= itoa64_to_int (buf
[11]) << 18;
1281 digest
[ 8] = (l
>> 0) & 0xff;
1282 digest
[ 7] = (l
>> 8) & 0xff;
1283 digest
[ 6] = (l
>> 16) & 0xff;
1285 l
= itoa64_to_int (buf
[12]) << 0;
1286 l
|= itoa64_to_int (buf
[13]) << 6;
1287 l
|= itoa64_to_int (buf
[14]) << 12;
1288 l
|= itoa64_to_int (buf
[15]) << 18;
1290 digest
[11] = (l
>> 0) & 0xff;
1291 digest
[10] = (l
>> 8) & 0xff;
1292 digest
[ 9] = (l
>> 16) & 0xff;
1294 l
= itoa64_to_int (buf
[16]) << 0;
1295 l
|= itoa64_to_int (buf
[17]) << 6;
1296 l
|= itoa64_to_int (buf
[18]) << 12;
1297 l
|= itoa64_to_int (buf
[19]) << 18;
1299 digest
[14] = (l
>> 0) & 0xff;
1300 digest
[13] = (l
>> 8) & 0xff;
1301 digest
[12] = (l
>> 16) & 0xff;
1303 l
= itoa64_to_int (buf
[20]) << 0;
1304 l
|= itoa64_to_int (buf
[21]) << 6;
1305 l
|= itoa64_to_int (buf
[22]) << 12;
1306 l
|= itoa64_to_int (buf
[23]) << 18;
1308 digest
[17] = (l
>> 0) & 0xff;
1309 digest
[16] = (l
>> 8) & 0xff;
1310 digest
[15] = (l
>> 16) & 0xff;
1312 l
= itoa64_to_int (buf
[24]) << 0;
1313 l
|= itoa64_to_int (buf
[25]) << 6;
1314 l
|= itoa64_to_int (buf
[26]) << 12;
1316 digest
[19] = (l
>> 8) & 0xff;
1317 digest
[18] = (l
>> 16) & 0xff;
1320 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1324 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1326 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1327 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1328 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1329 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1331 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1333 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1334 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1335 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1336 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1338 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1340 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1341 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1342 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1343 buf
[11] = int_to_itoa64 (l
& 0x3f);
1345 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1347 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1348 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1349 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1350 buf
[15] = int_to_itoa64 (l
& 0x3f);
1352 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1354 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1355 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1356 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1357 buf
[19] = int_to_itoa64 (l
& 0x3f);
1359 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1361 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1362 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1363 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1364 buf
[23] = int_to_itoa64 (l
& 0x3f);
1366 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1368 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1369 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1370 buf
[26] = int_to_itoa64 (l
& 0x3f);
1373 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1377 l
= itoa64_to_int (buf
[ 0]) << 0;
1378 l
|= itoa64_to_int (buf
[ 1]) << 6;
1379 l
|= itoa64_to_int (buf
[ 2]) << 12;
1380 l
|= itoa64_to_int (buf
[ 3]) << 18;
1382 digest
[ 2] = (l
>> 0) & 0xff;
1383 digest
[ 1] = (l
>> 8) & 0xff;
1384 digest
[ 0] = (l
>> 16) & 0xff;
1386 l
= itoa64_to_int (buf
[ 4]) << 0;
1387 l
|= itoa64_to_int (buf
[ 5]) << 6;
1388 l
|= itoa64_to_int (buf
[ 6]) << 12;
1389 l
|= itoa64_to_int (buf
[ 7]) << 18;
1391 digest
[ 5] = (l
>> 0) & 0xff;
1392 digest
[ 4] = (l
>> 8) & 0xff;
1393 digest
[ 3] = (l
>> 16) & 0xff;
1395 l
= itoa64_to_int (buf
[ 8]) << 0;
1396 l
|= itoa64_to_int (buf
[ 9]) << 6;
1397 l
|= itoa64_to_int (buf
[10]) << 12;
1398 l
|= itoa64_to_int (buf
[11]) << 18;
1400 digest
[ 8] = (l
>> 0) & 0xff;
1401 digest
[ 7] = (l
>> 8) & 0xff;
1402 digest
[ 6] = (l
>> 16) & 0xff;
1404 l
= itoa64_to_int (buf
[12]) << 0;
1405 l
|= itoa64_to_int (buf
[13]) << 6;
1406 l
|= itoa64_to_int (buf
[14]) << 12;
1407 l
|= itoa64_to_int (buf
[15]) << 18;
1409 digest
[11] = (l
>> 0) & 0xff;
1410 digest
[10] = (l
>> 8) & 0xff;
1411 digest
[ 9] = (l
>> 16) & 0xff;
1413 l
= itoa64_to_int (buf
[16]) << 0;
1414 l
|= itoa64_to_int (buf
[17]) << 6;
1415 l
|= itoa64_to_int (buf
[18]) << 12;
1416 l
|= itoa64_to_int (buf
[19]) << 18;
1418 digest
[14] = (l
>> 0) & 0xff;
1419 digest
[13] = (l
>> 8) & 0xff;
1420 digest
[12] = (l
>> 16) & 0xff;
1422 l
= itoa64_to_int (buf
[20]) << 0;
1423 l
|= itoa64_to_int (buf
[21]) << 6;
1424 l
|= itoa64_to_int (buf
[22]) << 12;
1425 l
|= itoa64_to_int (buf
[23]) << 18;
1427 digest
[17] = (l
>> 0) & 0xff;
1428 digest
[16] = (l
>> 8) & 0xff;
1429 digest
[15] = (l
>> 16) & 0xff;
1431 l
= itoa64_to_int (buf
[24]) << 0;
1432 l
|= itoa64_to_int (buf
[25]) << 6;
1433 l
|= itoa64_to_int (buf
[26]) << 12;
1434 l
|= itoa64_to_int (buf
[27]) << 18;
1436 digest
[20] = (l
>> 0) & 0xff;
1437 digest
[19] = (l
>> 8) & 0xff;
1438 digest
[18] = (l
>> 16) & 0xff;
1440 l
= itoa64_to_int (buf
[28]) << 0;
1441 l
|= itoa64_to_int (buf
[29]) << 6;
1442 l
|= itoa64_to_int (buf
[30]) << 12;
1443 l
|= itoa64_to_int (buf
[31]) << 18;
1445 digest
[23] = (l
>> 0) & 0xff;
1446 digest
[22] = (l
>> 8) & 0xff;
1447 digest
[21] = (l
>> 16) & 0xff;
1449 l
= itoa64_to_int (buf
[32]) << 0;
1450 l
|= itoa64_to_int (buf
[33]) << 6;
1451 l
|= itoa64_to_int (buf
[34]) << 12;
1452 l
|= itoa64_to_int (buf
[35]) << 18;
1454 digest
[26] = (l
>> 0) & 0xff;
1455 digest
[25] = (l
>> 8) & 0xff;
1456 digest
[24] = (l
>> 16) & 0xff;
1458 l
= itoa64_to_int (buf
[36]) << 0;
1459 l
|= itoa64_to_int (buf
[37]) << 6;
1460 l
|= itoa64_to_int (buf
[38]) << 12;
1461 l
|= itoa64_to_int (buf
[39]) << 18;
1463 digest
[29] = (l
>> 0) & 0xff;
1464 digest
[28] = (l
>> 8) & 0xff;
1465 digest
[27] = (l
>> 16) & 0xff;
1467 l
= itoa64_to_int (buf
[40]) << 0;
1468 l
|= itoa64_to_int (buf
[41]) << 6;
1469 l
|= itoa64_to_int (buf
[42]) << 12;
1471 //digest[32] = (l >> 0) & 0xff;
1472 digest
[31] = (l
>> 8) & 0xff;
1473 digest
[30] = (l
>> 16) & 0xff;
1476 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1480 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1482 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1483 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1484 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1485 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1487 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1489 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1490 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1491 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1492 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1494 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1496 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1497 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1498 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1499 buf
[11] = int_to_itoa64 (l
& 0x3f);
1501 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1503 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1504 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1505 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1506 buf
[15] = int_to_itoa64 (l
& 0x3f);
1508 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1510 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1511 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1512 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1513 buf
[19] = int_to_itoa64 (l
& 0x3f);
1515 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1517 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1518 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1519 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1520 buf
[23] = int_to_itoa64 (l
& 0x3f);
1522 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1524 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1525 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1526 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1527 buf
[27] = int_to_itoa64 (l
& 0x3f);
1529 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1531 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1532 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1533 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1534 buf
[31] = int_to_itoa64 (l
& 0x3f);
1536 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1538 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1539 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1540 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1541 buf
[35] = int_to_itoa64 (l
& 0x3f);
1543 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1545 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1546 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1547 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1548 buf
[39] = int_to_itoa64 (l
& 0x3f);
1550 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1552 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1553 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1554 buf
[42] = int_to_itoa64 (l
& 0x3f);
1557 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1561 l
= itoa64_to_int (buf
[ 0]) << 0;
1562 l
|= itoa64_to_int (buf
[ 1]) << 6;
1563 l
|= itoa64_to_int (buf
[ 2]) << 12;
1564 l
|= itoa64_to_int (buf
[ 3]) << 18;
1566 digest
[ 2] = (l
>> 0) & 0xff;
1567 digest
[ 1] = (l
>> 8) & 0xff;
1568 digest
[ 0] = (l
>> 16) & 0xff;
1570 l
= itoa64_to_int (buf
[ 4]) << 0;
1571 l
|= itoa64_to_int (buf
[ 5]) << 6;
1572 l
|= itoa64_to_int (buf
[ 6]) << 12;
1573 l
|= itoa64_to_int (buf
[ 7]) << 18;
1575 digest
[ 5] = (l
>> 0) & 0xff;
1576 digest
[ 4] = (l
>> 8) & 0xff;
1577 digest
[ 3] = (l
>> 16) & 0xff;
1579 l
= itoa64_to_int (buf
[ 8]) << 0;
1580 l
|= itoa64_to_int (buf
[ 9]) << 6;
1581 l
|= itoa64_to_int (buf
[10]) << 12;
1582 l
|= itoa64_to_int (buf
[11]) << 18;
1584 digest
[ 8] = (l
>> 0) & 0xff;
1585 digest
[ 7] = (l
>> 8) & 0xff;
1586 digest
[ 6] = (l
>> 16) & 0xff;
1588 l
= itoa64_to_int (buf
[12]) << 0;
1589 l
|= itoa64_to_int (buf
[13]) << 6;
1590 l
|= itoa64_to_int (buf
[14]) << 12;
1591 l
|= itoa64_to_int (buf
[15]) << 18;
1593 digest
[11] = (l
>> 0) & 0xff;
1594 digest
[10] = (l
>> 8) & 0xff;
1595 digest
[ 9] = (l
>> 16) & 0xff;
1597 l
= itoa64_to_int (buf
[16]) << 0;
1598 l
|= itoa64_to_int (buf
[17]) << 6;
1599 l
|= itoa64_to_int (buf
[18]) << 12;
1600 l
|= itoa64_to_int (buf
[19]) << 18;
1602 digest
[14] = (l
>> 0) & 0xff;
1603 digest
[13] = (l
>> 8) & 0xff;
1604 digest
[12] = (l
>> 16) & 0xff;
1606 l
= itoa64_to_int (buf
[20]) << 0;
1607 l
|= itoa64_to_int (buf
[21]) << 6;
1608 l
|= itoa64_to_int (buf
[22]) << 12;
1609 l
|= itoa64_to_int (buf
[23]) << 18;
1611 digest
[17] = (l
>> 0) & 0xff;
1612 digest
[16] = (l
>> 8) & 0xff;
1613 digest
[15] = (l
>> 16) & 0xff;
1615 l
= itoa64_to_int (buf
[24]) << 0;
1616 l
|= itoa64_to_int (buf
[25]) << 6;
1617 l
|= itoa64_to_int (buf
[26]) << 12;
1618 l
|= itoa64_to_int (buf
[27]) << 18;
1620 digest
[20] = (l
>> 0) & 0xff;
1621 digest
[19] = (l
>> 8) & 0xff;
1622 digest
[18] = (l
>> 16) & 0xff;
1624 l
= itoa64_to_int (buf
[28]) << 0;
1625 l
|= itoa64_to_int (buf
[29]) << 6;
1626 l
|= itoa64_to_int (buf
[30]) << 12;
1627 l
|= itoa64_to_int (buf
[31]) << 18;
1629 digest
[23] = (l
>> 0) & 0xff;
1630 digest
[22] = (l
>> 8) & 0xff;
1631 digest
[21] = (l
>> 16) & 0xff;
1633 l
= itoa64_to_int (buf
[32]) << 0;
1634 l
|= itoa64_to_int (buf
[33]) << 6;
1635 l
|= itoa64_to_int (buf
[34]) << 12;
1636 l
|= itoa64_to_int (buf
[35]) << 18;
1638 digest
[26] = (l
>> 0) & 0xff;
1639 digest
[25] = (l
>> 8) & 0xff;
1640 digest
[24] = (l
>> 16) & 0xff;
1642 l
= itoa64_to_int (buf
[36]) << 0;
1643 l
|= itoa64_to_int (buf
[37]) << 6;
1644 l
|= itoa64_to_int (buf
[38]) << 12;
1645 l
|= itoa64_to_int (buf
[39]) << 18;
1647 digest
[29] = (l
>> 0) & 0xff;
1648 digest
[28] = (l
>> 8) & 0xff;
1649 digest
[27] = (l
>> 16) & 0xff;
1651 l
= itoa64_to_int (buf
[40]) << 0;
1652 l
|= itoa64_to_int (buf
[41]) << 6;
1653 l
|= itoa64_to_int (buf
[42]) << 12;
1654 l
|= itoa64_to_int (buf
[43]) << 18;
1656 digest
[32] = (l
>> 0) & 0xff;
1657 digest
[31] = (l
>> 8) & 0xff;
1658 digest
[30] = (l
>> 16) & 0xff;
1660 l
= itoa64_to_int (buf
[44]) << 0;
1661 l
|= itoa64_to_int (buf
[45]) << 6;
1662 l
|= itoa64_to_int (buf
[46]) << 12;
1663 l
|= itoa64_to_int (buf
[47]) << 18;
1665 digest
[35] = (l
>> 0) & 0xff;
1666 digest
[34] = (l
>> 8) & 0xff;
1667 digest
[33] = (l
>> 16) & 0xff;
1669 l
= itoa64_to_int (buf
[48]) << 0;
1670 l
|= itoa64_to_int (buf
[49]) << 6;
1671 l
|= itoa64_to_int (buf
[50]) << 12;
1672 l
|= itoa64_to_int (buf
[51]) << 18;
1674 digest
[38] = (l
>> 0) & 0xff;
1675 digest
[37] = (l
>> 8) & 0xff;
1676 digest
[36] = (l
>> 16) & 0xff;
1678 l
= itoa64_to_int (buf
[52]) << 0;
1679 l
|= itoa64_to_int (buf
[53]) << 6;
1680 l
|= itoa64_to_int (buf
[54]) << 12;
1681 l
|= itoa64_to_int (buf
[55]) << 18;
1683 digest
[41] = (l
>> 0) & 0xff;
1684 digest
[40] = (l
>> 8) & 0xff;
1685 digest
[39] = (l
>> 16) & 0xff;
1687 l
= itoa64_to_int (buf
[56]) << 0;
1688 l
|= itoa64_to_int (buf
[57]) << 6;
1689 l
|= itoa64_to_int (buf
[58]) << 12;
1690 l
|= itoa64_to_int (buf
[59]) << 18;
1692 digest
[44] = (l
>> 0) & 0xff;
1693 digest
[43] = (l
>> 8) & 0xff;
1694 digest
[42] = (l
>> 16) & 0xff;
1696 l
= itoa64_to_int (buf
[60]) << 0;
1697 l
|= itoa64_to_int (buf
[61]) << 6;
1698 l
|= itoa64_to_int (buf
[62]) << 12;
1699 l
|= itoa64_to_int (buf
[63]) << 18;
1701 digest
[47] = (l
>> 0) & 0xff;
1702 digest
[46] = (l
>> 8) & 0xff;
1703 digest
[45] = (l
>> 16) & 0xff;
1705 l
= itoa64_to_int (buf
[64]) << 0;
1706 l
|= itoa64_to_int (buf
[65]) << 6;
1707 l
|= itoa64_to_int (buf
[66]) << 12;
1708 l
|= itoa64_to_int (buf
[67]) << 18;
1710 digest
[50] = (l
>> 0) & 0xff;
1711 digest
[49] = (l
>> 8) & 0xff;
1712 digest
[48] = (l
>> 16) & 0xff;
1714 l
= itoa64_to_int (buf
[68]) << 0;
1715 l
|= itoa64_to_int (buf
[69]) << 6;
1716 l
|= itoa64_to_int (buf
[70]) << 12;
1717 l
|= itoa64_to_int (buf
[71]) << 18;
1719 digest
[53] = (l
>> 0) & 0xff;
1720 digest
[52] = (l
>> 8) & 0xff;
1721 digest
[51] = (l
>> 16) & 0xff;
1723 l
= itoa64_to_int (buf
[72]) << 0;
1724 l
|= itoa64_to_int (buf
[73]) << 6;
1725 l
|= itoa64_to_int (buf
[74]) << 12;
1726 l
|= itoa64_to_int (buf
[75]) << 18;
1728 digest
[56] = (l
>> 0) & 0xff;
1729 digest
[55] = (l
>> 8) & 0xff;
1730 digest
[54] = (l
>> 16) & 0xff;
1732 l
= itoa64_to_int (buf
[76]) << 0;
1733 l
|= itoa64_to_int (buf
[77]) << 6;
1734 l
|= itoa64_to_int (buf
[78]) << 12;
1735 l
|= itoa64_to_int (buf
[79]) << 18;
1737 digest
[59] = (l
>> 0) & 0xff;
1738 digest
[58] = (l
>> 8) & 0xff;
1739 digest
[57] = (l
>> 16) & 0xff;
1741 l
= itoa64_to_int (buf
[80]) << 0;
1742 l
|= itoa64_to_int (buf
[81]) << 6;
1743 l
|= itoa64_to_int (buf
[82]) << 12;
1744 l
|= itoa64_to_int (buf
[83]) << 18;
1746 digest
[62] = (l
>> 0) & 0xff;
1747 digest
[61] = (l
>> 8) & 0xff;
1748 digest
[60] = (l
>> 16) & 0xff;
1750 l
= itoa64_to_int (buf
[84]) << 0;
1751 l
|= itoa64_to_int (buf
[85]) << 6;
1753 digest
[63] = (l
>> 16) & 0xff;
1756 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1760 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1762 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1763 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1764 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1765 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1767 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1769 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1770 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1771 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1772 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1774 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1776 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1777 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1778 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1779 buf
[11] = int_to_itoa64 (l
& 0x3f);
1781 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1783 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1784 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1785 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1786 buf
[15] = int_to_itoa64 (l
& 0x3f);
1788 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1790 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1791 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1792 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1793 buf
[19] = int_to_itoa64 (l
& 0x3f);
1795 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1797 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1798 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1799 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1800 buf
[23] = int_to_itoa64 (l
& 0x3f);
1802 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1804 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1805 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1806 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1807 buf
[27] = int_to_itoa64 (l
& 0x3f);
1809 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1811 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1812 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1813 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1814 buf
[31] = int_to_itoa64 (l
& 0x3f);
1816 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1818 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1819 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1820 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1821 buf
[35] = int_to_itoa64 (l
& 0x3f);
1823 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1825 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1826 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1827 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1828 buf
[39] = int_to_itoa64 (l
& 0x3f);
1830 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1832 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1833 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1834 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1835 buf
[43] = int_to_itoa64 (l
& 0x3f);
1837 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1839 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1840 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1841 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1842 buf
[47] = int_to_itoa64 (l
& 0x3f);
1844 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1846 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1847 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1848 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1849 buf
[51] = int_to_itoa64 (l
& 0x3f);
1851 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1853 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1854 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1855 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1856 buf
[55] = int_to_itoa64 (l
& 0x3f);
1858 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1860 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1861 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1862 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1863 buf
[59] = int_to_itoa64 (l
& 0x3f);
1865 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1867 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1868 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1869 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1870 buf
[63] = int_to_itoa64 (l
& 0x3f);
1872 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1874 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1875 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1876 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1877 buf
[67] = int_to_itoa64 (l
& 0x3f);
1879 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1881 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1882 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1883 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1884 buf
[71] = int_to_itoa64 (l
& 0x3f);
1886 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1888 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1889 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1890 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1891 buf
[75] = int_to_itoa64 (l
& 0x3f);
1893 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1895 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1896 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1897 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1898 buf
[79] = int_to_itoa64 (l
& 0x3f);
1900 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1902 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1903 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1904 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1905 buf
[83] = int_to_itoa64 (l
& 0x3f);
1907 l
= 0 | 0 | (digest
[63] << 16);
1909 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1910 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1913 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1917 l
= itoa64_to_int (buf
[ 0]) << 0;
1918 l
|= itoa64_to_int (buf
[ 1]) << 6;
1919 l
|= itoa64_to_int (buf
[ 2]) << 12;
1920 l
|= itoa64_to_int (buf
[ 3]) << 18;
1922 digest
[ 0] = (l
>> 16) & 0xff;
1923 digest
[10] = (l
>> 8) & 0xff;
1924 digest
[20] = (l
>> 0) & 0xff;
1926 l
= itoa64_to_int (buf
[ 4]) << 0;
1927 l
|= itoa64_to_int (buf
[ 5]) << 6;
1928 l
|= itoa64_to_int (buf
[ 6]) << 12;
1929 l
|= itoa64_to_int (buf
[ 7]) << 18;
1931 digest
[21] = (l
>> 16) & 0xff;
1932 digest
[ 1] = (l
>> 8) & 0xff;
1933 digest
[11] = (l
>> 0) & 0xff;
1935 l
= itoa64_to_int (buf
[ 8]) << 0;
1936 l
|= itoa64_to_int (buf
[ 9]) << 6;
1937 l
|= itoa64_to_int (buf
[10]) << 12;
1938 l
|= itoa64_to_int (buf
[11]) << 18;
1940 digest
[12] = (l
>> 16) & 0xff;
1941 digest
[22] = (l
>> 8) & 0xff;
1942 digest
[ 2] = (l
>> 0) & 0xff;
1944 l
= itoa64_to_int (buf
[12]) << 0;
1945 l
|= itoa64_to_int (buf
[13]) << 6;
1946 l
|= itoa64_to_int (buf
[14]) << 12;
1947 l
|= itoa64_to_int (buf
[15]) << 18;
1949 digest
[ 3] = (l
>> 16) & 0xff;
1950 digest
[13] = (l
>> 8) & 0xff;
1951 digest
[23] = (l
>> 0) & 0xff;
1953 l
= itoa64_to_int (buf
[16]) << 0;
1954 l
|= itoa64_to_int (buf
[17]) << 6;
1955 l
|= itoa64_to_int (buf
[18]) << 12;
1956 l
|= itoa64_to_int (buf
[19]) << 18;
1958 digest
[24] = (l
>> 16) & 0xff;
1959 digest
[ 4] = (l
>> 8) & 0xff;
1960 digest
[14] = (l
>> 0) & 0xff;
1962 l
= itoa64_to_int (buf
[20]) << 0;
1963 l
|= itoa64_to_int (buf
[21]) << 6;
1964 l
|= itoa64_to_int (buf
[22]) << 12;
1965 l
|= itoa64_to_int (buf
[23]) << 18;
1967 digest
[15] = (l
>> 16) & 0xff;
1968 digest
[25] = (l
>> 8) & 0xff;
1969 digest
[ 5] = (l
>> 0) & 0xff;
1971 l
= itoa64_to_int (buf
[24]) << 0;
1972 l
|= itoa64_to_int (buf
[25]) << 6;
1973 l
|= itoa64_to_int (buf
[26]) << 12;
1974 l
|= itoa64_to_int (buf
[27]) << 18;
1976 digest
[ 6] = (l
>> 16) & 0xff;
1977 digest
[16] = (l
>> 8) & 0xff;
1978 digest
[26] = (l
>> 0) & 0xff;
1980 l
= itoa64_to_int (buf
[28]) << 0;
1981 l
|= itoa64_to_int (buf
[29]) << 6;
1982 l
|= itoa64_to_int (buf
[30]) << 12;
1983 l
|= itoa64_to_int (buf
[31]) << 18;
1985 digest
[27] = (l
>> 16) & 0xff;
1986 digest
[ 7] = (l
>> 8) & 0xff;
1987 digest
[17] = (l
>> 0) & 0xff;
1989 l
= itoa64_to_int (buf
[32]) << 0;
1990 l
|= itoa64_to_int (buf
[33]) << 6;
1991 l
|= itoa64_to_int (buf
[34]) << 12;
1992 l
|= itoa64_to_int (buf
[35]) << 18;
1994 digest
[18] = (l
>> 16) & 0xff;
1995 digest
[28] = (l
>> 8) & 0xff;
1996 digest
[ 8] = (l
>> 0) & 0xff;
1998 l
= itoa64_to_int (buf
[36]) << 0;
1999 l
|= itoa64_to_int (buf
[37]) << 6;
2000 l
|= itoa64_to_int (buf
[38]) << 12;
2001 l
|= itoa64_to_int (buf
[39]) << 18;
2003 digest
[ 9] = (l
>> 16) & 0xff;
2004 digest
[19] = (l
>> 8) & 0xff;
2005 digest
[29] = (l
>> 0) & 0xff;
2007 l
= itoa64_to_int (buf
[40]) << 0;
2008 l
|= itoa64_to_int (buf
[41]) << 6;
2009 l
|= itoa64_to_int (buf
[42]) << 12;
2011 digest
[31] = (l
>> 8) & 0xff;
2012 digest
[30] = (l
>> 0) & 0xff;
2015 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2019 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2021 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2022 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2023 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2024 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2026 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2028 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2029 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2030 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2031 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2033 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2035 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2036 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2037 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2038 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2042 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2043 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2044 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2045 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2049 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2050 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2051 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2052 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2056 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2057 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2058 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2059 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2063 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2064 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2065 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2066 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2070 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2071 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2072 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2073 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2077 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2078 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2079 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2080 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2084 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2085 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2086 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2087 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2091 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2092 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2093 buf
[42] = int_to_itoa64 (l
& 0x3f);
2096 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2100 l
= itoa64_to_int (buf
[ 0]) << 0;
2101 l
|= itoa64_to_int (buf
[ 1]) << 6;
2102 l
|= itoa64_to_int (buf
[ 2]) << 12;
2103 l
|= itoa64_to_int (buf
[ 3]) << 18;
2105 digest
[ 0] = (l
>> 0) & 0xff;
2106 digest
[ 1] = (l
>> 8) & 0xff;
2107 digest
[ 2] = (l
>> 16) & 0xff;
2109 l
= itoa64_to_int (buf
[ 4]) << 0;
2110 l
|= itoa64_to_int (buf
[ 5]) << 6;
2111 l
|= itoa64_to_int (buf
[ 6]) << 12;
2112 l
|= itoa64_to_int (buf
[ 7]) << 18;
2114 digest
[ 3] = (l
>> 0) & 0xff;
2115 digest
[ 4] = (l
>> 8) & 0xff;
2116 digest
[ 5] = (l
>> 16) & 0xff;
2118 l
= itoa64_to_int (buf
[ 8]) << 0;
2119 l
|= itoa64_to_int (buf
[ 9]) << 6;
2120 l
|= itoa64_to_int (buf
[10]) << 12;
2121 l
|= itoa64_to_int (buf
[11]) << 18;
2123 digest
[ 6] = (l
>> 0) & 0xff;
2124 digest
[ 7] = (l
>> 8) & 0xff;
2125 digest
[ 8] = (l
>> 16) & 0xff;
2127 l
= itoa64_to_int (buf
[12]) << 0;
2128 l
|= itoa64_to_int (buf
[13]) << 6;
2129 l
|= itoa64_to_int (buf
[14]) << 12;
2130 l
|= itoa64_to_int (buf
[15]) << 18;
2132 digest
[ 9] = (l
>> 0) & 0xff;
2133 digest
[10] = (l
>> 8) & 0xff;
2134 digest
[11] = (l
>> 16) & 0xff;
2136 l
= itoa64_to_int (buf
[16]) << 0;
2137 l
|= itoa64_to_int (buf
[17]) << 6;
2138 l
|= itoa64_to_int (buf
[18]) << 12;
2139 l
|= itoa64_to_int (buf
[19]) << 18;
2141 digest
[12] = (l
>> 0) & 0xff;
2142 digest
[13] = (l
>> 8) & 0xff;
2143 digest
[14] = (l
>> 16) & 0xff;
2145 l
= itoa64_to_int (buf
[20]) << 0;
2146 l
|= itoa64_to_int (buf
[21]) << 6;
2147 l
|= itoa64_to_int (buf
[22]) << 12;
2148 l
|= itoa64_to_int (buf
[23]) << 18;
2150 digest
[15] = (l
>> 0) & 0xff;
2151 digest
[16] = (l
>> 8) & 0xff;
2152 digest
[17] = (l
>> 16) & 0xff;
2154 l
= itoa64_to_int (buf
[24]) << 0;
2155 l
|= itoa64_to_int (buf
[25]) << 6;
2156 l
|= itoa64_to_int (buf
[26]) << 12;
2157 l
|= itoa64_to_int (buf
[27]) << 18;
2159 digest
[18] = (l
>> 0) & 0xff;
2160 digest
[19] = (l
>> 8) & 0xff;
2161 digest
[20] = (l
>> 16) & 0xff;
2163 l
= itoa64_to_int (buf
[28]) << 0;
2164 l
|= itoa64_to_int (buf
[29]) << 6;
2165 l
|= itoa64_to_int (buf
[30]) << 12;
2166 l
|= itoa64_to_int (buf
[31]) << 18;
2168 digest
[21] = (l
>> 0) & 0xff;
2169 digest
[22] = (l
>> 8) & 0xff;
2170 digest
[23] = (l
>> 16) & 0xff;
2172 l
= itoa64_to_int (buf
[32]) << 0;
2173 l
|= itoa64_to_int (buf
[33]) << 6;
2174 l
|= itoa64_to_int (buf
[34]) << 12;
2175 l
|= itoa64_to_int (buf
[35]) << 18;
2177 digest
[24] = (l
>> 0) & 0xff;
2178 digest
[25] = (l
>> 8) & 0xff;
2179 digest
[26] = (l
>> 16) & 0xff;
2181 l
= itoa64_to_int (buf
[36]) << 0;
2182 l
|= itoa64_to_int (buf
[37]) << 6;
2183 l
|= itoa64_to_int (buf
[38]) << 12;
2184 l
|= itoa64_to_int (buf
[39]) << 18;
2186 digest
[27] = (l
>> 0) & 0xff;
2187 digest
[28] = (l
>> 8) & 0xff;
2188 digest
[29] = (l
>> 16) & 0xff;
2190 l
= itoa64_to_int (buf
[40]) << 0;
2191 l
|= itoa64_to_int (buf
[41]) << 6;
2192 l
|= itoa64_to_int (buf
[42]) << 12;
2193 l
|= itoa64_to_int (buf
[43]) << 18;
2195 digest
[30] = (l
>> 0) & 0xff;
2196 digest
[31] = (l
>> 8) & 0xff;
2197 digest
[32] = (l
>> 16) & 0xff;
2232 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2236 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2238 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2239 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2240 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2241 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2243 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2245 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2246 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2247 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2248 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2250 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2252 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2253 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2254 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2255 buf
[11] = int_to_itoa64 (l
& 0x3f);
2257 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2259 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2260 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2261 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2262 buf
[15] = int_to_itoa64 (l
& 0x3f);
2264 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2266 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2267 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2268 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2269 buf
[19] = int_to_itoa64 (l
& 0x3f);
2271 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2273 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2274 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2275 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2276 buf
[23] = int_to_itoa64 (l
& 0x3f);
2278 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2280 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2281 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2282 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2283 buf
[27] = int_to_itoa64 (l
& 0x3f);
2285 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2287 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2288 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2289 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2290 buf
[31] = int_to_itoa64 (l
& 0x3f);
2292 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2294 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2295 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2296 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2297 buf
[35] = int_to_itoa64 (l
& 0x3f);
2299 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2301 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2302 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2303 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2304 buf
[39] = int_to_itoa64 (l
& 0x3f);
2306 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2308 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2309 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2310 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2311 //buf[43] = int_to_itoa64 (l & 0x3f);
2319 static struct termio savemodes
;
2320 static int havemodes
= 0;
2324 struct termio modmodes
;
2326 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2330 modmodes
= savemodes
;
2331 modmodes
.c_lflag
&= ~ICANON
;
2332 modmodes
.c_cc
[VMIN
] = 1;
2333 modmodes
.c_cc
[VTIME
] = 0;
2335 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2344 FD_SET (fileno (stdin
), &rfds
);
2351 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2353 if (retval
== 0) return 0;
2354 if (retval
== -1) return -1;
2361 if (!havemodes
) return 0;
2363 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2368 static struct termios savemodes
;
2369 static int havemodes
= 0;
2373 struct termios modmodes
;
2375 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2379 modmodes
= savemodes
;
2380 modmodes
.c_lflag
&= ~ICANON
;
2381 modmodes
.c_cc
[VMIN
] = 1;
2382 modmodes
.c_cc
[VTIME
] = 0;
2384 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2393 FD_SET (fileno (stdin
), &rfds
);
2400 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2402 if (retval
== 0) return 0;
2403 if (retval
== -1) return -1;
2410 if (!havemodes
) return 0;
2412 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2417 static DWORD saveMode
= 0;
2421 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2423 GetConsoleMode (stdinHandle
, &saveMode
);
2424 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2431 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2433 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2435 if (rc
== WAIT_TIMEOUT
) return 0;
2436 if (rc
== WAIT_ABANDONED
) return -1;
2437 if (rc
== WAIT_FAILED
) return -1;
2439 // The whole ReadConsoleInput () part is a workaround.
2440 // For some unknown reason, maybe a mingw bug, a random signal
2441 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2442 // Then it wants to read with getche () a keyboard input
2443 // which has never been made.
2445 INPUT_RECORD buf
[100];
2449 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2451 FlushConsoleInputBuffer (stdinHandle
);
2453 for (uint i
= 0; i
< num
; i
++)
2455 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2457 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2459 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2461 return KeyEvent
.uChar
.AsciiChar
;
2469 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2471 SetConsoleMode (stdinHandle
, saveMode
);
2481 #define MSG_ENOMEM "Insufficient memory available"
2483 void *mycalloc (size_t nmemb
, size_t size
)
2485 void *p
= calloc (nmemb
, size
);
2489 log_error ("ERROR: %s", MSG_ENOMEM
);
2497 void *mymalloc (size_t size
)
2499 void *p
= malloc (size
);
2503 log_error ("ERROR: %s", MSG_ENOMEM
);
2508 memset (p
, 0, size
);
2513 void myfree (void *ptr
)
2515 if (ptr
== NULL
) return;
2520 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2522 void *p
= realloc (ptr
, oldsz
+ add
);
2526 log_error ("ERROR: %s", MSG_ENOMEM
);
2531 memset ((char *) p
+ oldsz
, 0, add
);
2536 char *mystrdup (const char *s
)
2538 const size_t len
= strlen (s
);
2540 char *b
= (char *) mymalloc (len
+ 1);
2547 FILE *logfile_open (char *logfile
)
2549 FILE *fp
= fopen (logfile
, "ab");
2559 void logfile_close (FILE *fp
)
2561 if (fp
== stdout
) return;
2566 void logfile_append (const char *fmt
, ...)
2568 if (data
.logfile_disable
== 1) return;
2570 FILE *fp
= logfile_open (data
.logfile
);
2576 vfprintf (fp
, fmt
, ap
);
2587 int logfile_generate_id ()
2589 const int n
= rand ();
2598 char *logfile_generate_topid ()
2600 const int id
= logfile_generate_id ();
2602 char *topid
= (char *) mymalloc (1 + 16 + 1);
2604 sprintf (topid
, "TOP%08x", id
);
2609 char *logfile_generate_subid ()
2611 const int id
= logfile_generate_id ();
2613 char *subid
= (char *) mymalloc (1 + 16 + 1);
2615 sprintf (subid
, "SUB%08x", id
);
2627 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2629 FlushFileBuffers (h
);
2638 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2642 if (hc_NvAPI_EnumPhysicalGPUs (nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2646 log_info ("WARN: No NvAPI adapters found");
2656 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2660 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2662 if (hc_NVML_nvmlDeviceGetHandleByIndex (data
.hm_dll_nv
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2664 //can be used to determine if the device by index matches the cuda device by index
2665 //char name[100]; memset (name, 0, sizeof (name));
2666 //hc_NVML_nvmlDeviceGetName (data.hm_dll_nv, nvGPUHandle[i], name, sizeof (name) - 1);
2673 log_info ("WARN: No NVML adapters found");
2682 void hm_close (HM_LIB hm_dll
)
2688 FreeLibrary (hm_dll
);
2693 HM_LIB
hm_init (const cl_uint vendor_id
)
2695 HM_LIB hm_dll
= NULL
;
2697 if (vendor_id
== VENDOR_ID_AMD
)
2700 hm_dll
= dlopen ("libatiadlxx.so", RTLD_LAZY
| RTLD_GLOBAL
);
2703 hm_dll
= LoadLibrary ("atiadlxx.dll");
2707 hm_dll
= LoadLibrary ("atiadlxy.dll");
2714 if (vendor_id
== VENDOR_ID_NV
)
2716 hm_dll
= dlopen ("libnvidia-ml.so", RTLD_LAZY
| RTLD_GLOBAL
);
2723 int get_adapters_num_amd (HM_LIB hm_dll_amd
, int *iNumberAdapters
)
2725 if (hc_ADL_Adapter_NumberOfAdapters_Get (hm_dll_amd
, 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 (hc_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 (hc_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 (HM_LIB hm_dll_amd
, int iNumberAdapters
)
2775 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2777 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2779 if (hc_ADL_Adapter_AdapterInfo_Get (hm_dll_amd
, 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 (HM_LIB hm_dll_amd
, 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 (hm_dll_amd, 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 (hc_ADL_Overdrive5_FanSpeedInfo_Get (hm_dll_amd
, 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 (hc_ADL_Overdrive6_FanSpeed_Get (hm_dll_amd
, 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 (HM_LIB hm_dll_amd
, 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 (hc_ADL_Overdrive_Caps (hm_dll_amd
, 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
;
3062 int hm_get_temperature_with_device_id (const uint device_id
)
3064 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3066 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3068 if (data
.hm_dll_amd
)
3070 if (data
.hm_device
[device_id
].od_version
== 5)
3072 ADLTemperature Temperature
;
3074 Temperature
.iSize
= sizeof (ADLTemperature
);
3076 if (hc_ADL_Overdrive5_Temperature_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3078 return Temperature
.iTemperature
/ 1000;
3080 else if (data
.hm_device
[device_id
].od_version
== 6)
3082 int Temperature
= 0;
3084 if (hc_ADL_Overdrive6_Temperature_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3086 return Temperature
/ 1000;
3090 else if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3093 int temperature
= 0;
3095 hc_NVML_nvmlDeviceGetTemperature (data
.hm_dll_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (unsigned int *) &temperature
);
3101 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3103 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3104 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3105 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3106 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3108 if (hc_NvAPI_GPU_GetThermalSettings (data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3110 return pThermalSettings
.sensor
[0].currentTemp
;
3117 int hm_get_fanspeed_with_device_id (const uint device_id
)
3119 // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
3120 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3122 if (data
.hm_device
[device_id
].fan_supported
== 1)
3124 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3126 if (data
.hm_dll_amd
)
3128 if (data
.hm_device
[device_id
].od_version
== 5)
3130 ADLFanSpeedValue lpFanSpeedValue
;
3132 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3134 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3135 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3136 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3138 if (hc_ADL_Overdrive5_FanSpeed_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3140 return lpFanSpeedValue
.iFanSpeed
;
3142 else // od_version == 6
3144 ADLOD6FanSpeedInfo faninfo
;
3146 memset (&faninfo
, 0, sizeof (faninfo
));
3148 if (hc_ADL_Overdrive6_FanSpeed_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3150 return faninfo
.iFanSpeedPercent
;
3154 else if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3159 hc_NVML_nvmlDeviceGetFanSpeed (data
.hm_dll_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (unsigned int *) &speed
);
3167 hc_NvAPI_GPU_GetTachReading (data
.hm_device
[device_id
].adapter_index
.nv
, &speed
);
3177 int hm_get_utilization_with_device_id (const uint device_id
)
3179 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3181 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3183 if (data
.hm_dll_amd
)
3185 ADLPMActivity PMActivity
;
3187 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3189 if (hc_ADL_Overdrive_CurrentActivity_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3191 return PMActivity
.iActivityPercent
;
3194 else if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3197 nvmlUtilization_t utilization
;
3199 hc_NVML_nvmlDeviceGetUtilizationRates (data
.hm_dll_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3201 return utilization
.gpu
;
3205 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3207 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3209 if (hc_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3211 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3218 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3220 if (data
.hm_device
[device_id
].fan_supported
== 1)
3222 if (data
.hm_dll_amd
)
3224 if (data
.hm_device
[device_id
].od_version
== 5)
3226 ADLFanSpeedValue lpFanSpeedValue
;
3228 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3230 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3231 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3232 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3233 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3235 if (hc_ADL_Overdrive5_FanSpeed_Set (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3239 else // od_version == 6
3241 ADLOD6FanSpeedValue fan_speed_value
;
3243 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3245 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3246 fan_speed_value
.iFanSpeed
= fanspeed
;
3248 if (hc_ADL_Overdrive6_FanSpeed_Set (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3258 // helper function for status display
3260 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3262 #define VALUE_NOT_AVAILABLE "N/A"
3266 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3270 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3278 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3280 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3282 if (css_cnt
> SP_PW_MAX
)
3284 log_error ("ERROR: mask length is too long");
3289 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3291 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3293 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3294 uint cs_len
= css
[css_pos
].cs_len
;
3296 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3298 uint c
= cs_buf
[cs_pos
] & 0xff;
3305 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3307 cs_t
*cs
= &css
[css_cnt
];
3309 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3311 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3313 memset (css_uniq
, 0, css_uniq_sz
);
3317 for (i
= 0; i
< cs
->cs_len
; i
++)
3319 const uint u
= cs
->cs_buf
[i
];
3324 for (i
= 0; i
< in_len
; i
++)
3326 uint u
= in_buf
[i
] & 0xff;
3328 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3330 if (css_uniq
[u
] == 1) continue;
3334 cs
->cs_buf
[cs
->cs_len
] = u
;
3342 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3346 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3348 uint p0
= in_buf
[in_pos
] & 0xff;
3350 if (interpret
== 1 && p0
== '?')
3354 if (in_pos
== in_len
) break;
3356 uint p1
= in_buf
[in_pos
] & 0xff;
3360 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3362 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3364 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3366 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3368 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3370 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3372 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3373 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3375 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3376 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3378 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3379 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3381 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3382 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3384 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3386 default: log_error ("Syntax error: %s", in_buf
);
3392 if (data
.hex_charset
)
3396 if (in_pos
== in_len
)
3398 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3403 uint p1
= in_buf
[in_pos
] & 0xff;
3405 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3407 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3414 chr
= hex_convert (p1
) << 0;
3415 chr
|= hex_convert (p0
) << 4;
3417 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3423 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3429 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3433 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3435 sum
*= css
[css_pos
].cs_len
;
3441 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3443 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3448 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3450 char p0
= mask_buf
[mask_pos
];
3456 if (mask_pos
== mask_len
) break;
3458 char p1
= mask_buf
[mask_pos
];
3464 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3466 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3468 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3470 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3472 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3474 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3476 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3477 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3479 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3480 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3482 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3483 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3485 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3486 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3488 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3490 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3496 if (data
.hex_charset
)
3500 // if there is no 2nd hex character, show an error:
3502 if (mask_pos
== mask_len
)
3504 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3509 char p1
= mask_buf
[mask_pos
];
3511 // if they are not valid hex character, show an error:
3513 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3515 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3522 chr
|= hex_convert (p1
) << 0;
3523 chr
|= hex_convert (p0
) << 4;
3525 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3531 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3538 log_error ("ERROR: invalid mask length (0)");
3548 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3550 for (int i
= 0; i
< css_cnt
; i
++)
3552 uint len
= css
[i
].cs_len
;
3553 u64 next
= val
/ len
;
3554 uint pos
= val
% len
;
3555 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3560 void mp_cut_at (char *mask
, uint max
)
3564 uint mask_len
= strlen (mask
);
3566 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3568 if (mask
[i
] == '?') i
++;
3574 void mp_setup_sys (cs_t
*mp_sys
)
3578 uint donec
[CHARSIZ
];
3580 memset (donec
, 0, sizeof (donec
));
3582 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3583 mp_sys
[0].cs_buf
[pos
++] = chr
;
3584 mp_sys
[0].cs_len
= pos
; }
3586 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3587 mp_sys
[1].cs_buf
[pos
++] = chr
;
3588 mp_sys
[1].cs_len
= pos
; }
3590 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3591 mp_sys
[2].cs_buf
[pos
++] = chr
;
3592 mp_sys
[2].cs_len
= pos
; }
3594 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3595 mp_sys
[3].cs_buf
[pos
++] = chr
;
3596 mp_sys
[3].cs_len
= pos
; }
3598 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3599 mp_sys
[4].cs_len
= pos
; }
3601 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3602 mp_sys
[5].cs_len
= pos
; }
3605 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3607 FILE *fp
= fopen (buf
, "rb");
3609 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3611 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3617 memset (mp_file
, 0, sizeof (mp_file
));
3619 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3623 len
= in_superchop (mp_file
);
3627 log_info ("WARNING: charset file corrupted");
3629 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3633 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3638 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3640 mp_usr
[index
].cs_len
= 0;
3642 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3645 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3647 char *new_mask_buf
= (char *) mymalloc (256);
3653 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3655 if (css_pos
== len
) break;
3657 char p0
= mask_buf
[mask_pos
];
3659 new_mask_buf
[mask_pos
] = p0
;
3665 if (mask_pos
== mask_len
) break;
3667 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3671 if (data
.hex_charset
)
3675 if (mask_pos
== mask_len
)
3677 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3682 char p1
= mask_buf
[mask_pos
];
3684 // if they are not valid hex character, show an error:
3686 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3688 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3693 new_mask_buf
[mask_pos
] = p1
;
3698 if (css_pos
== len
) return (new_mask_buf
);
3700 myfree (new_mask_buf
);
3709 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3715 for (i
= start
; i
< stop
; i
++)
3717 sum
*= root_css_buf
[i
].cs_len
;
3723 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3727 cs_t
*cs
= &root_css_buf
[start
];
3731 for (i
= start
; i
< stop
; i
++)
3733 const u64 m
= v
% cs
->cs_len
;
3734 const u64 d
= v
/ cs
->cs_len
;
3738 const uint k
= cs
->cs_buf
[m
];
3740 pw_buf
[i
- start
] = (char) k
;
3742 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3746 int sp_comp_val (const void *p1
, const void *p2
)
3748 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3749 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3751 return b2
->val
- b1
->val
;
3754 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
)
3761 * Initialize hcstats
3764 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3766 u64
*root_stats_ptr
= root_stats_buf
;
3768 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3770 for (i
= 0; i
< SP_PW_MAX
; i
++)
3772 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3774 root_stats_ptr
+= CHARSIZ
;
3777 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3779 u64
*markov_stats_ptr
= markov_stats_buf
;
3781 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3783 for (i
= 0; i
< SP_PW_MAX
; i
++)
3785 for (j
= 0; j
< CHARSIZ
; j
++)
3787 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3789 markov_stats_ptr
+= CHARSIZ
;
3799 char hcstat_tmp
[256];
3801 memset (hcstat_tmp
, 0, sizeof (hcstat_tmp
));
3803 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3805 hcstat
= hcstat_tmp
;
3808 FILE *fd
= fopen (hcstat
, "rb");
3812 log_error ("%s: %s", hcstat
, strerror (errno
));
3817 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3819 log_error ("%s: Could not load data", hcstat
);
3824 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3826 log_error ("%s: Could not load data", hcstat
);
3834 * Markov modifier of hcstat_table on user request
3839 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
3840 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
3845 /* Add all stats to first position */
3847 for (i
= 1; i
< SP_PW_MAX
; i
++)
3849 u64
*out
= root_stats_buf_by_pos
[0];
3850 u64
*in
= root_stats_buf_by_pos
[i
];
3852 for (j
= 0; j
< CHARSIZ
; j
++)
3858 for (i
= 1; i
< SP_PW_MAX
; i
++)
3860 u64
*out
= markov_stats_buf_by_key
[0][0];
3861 u64
*in
= markov_stats_buf_by_key
[i
][0];
3863 for (j
= 0; j
< CHARSIZ
; j
++)
3865 for (k
= 0; k
< CHARSIZ
; k
++)
3872 /* copy them to all pw_positions */
3874 for (i
= 1; i
< SP_PW_MAX
; i
++)
3876 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
3879 for (i
= 1; i
< SP_PW_MAX
; i
++)
3881 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
3889 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3891 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3893 for (i
= 0; i
< SP_PW_MAX
; i
++)
3895 root_table_buf_by_pos
[i
] = root_table_ptr
;
3897 root_table_ptr
+= CHARSIZ
;
3900 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3902 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3904 for (i
= 0; i
< SP_PW_MAX
; i
++)
3906 for (j
= 0; j
< CHARSIZ
; j
++)
3908 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3910 markov_table_ptr
+= CHARSIZ
;
3915 * Convert hcstat to tables
3918 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3920 uint key
= i
% CHARSIZ
;
3922 root_table_buf
[i
].key
= key
;
3923 root_table_buf
[i
].val
= root_stats_buf
[i
];
3926 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3928 uint key
= i
% CHARSIZ
;
3930 markov_table_buf
[i
].key
= key
;
3931 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3934 myfree (root_stats_buf
);
3935 myfree (markov_stats_buf
);
3941 for (i
= 0; i
< SP_PW_MAX
; i
++)
3943 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3946 for (i
= 0; i
< SP_PW_MAX
; i
++)
3948 for (j
= 0; j
< CHARSIZ
; j
++)
3950 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3955 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
])
3958 * Convert tables to css
3961 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
3963 uint pw_pos
= i
/ CHARSIZ
;
3965 cs_t
*cs
= &root_css_buf
[pw_pos
];
3967 if (cs
->cs_len
== threshold
) continue;
3969 uint key
= root_table_buf
[i
].key
;
3971 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
3973 cs
->cs_buf
[cs
->cs_len
] = key
;
3979 * Convert table to css
3982 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
3984 uint c
= i
/ CHARSIZ
;
3986 cs_t
*cs
= &markov_css_buf
[c
];
3988 if (cs
->cs_len
== threshold
) continue;
3990 uint pw_pos
= c
/ CHARSIZ
;
3992 uint key
= markov_table_buf
[i
].key
;
3994 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
3996 cs
->cs_buf
[cs
->cs_len
] = key
;
4002 for (uint i = 0; i < 8; i++)
4004 for (uint j = 0x20; j < 0x80; j++)
4006 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4008 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4010 for (uint k = 0; k < 10; k++)
4012 printf (" %u\n", ptr->cs_buf[k]);
4019 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4021 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4023 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4033 for (uint j
= 1; j
< CHARSIZ
; j
++)
4043 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4045 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4047 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4049 out
+= CHARSIZ
* CHARSIZ
;
4050 in
+= CHARSIZ
* CHARSIZ
;
4052 for (uint j
= 0; j
< CHARSIZ
; j
++)
4059 for (uint k
= 1; k
< CHARSIZ
; k
++)
4071 * mixed shared functions
4074 void dump_hex (const u8
*s
, const int sz
)
4076 for (int i
= 0; i
< sz
; i
++)
4078 log_info_nn ("%02x ", s
[i
]);
4084 void usage_mini_print (const char *progname
)
4086 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4089 void usage_big_print (const char *progname
)
4091 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4094 char *get_exec_path ()
4096 int exec_path_len
= 1024;
4098 char *exec_path
= (char *) mymalloc (exec_path_len
);
4104 sprintf (tmp
, "/proc/%d/exe", getpid ());
4106 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4112 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4121 char *get_install_dir (const char *progname
)
4123 char *install_dir
= mystrdup (progname
);
4124 char *last_slash
= NULL
;
4126 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4130 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4136 install_dir
[0] = '.';
4140 return (install_dir
);
4143 char *get_profile_dir (const char *homedir
)
4145 #define DOT_HASHCAT ".hashcat"
4147 char *profile_dir
= (char *) mymalloc (strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1);
4149 sprintf (profile_dir
, "%s/%s", homedir
, DOT_HASHCAT
);
4154 char *get_session_dir (const char *profile_dir
)
4156 #define SESSIONS_FOLDER "sessions"
4158 char *session_dir
= (char *) mymalloc (strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1);
4160 sprintf (session_dir
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4165 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4169 FILE *fd
= fopen (filename
, "rb");
4173 log_error ("%s: %s", filename
, strerror (errno
));
4178 #define MAX_KEY_SIZE (1024 * 1024)
4180 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4182 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4188 for (int fpos
= 0; fpos
< nread
; fpos
++)
4190 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4192 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4193 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4194 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4195 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4197 if (kpos
>= 64) kpos
= 0;
4203 void set_cpu_affinity (char *cpu_affinity
)
4206 DWORD_PTR aff_mask
= 0;
4217 char *devices
= strdup (cpu_affinity
);
4219 char *next
= strtok (devices
, ",");
4223 uint cpu_id
= atoi (next
);
4240 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4246 aff_mask
|= 1 << (cpu_id
- 1);
4250 CPU_SET ((cpu_id
- 1), &cpuset
);
4253 } while ((next
= strtok (NULL
, ",")) != NULL
);
4259 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4260 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4264 pthread_t thread
= pthread_self ();
4265 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4269 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4271 char *element
, *end
;
4273 end
= (char *) base
+ nmemb
* size
;
4275 for (element
= (char *) base
; element
< end
; element
+= size
)
4276 if (!compar (element
, key
))
4282 int sort_by_salt (const void *v1
, const void *v2
)
4284 const salt_t
*s1
= (const salt_t
*) v1
;
4285 const salt_t
*s2
= (const salt_t
*) v2
;
4287 const int res1
= s1
->salt_len
- s2
->salt_len
;
4289 if (res1
!= 0) return (res1
);
4291 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4293 if (res2
!= 0) return (res2
);
4301 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4302 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4309 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4310 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4316 int sort_by_salt_buf (const void *v1
, const void *v2
)
4318 const pot_t
*p1
= (const pot_t
*) v1
;
4319 const pot_t
*p2
= (const pot_t
*) v2
;
4321 const hash_t
*h1
= &p1
->hash
;
4322 const hash_t
*h2
= &p2
->hash
;
4324 const salt_t
*s1
= h1
->salt
;
4325 const salt_t
*s2
= h2
->salt
;
4331 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4332 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4338 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4340 const hash_t
*h1
= (const hash_t
*) v1
;
4341 const hash_t
*h2
= (const hash_t
*) v2
;
4343 const salt_t
*s1
= h1
->salt
;
4344 const salt_t
*s2
= h2
->salt
;
4346 // testphase: this should work
4351 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4352 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4355 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4356 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4357 if (s1->salt_len > s2->salt_len) return ( 1);
4358 if (s1->salt_len < s2->salt_len) return (-1);
4360 uint n = s1->salt_len;
4364 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4365 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4372 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4374 const hash_t
*h1
= (const hash_t
*) v1
;
4375 const hash_t
*h2
= (const hash_t
*) v2
;
4377 const salt_t
*s1
= h1
->salt
;
4378 const salt_t
*s2
= h2
->salt
;
4380 // 12 - 2 (since last 2 uints contain the digest)
4385 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4386 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4392 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4394 const hash_t
*h1
= (const hash_t
*) v1
;
4395 const hash_t
*h2
= (const hash_t
*) v2
;
4397 const void *d1
= h1
->digest
;
4398 const void *d2
= h2
->digest
;
4400 return data
.sort_by_digest (d1
, d2
);
4403 int sort_by_hash (const void *v1
, const void *v2
)
4405 const hash_t
*h1
= (const hash_t
*) v1
;
4406 const hash_t
*h2
= (const hash_t
*) v2
;
4410 const salt_t
*s1
= h1
->salt
;
4411 const salt_t
*s2
= h2
->salt
;
4413 int res
= sort_by_salt (s1
, s2
);
4415 if (res
!= 0) return (res
);
4418 const void *d1
= h1
->digest
;
4419 const void *d2
= h2
->digest
;
4421 return data
.sort_by_digest (d1
, d2
);
4424 int sort_by_pot (const void *v1
, const void *v2
)
4426 const pot_t
*p1
= (const pot_t
*) v1
;
4427 const pot_t
*p2
= (const pot_t
*) v2
;
4429 const hash_t
*h1
= &p1
->hash
;
4430 const hash_t
*h2
= &p2
->hash
;
4432 return sort_by_hash (h1
, h2
);
4435 int sort_by_mtime (const void *p1
, const void *p2
)
4437 const char **f1
= (const char **) p1
;
4438 const char **f2
= (const char **) p2
;
4440 struct stat s1
; stat (*f1
, &s1
);
4441 struct stat s2
; stat (*f2
, &s2
);
4443 return s2
.st_mtime
- s1
.st_mtime
;
4446 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4448 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4449 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4451 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4454 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4456 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4457 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4459 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4462 int sort_by_stringptr (const void *p1
, const void *p2
)
4464 const char **s1
= (const char **) p1
;
4465 const char **s2
= (const char **) p2
;
4467 return strcmp (*s1
, *s2
);
4470 int sort_by_dictstat (const void *s1
, const void *s2
)
4472 dictstat_t
*d1
= (dictstat_t
*) s1
;
4473 dictstat_t
*d2
= (dictstat_t
*) s2
;
4476 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4478 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4481 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4484 int sort_by_bitmap (const void *p1
, const void *p2
)
4486 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4487 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4489 return b1
->collisions
- b2
->collisions
;
4492 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4494 const u32
*d1
= (const u32
*) v1
;
4495 const u32
*d2
= (const u32
*) v2
;
4501 if (d1
[n
] > d2
[n
]) return ( 1);
4502 if (d1
[n
] < d2
[n
]) return (-1);
4508 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4510 const u32
*d1
= (const u32
*) v1
;
4511 const u32
*d2
= (const u32
*) v2
;
4517 if (d1
[n
] > d2
[n
]) return ( 1);
4518 if (d1
[n
] < d2
[n
]) return (-1);
4524 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4526 const u32
*d1
= (const u32
*) v1
;
4527 const u32
*d2
= (const u32
*) v2
;
4533 if (d1
[n
] > d2
[n
]) return ( 1);
4534 if (d1
[n
] < d2
[n
]) return (-1);
4540 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4542 const u32
*d1
= (const u32
*) v1
;
4543 const u32
*d2
= (const u32
*) v2
;
4549 if (d1
[n
] > d2
[n
]) return ( 1);
4550 if (d1
[n
] < d2
[n
]) return (-1);
4556 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4558 const u32
*d1
= (const u32
*) v1
;
4559 const u32
*d2
= (const u32
*) v2
;
4565 if (d1
[n
] > d2
[n
]) return ( 1);
4566 if (d1
[n
] < d2
[n
]) return (-1);
4572 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4574 const u32
*d1
= (const u32
*) v1
;
4575 const u32
*d2
= (const u32
*) v2
;
4581 if (d1
[n
] > d2
[n
]) return ( 1);
4582 if (d1
[n
] < d2
[n
]) return (-1);
4588 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4590 const u32
*d1
= (const u32
*) v1
;
4591 const u32
*d2
= (const u32
*) v2
;
4597 if (d1
[n
] > d2
[n
]) return ( 1);
4598 if (d1
[n
] < d2
[n
]) return (-1);
4604 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4606 const u32
*d1
= (const u32
*) v1
;
4607 const u32
*d2
= (const u32
*) v2
;
4613 if (d1
[n
] > d2
[n
]) return ( 1);
4614 if (d1
[n
] < d2
[n
]) return (-1);
4620 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4622 const u64
*d1
= (const u64
*) v1
;
4623 const u64
*d2
= (const u64
*) v2
;
4629 if (d1
[n
] > d2
[n
]) return ( 1);
4630 if (d1
[n
] < d2
[n
]) return (-1);
4636 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4638 const u64
*d1
= (const u64
*) v1
;
4639 const u64
*d2
= (const u64
*) v2
;
4645 if (d1
[n
] > d2
[n
]) return ( 1);
4646 if (d1
[n
] < d2
[n
]) return (-1);
4652 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4654 const u64
*d1
= (const u64
*) v1
;
4655 const u64
*d2
= (const u64
*) v2
;
4661 if (d1
[n
] > d2
[n
]) return ( 1);
4662 if (d1
[n
] < d2
[n
]) return (-1);
4668 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4670 const u32
*d1
= (const u32
*) v1
;
4671 const u32
*d2
= (const u32
*) v2
;
4673 const uint dgst_pos0
= data
.dgst_pos0
;
4674 const uint dgst_pos1
= data
.dgst_pos1
;
4675 const uint dgst_pos2
= data
.dgst_pos2
;
4676 const uint dgst_pos3
= data
.dgst_pos3
;
4678 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4679 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4680 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4681 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4682 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4683 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4684 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4685 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4690 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
)
4692 uint outfile_autohex
= data
.outfile_autohex
;
4694 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4696 FILE *debug_fp
= NULL
;
4698 if (debug_file
!= NULL
)
4700 debug_fp
= fopen (debug_file
, "ab");
4707 if (debug_fp
== NULL
)
4709 log_info ("WARNING: Could not open debug-file for writing");
4713 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4715 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4717 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4720 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4722 if (debug_mode
== 4)
4724 fputc (':', debug_fp
);
4726 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4729 fputc ('\n', debug_fp
);
4731 if (debug_file
!= NULL
) fclose (debug_fp
);
4735 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4737 int needs_hexify
= 0;
4739 if (outfile_autohex
== 1)
4741 for (uint i
= 0; i
< plain_len
; i
++)
4743 if (plain_ptr
[i
] < 0x20)
4750 if (plain_ptr
[i
] > 0x7f)
4759 if (needs_hexify
== 1)
4761 fprintf (fp
, "$HEX[");
4763 for (uint i
= 0; i
< plain_len
; i
++)
4765 fprintf (fp
, "%02x", plain_ptr
[i
]);
4772 fwrite (plain_ptr
, plain_len
, 1, fp
);
4776 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
)
4778 uint outfile_format
= data
.outfile_format
;
4780 char separator
= data
.separator
;
4782 if (outfile_format
& OUTFILE_FMT_HASH
)
4784 fprintf (out_fp
, "%s", out_buf
);
4786 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4788 fputc (separator
, out_fp
);
4791 else if (data
.username
)
4793 if (username
!= NULL
)
4795 for (uint i
= 0; i
< user_len
; i
++)
4797 fprintf (out_fp
, "%c", username
[i
]);
4800 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4802 fputc (separator
, out_fp
);
4807 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4809 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4811 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4813 fputc (separator
, out_fp
);
4817 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4819 for (uint i
= 0; i
< plain_len
; i
++)
4821 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4824 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4826 fputc (separator
, out_fp
);
4830 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4833 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4838 fprintf (out_fp
, "%lu", crackpos
);
4840 fprintf (out_fp
, "%llu", crackpos
);
4845 fputc ('\n', out_fp
);
4848 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
)
4852 pot_key
.hash
.salt
= hashes_buf
->salt
;
4853 pot_key
.hash
.digest
= hashes_buf
->digest
;
4855 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4861 input_buf
[input_len
] = 0;
4864 unsigned char *username
= NULL
;
4869 user_t
*user
= hashes_buf
->hash_info
->user
;
4873 username
= (unsigned char *) (user
->user_name
);
4875 user_len
= user
->user_len
;
4879 // do output the line
4880 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
4884 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
4885 #define LM_MASKED_PLAIN "[notfound]"
4887 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
)
4893 pot_left_key
.hash
.salt
= hash_left
->salt
;
4894 pot_left_key
.hash
.digest
= hash_left
->digest
;
4896 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4900 uint weak_hash_found
= 0;
4902 pot_t pot_right_key
;
4904 pot_right_key
.hash
.salt
= hash_right
->salt
;
4905 pot_right_key
.hash
.digest
= hash_right
->digest
;
4907 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4909 if (pot_right_ptr
== NULL
)
4911 // special case, if "weak hash"
4913 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
4915 weak_hash_found
= 1;
4917 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4919 // in theory this is not needed, but we are paranoia:
4921 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4922 pot_right_ptr
->plain_len
= 0;
4926 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
4928 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
4933 // at least one half was found:
4937 input_buf
[input_len
] = 0;
4941 unsigned char *username
= NULL
;
4946 user_t
*user
= hash_left
->hash_info
->user
;
4950 username
= (unsigned char *) (user
->user_name
);
4952 user_len
= user
->user_len
;
4956 // mask the part which was not found
4958 uint left_part_masked
= 0;
4959 uint right_part_masked
= 0;
4961 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
4963 if (pot_left_ptr
== NULL
)
4965 left_part_masked
= 1;
4967 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4969 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
4971 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
4972 pot_left_ptr
->plain_len
= mask_plain_len
;
4975 if (pot_right_ptr
== NULL
)
4977 right_part_masked
= 1;
4979 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4981 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4983 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
4984 pot_right_ptr
->plain_len
= mask_plain_len
;
4987 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
4991 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
4993 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
4995 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
4997 // do output the line
4999 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5001 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5003 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5004 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5007 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
)
5011 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5013 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5015 if (pot_ptr
== NULL
)
5019 input_buf
[input_len
] = 0;
5021 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5025 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
)
5031 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5033 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5037 pot_t pot_right_key
;
5039 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5041 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5043 uint weak_hash_found
= 0;
5045 if (pot_right_ptr
== NULL
)
5047 // special case, if "weak hash"
5049 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5051 weak_hash_found
= 1;
5053 // we just need that pot_right_ptr is not a NULL pointer
5055 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5059 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5061 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5066 // ... at least one part was not cracked
5070 input_buf
[input_len
] = 0;
5072 // only show the hash part which is still not cracked
5074 uint user_len
= input_len
- 32;
5076 char hash_output
[user_len
+ 33];
5078 memset (hash_output
, 0, sizeof (hash_output
));
5080 memcpy (hash_output
, input_buf
, input_len
);
5082 if (pot_left_ptr
!= NULL
)
5084 // only show right part (because left part was already found)
5086 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5088 hash_output
[user_len
+ 16] = 0;
5091 if (pot_right_ptr
!= NULL
)
5093 // only show left part (because right part was already found)
5095 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5097 hash_output
[user_len
+ 16] = 0;
5100 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5102 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5105 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5107 uint opencl_platforms_filter
= 0;
5109 if (opencl_platforms
)
5111 char *platforms
= strdup (opencl_platforms
);
5113 char *next
= strtok (platforms
, ",");
5117 int platform
= atoi (next
);
5119 if (platform
< 1 || platform
> 32)
5121 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5126 opencl_platforms_filter
|= 1 << (platform
- 1);
5128 } while ((next
= strtok (NULL
, ",")) != NULL
);
5134 opencl_platforms_filter
= -1;
5137 return opencl_platforms_filter
;
5140 u32
setup_devices_filter (char *opencl_devices
)
5142 u32 devices_filter
= 0;
5146 char *devices
= strdup (opencl_devices
);
5148 char *next
= strtok (devices
, ",");
5152 int device_id
= atoi (next
);
5154 if (device_id
< 1 || device_id
> 32)
5156 log_error ("ERROR: invalid device_id %u specified", device_id
);
5161 devices_filter
|= 1 << (device_id
- 1);
5163 } while ((next
= strtok (NULL
, ",")) != NULL
);
5169 devices_filter
= -1;
5172 return devices_filter
;
5175 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5177 cl_device_type device_types_filter
= 0;
5179 if (opencl_device_types
)
5181 char *device_types
= strdup (opencl_device_types
);
5183 char *next
= strtok (device_types
, ",");
5187 int device_type
= atoi (next
);
5189 if (device_type
< 1 || device_type
> 3)
5191 log_error ("ERROR: invalid device_type %u specified", device_type
);
5196 device_types_filter
|= 1 << device_type
;
5198 } while ((next
= strtok (NULL
, ",")) != NULL
);
5200 free (device_types
);
5204 // Do not use CPU by default, this often reduces GPU performance because
5205 // the CPU is to busy to handle GPU synchronization
5207 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5210 return device_types_filter
;
5213 u32
get_random_num (const u32 min
, const u32 max
)
5215 if (min
== max
) return (min
);
5217 return ((rand () % (max
- min
)) + min
);
5220 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5222 u32 quotient
= dividend
/ divisor
;
5224 if (dividend
% divisor
) quotient
++;
5229 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5231 u64 quotient
= dividend
/ divisor
;
5233 if (dividend
% divisor
) quotient
++;
5238 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5240 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5241 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5243 if (tm
->tm_year
- 70)
5245 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5246 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5248 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5250 else if (tm
->tm_yday
)
5252 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5253 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5255 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5257 else if (tm
->tm_hour
)
5259 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5260 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5262 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5264 else if (tm
->tm_min
)
5266 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5267 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5269 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5273 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5275 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5279 void format_speed_display (float val
, char *buf
, size_t len
)
5290 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5301 /* generate output */
5305 snprintf (buf
, len
- 1, "%.0f ", val
);
5309 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5313 void lowercase (u8
*buf
, int len
)
5315 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5318 void uppercase (u8
*buf
, int len
)
5320 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5323 int fgetl (FILE *fp
, char *line_buf
)
5329 const int c
= fgetc (fp
);
5331 if (c
== EOF
) break;
5333 line_buf
[line_len
] = (char) c
;
5337 if (line_len
== BUFSIZ
) line_len
--;
5339 if (c
== '\n') break;
5342 if (line_len
== 0) return 0;
5344 if (line_buf
[line_len
- 1] == '\n')
5348 line_buf
[line_len
] = 0;
5351 if (line_len
== 0) return 0;
5353 if (line_buf
[line_len
- 1] == '\r')
5357 line_buf
[line_len
] = 0;
5363 int in_superchop (char *buf
)
5365 int len
= strlen (buf
);
5369 if (buf
[len
- 1] == '\n')
5376 if (buf
[len
- 1] == '\r')
5391 char **scan_directory (const char *path
)
5393 char *tmp_path
= mystrdup (path
);
5395 size_t tmp_path_len
= strlen (tmp_path
);
5397 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5399 tmp_path
[tmp_path_len
- 1] = 0;
5401 tmp_path_len
= strlen (tmp_path
);
5404 char **files
= NULL
;
5410 if ((d
= opendir (tmp_path
)) != NULL
)
5414 while ((de
= readdir (d
)) != NULL
)
5416 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5418 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5420 char *path_file
= (char *) mymalloc (path_size
+ 1);
5422 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5424 path_file
[path_size
] = 0;
5428 if ((d_test
= opendir (path_file
)) != NULL
)
5436 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5440 files
[num_files
- 1] = path_file
;
5446 else if (errno
== ENOTDIR
)
5448 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5452 files
[num_files
- 1] = mystrdup (path
);
5455 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5459 files
[num_files
- 1] = NULL
;
5466 int count_dictionaries (char **dictionary_files
)
5468 if (dictionary_files
== NULL
) return 0;
5472 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5480 char *stroptitype (const uint opti_type
)
5484 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5485 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5486 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5487 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5488 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5489 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5490 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5491 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5492 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5493 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5494 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5495 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5496 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5497 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5503 char *strparser (const uint parser_status
)
5505 switch (parser_status
)
5507 case PARSER_OK
: return ((char *) PA_000
); break;
5508 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5509 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5510 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5511 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5512 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5513 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5514 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5515 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5516 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5517 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5518 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5519 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5520 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5521 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5522 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5523 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5526 return ((char *) PA_255
);
5529 char *strhashtype (const uint hash_mode
)
5533 case 0: return ((char *) HT_00000
); break;
5534 case 10: return ((char *) HT_00010
); break;
5535 case 11: return ((char *) HT_00011
); break;
5536 case 12: return ((char *) HT_00012
); break;
5537 case 20: return ((char *) HT_00020
); break;
5538 case 21: return ((char *) HT_00021
); break;
5539 case 22: return ((char *) HT_00022
); break;
5540 case 23: return ((char *) HT_00023
); break;
5541 case 30: return ((char *) HT_00030
); break;
5542 case 40: return ((char *) HT_00040
); break;
5543 case 50: return ((char *) HT_00050
); break;
5544 case 60: return ((char *) HT_00060
); break;
5545 case 100: return ((char *) HT_00100
); break;
5546 case 101: return ((char *) HT_00101
); break;
5547 case 110: return ((char *) HT_00110
); break;
5548 case 111: return ((char *) HT_00111
); break;
5549 case 112: return ((char *) HT_00112
); break;
5550 case 120: return ((char *) HT_00120
); break;
5551 case 121: return ((char *) HT_00121
); break;
5552 case 122: return ((char *) HT_00122
); break;
5553 case 124: return ((char *) HT_00124
); break;
5554 case 130: return ((char *) HT_00130
); break;
5555 case 131: return ((char *) HT_00131
); break;
5556 case 132: return ((char *) HT_00132
); break;
5557 case 133: return ((char *) HT_00133
); break;
5558 case 140: return ((char *) HT_00140
); break;
5559 case 141: return ((char *) HT_00141
); break;
5560 case 150: return ((char *) HT_00150
); break;
5561 case 160: return ((char *) HT_00160
); break;
5562 case 190: return ((char *) HT_00190
); break;
5563 case 200: return ((char *) HT_00200
); break;
5564 case 300: return ((char *) HT_00300
); break;
5565 case 400: return ((char *) HT_00400
); break;
5566 case 500: return ((char *) HT_00500
); break;
5567 case 501: return ((char *) HT_00501
); break;
5568 case 900: return ((char *) HT_00900
); break;
5569 case 910: return ((char *) HT_00910
); break;
5570 case 1000: return ((char *) HT_01000
); break;
5571 case 1100: return ((char *) HT_01100
); break;
5572 case 1400: return ((char *) HT_01400
); break;
5573 case 1410: return ((char *) HT_01410
); break;
5574 case 1420: return ((char *) HT_01420
); break;
5575 case 1421: return ((char *) HT_01421
); break;
5576 case 1430: return ((char *) HT_01430
); break;
5577 case 1440: return ((char *) HT_01440
); break;
5578 case 1441: return ((char *) HT_01441
); break;
5579 case 1450: return ((char *) HT_01450
); break;
5580 case 1460: return ((char *) HT_01460
); break;
5581 case 1500: return ((char *) HT_01500
); break;
5582 case 1600: return ((char *) HT_01600
); break;
5583 case 1700: return ((char *) HT_01700
); break;
5584 case 1710: return ((char *) HT_01710
); break;
5585 case 1711: return ((char *) HT_01711
); break;
5586 case 1720: return ((char *) HT_01720
); break;
5587 case 1722: return ((char *) HT_01722
); break;
5588 case 1730: return ((char *) HT_01730
); break;
5589 case 1731: return ((char *) HT_01731
); break;
5590 case 1740: return ((char *) HT_01740
); break;
5591 case 1750: return ((char *) HT_01750
); break;
5592 case 1760: return ((char *) HT_01760
); break;
5593 case 1800: return ((char *) HT_01800
); break;
5594 case 2100: return ((char *) HT_02100
); break;
5595 case 2400: return ((char *) HT_02400
); break;
5596 case 2410: return ((char *) HT_02410
); break;
5597 case 2500: return ((char *) HT_02500
); break;
5598 case 2600: return ((char *) HT_02600
); break;
5599 case 2611: return ((char *) HT_02611
); break;
5600 case 2612: return ((char *) HT_02612
); break;
5601 case 2711: return ((char *) HT_02711
); break;
5602 case 2811: return ((char *) HT_02811
); break;
5603 case 3000: return ((char *) HT_03000
); break;
5604 case 3100: return ((char *) HT_03100
); break;
5605 case 3200: return ((char *) HT_03200
); break;
5606 case 3710: return ((char *) HT_03710
); break;
5607 case 3711: return ((char *) HT_03711
); break;
5608 case 3800: return ((char *) HT_03800
); break;
5609 case 4300: return ((char *) HT_04300
); break;
5610 case 4400: return ((char *) HT_04400
); break;
5611 case 4500: return ((char *) HT_04500
); break;
5612 case 4700: return ((char *) HT_04700
); break;
5613 case 4800: return ((char *) HT_04800
); break;
5614 case 4900: return ((char *) HT_04900
); break;
5615 case 5000: return ((char *) HT_05000
); break;
5616 case 5100: return ((char *) HT_05100
); break;
5617 case 5200: return ((char *) HT_05200
); break;
5618 case 5300: return ((char *) HT_05300
); break;
5619 case 5400: return ((char *) HT_05400
); break;
5620 case 5500: return ((char *) HT_05500
); break;
5621 case 5600: return ((char *) HT_05600
); break;
5622 case 5700: return ((char *) HT_05700
); break;
5623 case 5800: return ((char *) HT_05800
); break;
5624 case 6000: return ((char *) HT_06000
); break;
5625 case 6100: return ((char *) HT_06100
); break;
5626 case 6211: return ((char *) HT_06211
); break;
5627 case 6212: return ((char *) HT_06212
); break;
5628 case 6213: return ((char *) HT_06213
); break;
5629 case 6221: return ((char *) HT_06221
); break;
5630 case 6222: return ((char *) HT_06222
); break;
5631 case 6223: return ((char *) HT_06223
); break;
5632 case 6231: return ((char *) HT_06231
); break;
5633 case 6232: return ((char *) HT_06232
); break;
5634 case 6233: return ((char *) HT_06233
); break;
5635 case 6241: return ((char *) HT_06241
); break;
5636 case 6242: return ((char *) HT_06242
); break;
5637 case 6243: return ((char *) HT_06243
); break;
5638 case 6300: return ((char *) HT_06300
); break;
5639 case 6400: return ((char *) HT_06400
); break;
5640 case 6500: return ((char *) HT_06500
); break;
5641 case 6600: return ((char *) HT_06600
); break;
5642 case 6700: return ((char *) HT_06700
); break;
5643 case 6800: return ((char *) HT_06800
); break;
5644 case 6900: return ((char *) HT_06900
); break;
5645 case 7100: return ((char *) HT_07100
); break;
5646 case 7200: return ((char *) HT_07200
); break;
5647 case 7300: return ((char *) HT_07300
); break;
5648 case 7400: return ((char *) HT_07400
); break;
5649 case 7500: return ((char *) HT_07500
); break;
5650 case 7600: return ((char *) HT_07600
); break;
5651 case 7700: return ((char *) HT_07700
); break;
5652 case 7800: return ((char *) HT_07800
); break;
5653 case 7900: return ((char *) HT_07900
); break;
5654 case 8000: return ((char *) HT_08000
); break;
5655 case 8100: return ((char *) HT_08100
); break;
5656 case 8200: return ((char *) HT_08200
); break;
5657 case 8300: return ((char *) HT_08300
); break;
5658 case 8400: return ((char *) HT_08400
); break;
5659 case 8500: return ((char *) HT_08500
); break;
5660 case 8600: return ((char *) HT_08600
); break;
5661 case 8700: return ((char *) HT_08700
); break;
5662 case 8800: return ((char *) HT_08800
); break;
5663 case 8900: return ((char *) HT_08900
); break;
5664 case 9000: return ((char *) HT_09000
); break;
5665 case 9100: return ((char *) HT_09100
); break;
5666 case 9200: return ((char *) HT_09200
); break;
5667 case 9300: return ((char *) HT_09300
); break;
5668 case 9400: return ((char *) HT_09400
); break;
5669 case 9500: return ((char *) HT_09500
); break;
5670 case 9600: return ((char *) HT_09600
); break;
5671 case 9700: return ((char *) HT_09700
); break;
5672 case 9710: return ((char *) HT_09710
); break;
5673 case 9720: return ((char *) HT_09720
); break;
5674 case 9800: return ((char *) HT_09800
); break;
5675 case 9810: return ((char *) HT_09810
); break;
5676 case 9820: return ((char *) HT_09820
); break;
5677 case 9900: return ((char *) HT_09900
); break;
5678 case 10000: return ((char *) HT_10000
); break;
5679 case 10100: return ((char *) HT_10100
); break;
5680 case 10200: return ((char *) HT_10200
); break;
5681 case 10300: return ((char *) HT_10300
); break;
5682 case 10400: return ((char *) HT_10400
); break;
5683 case 10410: return ((char *) HT_10410
); break;
5684 case 10420: return ((char *) HT_10420
); break;
5685 case 10500: return ((char *) HT_10500
); break;
5686 case 10600: return ((char *) HT_10600
); break;
5687 case 10700: return ((char *) HT_10700
); break;
5688 case 10800: return ((char *) HT_10800
); break;
5689 case 10900: return ((char *) HT_10900
); break;
5690 case 11000: return ((char *) HT_11000
); break;
5691 case 11100: return ((char *) HT_11100
); break;
5692 case 11200: return ((char *) HT_11200
); break;
5693 case 11300: return ((char *) HT_11300
); break;
5694 case 11400: return ((char *) HT_11400
); break;
5695 case 11500: return ((char *) HT_11500
); break;
5696 case 11600: return ((char *) HT_11600
); break;
5697 case 11700: return ((char *) HT_11700
); break;
5698 case 11800: return ((char *) HT_11800
); break;
5699 case 11900: return ((char *) HT_11900
); break;
5700 case 12000: return ((char *) HT_12000
); break;
5701 case 12100: return ((char *) HT_12100
); break;
5702 case 12200: return ((char *) HT_12200
); break;
5703 case 12300: return ((char *) HT_12300
); break;
5704 case 12400: return ((char *) HT_12400
); break;
5705 case 12500: return ((char *) HT_12500
); break;
5706 case 12600: return ((char *) HT_12600
); break;
5707 case 12700: return ((char *) HT_12700
); break;
5708 case 12800: return ((char *) HT_12800
); break;
5709 case 12900: return ((char *) HT_12900
); break;
5710 case 13000: return ((char *) HT_13000
); break;
5713 return ((char *) "Unknown");
5716 char *strstatus (const uint devices_status
)
5718 switch (devices_status
)
5720 case STATUS_INIT
: return ((char *) ST_0000
); break;
5721 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5722 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5723 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5724 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5725 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5726 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5727 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5728 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5729 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5732 return ((char *) "Unknown");
5735 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5737 uint hash_type
= data
.hash_type
;
5738 uint hash_mode
= data
.hash_mode
;
5739 uint salt_type
= data
.salt_type
;
5740 uint opts_type
= data
.opts_type
;
5741 uint opti_type
= data
.opti_type
;
5742 uint dgst_size
= data
.dgst_size
;
5744 char *hashfile
= data
.hashfile
;
5748 uint digest_buf
[64];
5750 u64
*digest_buf64
= (u64
*) digest_buf
;
5752 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5754 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5756 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5762 case HASH_TYPE_DESCRYPT
:
5763 FP (digest_buf
[1], digest_buf
[0], tt
);
5766 case HASH_TYPE_DESRACF
:
5767 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5768 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5770 FP (digest_buf
[1], digest_buf
[0], tt
);
5774 FP (digest_buf
[1], digest_buf
[0], tt
);
5777 case HASH_TYPE_NETNTLM
:
5778 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5779 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5780 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5781 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5783 FP (digest_buf
[1], digest_buf
[0], tt
);
5784 FP (digest_buf
[3], digest_buf
[2], tt
);
5787 case HASH_TYPE_BSDICRYPT
:
5788 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5789 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5791 FP (digest_buf
[1], digest_buf
[0], tt
);
5796 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5801 digest_buf
[0] += MD4M_A
;
5802 digest_buf
[1] += MD4M_B
;
5803 digest_buf
[2] += MD4M_C
;
5804 digest_buf
[3] += MD4M_D
;
5808 digest_buf
[0] += MD5M_A
;
5809 digest_buf
[1] += MD5M_B
;
5810 digest_buf
[2] += MD5M_C
;
5811 digest_buf
[3] += MD5M_D
;
5814 case HASH_TYPE_SHA1
:
5815 digest_buf
[0] += SHA1M_A
;
5816 digest_buf
[1] += SHA1M_B
;
5817 digest_buf
[2] += SHA1M_C
;
5818 digest_buf
[3] += SHA1M_D
;
5819 digest_buf
[4] += SHA1M_E
;
5822 case HASH_TYPE_SHA256
:
5823 digest_buf
[0] += SHA256M_A
;
5824 digest_buf
[1] += SHA256M_B
;
5825 digest_buf
[2] += SHA256M_C
;
5826 digest_buf
[3] += SHA256M_D
;
5827 digest_buf
[4] += SHA256M_E
;
5828 digest_buf
[5] += SHA256M_F
;
5829 digest_buf
[6] += SHA256M_G
;
5830 digest_buf
[7] += SHA256M_H
;
5833 case HASH_TYPE_SHA384
:
5834 digest_buf64
[0] += SHA384M_A
;
5835 digest_buf64
[1] += SHA384M_B
;
5836 digest_buf64
[2] += SHA384M_C
;
5837 digest_buf64
[3] += SHA384M_D
;
5838 digest_buf64
[4] += SHA384M_E
;
5839 digest_buf64
[5] += SHA384M_F
;
5840 digest_buf64
[6] += 0;
5841 digest_buf64
[7] += 0;
5844 case HASH_TYPE_SHA512
:
5845 digest_buf64
[0] += SHA512M_A
;
5846 digest_buf64
[1] += SHA512M_B
;
5847 digest_buf64
[2] += SHA512M_C
;
5848 digest_buf64
[3] += SHA512M_D
;
5849 digest_buf64
[4] += SHA512M_E
;
5850 digest_buf64
[5] += SHA512M_F
;
5851 digest_buf64
[6] += SHA512M_G
;
5852 digest_buf64
[7] += SHA512M_H
;
5857 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
5859 if (dgst_size
== DGST_SIZE_4_2
)
5861 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5863 else if (dgst_size
== DGST_SIZE_4_4
)
5865 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5867 else if (dgst_size
== DGST_SIZE_4_5
)
5869 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5871 else if (dgst_size
== DGST_SIZE_4_6
)
5873 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5875 else if (dgst_size
== DGST_SIZE_4_8
)
5877 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5879 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
5881 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
5883 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5885 else if (hash_type
== HASH_TYPE_SHA384
)
5887 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5889 else if (hash_type
== HASH_TYPE_SHA512
)
5891 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5893 else if (hash_type
== HASH_TYPE_GOST
)
5895 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5898 else if (dgst_size
== DGST_SIZE_4_64
)
5900 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5902 else if (dgst_size
== DGST_SIZE_8_25
)
5904 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5908 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
5909 | (data
.salt_type
== SALT_TYPE_EXTERN
)
5910 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
5916 memset (&salt
, 0, sizeof (salt_t
));
5918 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
5920 char *ptr
= (char *) salt
.salt_buf
;
5922 uint len
= salt
.salt_len
;
5924 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5930 case HASH_TYPE_NETNTLM
:
5932 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
5933 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
5935 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
5941 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
5943 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
5951 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
5953 uint max
= salt
.salt_len
/ 4;
5957 for (uint i
= 0; i
< max
; i
++)
5959 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
5963 if (opts_type
& OPTS_TYPE_ST_HEX
)
5967 memset (tmp
, 0, sizeof (tmp
));
5969 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
5971 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
5976 memcpy (ptr
, tmp
, len
);
5979 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
5981 memset (ptr
+ len
, 0, memset_size
);
5983 salt
.salt_len
= len
;
5987 // some modes require special encoding
5990 uint out_buf_plain
[256];
5991 uint out_buf_salt
[256];
5995 memset (out_buf_plain
, 0, sizeof (out_buf_plain
));
5996 memset (out_buf_salt
, 0, sizeof (out_buf_salt
));
5998 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6000 char *ptr_plain
= (char *) out_buf_plain
;
6001 char *ptr_salt
= (char *) out_buf_salt
;
6003 if (hash_mode
== 22)
6007 memset (username
, 0, sizeof (username
));
6009 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6011 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6013 u16
*ptr
= (u16
*) digest_buf
;
6015 tmp_buf
[ 0] = sig
[0];
6016 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6017 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6018 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6019 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6020 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6021 tmp_buf
[ 6] = sig
[1];
6022 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6023 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6024 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6025 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6026 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6027 tmp_buf
[12] = sig
[2];
6028 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6029 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6030 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6031 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6032 tmp_buf
[17] = sig
[3];
6033 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6034 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6035 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6036 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6037 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6038 tmp_buf
[23] = sig
[4];
6039 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6040 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6041 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6042 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6043 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6044 tmp_buf
[29] = sig
[5];
6046 snprintf (out_buf
, len
-1, "%s:%s",
6050 else if (hash_mode
== 23)
6052 // do not show the \nskyper\n part in output
6054 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6056 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6058 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6065 else if (hash_mode
== 101)
6067 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6069 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6070 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6071 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6072 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6073 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6075 memcpy (tmp_buf
, digest_buf
, 20);
6077 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6079 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6081 else if (hash_mode
== 111)
6083 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6085 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6086 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6087 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6088 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6089 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6091 memcpy (tmp_buf
, digest_buf
, 20);
6092 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6094 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6096 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6098 else if (hash_mode
== 122)
6100 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6101 (char *) salt
.salt_buf
,
6108 else if (hash_mode
== 124)
6110 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6111 (char *) salt
.salt_buf
,
6118 else if (hash_mode
== 131)
6120 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6121 (char *) salt
.salt_buf
,
6129 else if (hash_mode
== 132)
6131 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6132 (char *) salt
.salt_buf
,
6139 else if (hash_mode
== 133)
6141 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6143 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6144 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6145 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6146 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6147 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6149 memcpy (tmp_buf
, digest_buf
, 20);
6151 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6153 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6155 else if (hash_mode
== 141)
6157 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6159 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6161 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6163 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6165 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6166 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6167 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6168 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6169 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6171 memcpy (tmp_buf
, digest_buf
, 20);
6173 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6177 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6179 else if (hash_mode
== 400)
6181 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6183 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6184 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6185 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6186 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6188 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6190 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6192 else if (hash_mode
== 500)
6194 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6196 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6197 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6198 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6199 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6201 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6203 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6205 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6209 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6212 else if (hash_mode
== 501)
6214 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6216 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6217 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6219 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6221 else if (hash_mode
== 1421)
6223 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6225 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6241 else if (hash_mode
== 1441)
6243 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6245 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6247 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6249 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6251 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6252 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6253 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6254 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6255 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6256 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6257 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6258 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6260 memcpy (tmp_buf
, digest_buf
, 32);
6262 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6266 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6268 else if (hash_mode
== 1500)
6270 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6271 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6272 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6273 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6274 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6276 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6278 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6280 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6281 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6283 memcpy (tmp_buf
, digest_buf
, 8);
6285 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6287 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6291 else if (hash_mode
== 1600)
6293 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6295 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6296 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6297 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6298 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6300 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6302 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6304 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6308 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6311 else if (hash_mode
== 1711)
6313 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6315 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6316 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6317 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6318 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6319 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6320 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6321 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6322 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6324 memcpy (tmp_buf
, digest_buf
, 64);
6325 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6327 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6329 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6331 else if (hash_mode
== 1722)
6333 uint
*ptr
= digest_buf
;
6335 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6336 (unsigned char *) salt
.salt_buf
,
6346 else if (hash_mode
== 1731)
6348 uint
*ptr
= digest_buf
;
6350 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6351 (unsigned char *) salt
.salt_buf
,
6361 else if (hash_mode
== 1800)
6365 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6366 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6367 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6368 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6369 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6370 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6371 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6372 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6374 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6376 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6378 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6382 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6385 else if (hash_mode
== 2100)
6389 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6391 salt
.salt_iter
+ 1);
6393 uint signature_len
= strlen (out_buf
);
6395 pos
+= signature_len
;
6396 len
-= signature_len
;
6398 char *salt_ptr
= (char *) salt
.salt_buf
;
6400 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6402 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6403 byte_swap_32 (digest_buf
[0]),
6404 byte_swap_32 (digest_buf
[1]),
6405 byte_swap_32 (digest_buf
[2]),
6406 byte_swap_32 (digest_buf
[3]));
6408 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6410 memcpy (tmp_buf
, digest_buf
, 16);
6412 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6414 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6415 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6416 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6417 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6419 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6420 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6421 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6422 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6424 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6425 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6426 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6427 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6429 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6430 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6431 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6432 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6434 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6435 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6436 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6437 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6441 else if (hash_mode
== 2500)
6443 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6445 wpa_t
*wpa
= &wpas
[salt_pos
];
6449 char *pke_ptr
= (char *) pke
;
6451 for (uint i
= 0; i
< 25; i
++)
6453 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6456 unsigned char mac1
[6];
6457 unsigned char mac2
[6];
6459 memcpy (mac1
, pke_ptr
+ 23, 6);
6460 memcpy (mac2
, pke_ptr
+ 29, 6);
6462 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6463 (char *) salt
.salt_buf
,
6477 else if (hash_mode
== 4400)
6479 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6480 byte_swap_32 (digest_buf
[0]),
6481 byte_swap_32 (digest_buf
[1]),
6482 byte_swap_32 (digest_buf
[2]),
6483 byte_swap_32 (digest_buf
[3]));
6485 else if (hash_mode
== 4700)
6487 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6488 byte_swap_32 (digest_buf
[0]),
6489 byte_swap_32 (digest_buf
[1]),
6490 byte_swap_32 (digest_buf
[2]),
6491 byte_swap_32 (digest_buf
[3]),
6492 byte_swap_32 (digest_buf
[4]));
6494 else if (hash_mode
== 4800)
6496 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6498 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6503 byte_swap_32 (salt
.salt_buf
[0]),
6504 byte_swap_32 (salt
.salt_buf
[1]),
6505 byte_swap_32 (salt
.salt_buf
[2]),
6506 byte_swap_32 (salt
.salt_buf
[3]),
6509 else if (hash_mode
== 4900)
6511 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6512 byte_swap_32 (digest_buf
[0]),
6513 byte_swap_32 (digest_buf
[1]),
6514 byte_swap_32 (digest_buf
[2]),
6515 byte_swap_32 (digest_buf
[3]),
6516 byte_swap_32 (digest_buf
[4]));
6518 else if (hash_mode
== 5100)
6520 snprintf (out_buf
, len
-1, "%08x%08x",
6524 else if (hash_mode
== 5200)
6526 snprintf (out_buf
, len
-1, "%s", hashfile
);
6528 else if (hash_mode
== 5300)
6530 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6532 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6534 int buf_len
= len
-1;
6538 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6540 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6542 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6544 snprintf (out_buf
, buf_len
, ":");
6550 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6558 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6560 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6562 if ((i
== 0) || (i
== 5))
6564 snprintf (out_buf
, buf_len
, ":");
6570 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6578 for (uint i
= 0; i
< 4; i
++)
6582 snprintf (out_buf
, buf_len
, ":");
6588 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6594 else if (hash_mode
== 5400)
6596 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6598 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6600 int buf_len
= len
-1;
6604 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6606 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6608 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6610 snprintf (out_buf
, buf_len
, ":");
6616 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6624 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6626 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6628 if ((i
== 0) || (i
== 5))
6630 snprintf (out_buf
, buf_len
, ":");
6636 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6644 for (uint i
= 0; i
< 5; i
++)
6648 snprintf (out_buf
, buf_len
, ":");
6654 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6660 else if (hash_mode
== 5500)
6662 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6664 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6667 char domain_buf
[64];
6668 char srvchall_buf
[1024];
6669 char clichall_buf
[1024];
6671 memset (user_buf
, 0, sizeof (user_buf
));
6672 memset (domain_buf
, 0, sizeof (domain_buf
));
6673 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6674 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6676 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6678 char *ptr
= (char *) netntlm
->userdomain_buf
;
6680 user_buf
[i
] = ptr
[j
];
6683 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6685 char *ptr
= (char *) netntlm
->userdomain_buf
;
6687 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6690 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6692 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6694 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6697 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6699 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6701 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6704 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6712 byte_swap_32 (salt
.salt_buf_pc
[0]),
6713 byte_swap_32 (salt
.salt_buf_pc
[1]),
6716 else if (hash_mode
== 5600)
6718 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6720 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6723 char domain_buf
[64];
6724 char srvchall_buf
[1024];
6725 char clichall_buf
[1024];
6727 memset (user_buf
, 0, sizeof (user_buf
));
6728 memset (domain_buf
, 0, sizeof (domain_buf
));
6729 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6730 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6732 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6734 char *ptr
= (char *) netntlm
->userdomain_buf
;
6736 user_buf
[i
] = ptr
[j
];
6739 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6741 char *ptr
= (char *) netntlm
->userdomain_buf
;
6743 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6746 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6748 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6750 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6753 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6755 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6757 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6760 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6770 else if (hash_mode
== 5700)
6772 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6774 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6775 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6776 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6777 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6778 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6779 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6780 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6781 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6783 memcpy (tmp_buf
, digest_buf
, 32);
6785 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6789 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6791 else if (hash_mode
== 5800)
6793 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6794 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6795 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6796 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6797 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6799 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6806 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6808 snprintf (out_buf
, len
-1, "%s", hashfile
);
6810 else if (hash_mode
== 6300)
6812 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6814 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6815 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6816 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6817 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6819 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6821 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6823 else if (hash_mode
== 6400)
6825 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6827 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6829 else if (hash_mode
== 6500)
6831 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6833 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6835 else if (hash_mode
== 6600)
6837 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6839 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6841 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6842 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6844 uint buf_len
= len
- 1;
6846 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6849 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6851 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6856 else if (hash_mode
== 6700)
6858 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6860 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6862 else if (hash_mode
== 6800)
6864 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6866 else if (hash_mode
== 7100)
6868 uint
*ptr
= digest_buf
;
6870 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6872 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6876 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6877 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6878 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6879 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6880 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6881 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6882 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6883 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6885 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",
6886 SIGNATURE_SHA512OSX
,
6888 esalt
[ 0], esalt
[ 1],
6889 esalt
[ 2], esalt
[ 3],
6890 esalt
[ 4], esalt
[ 5],
6891 esalt
[ 6], esalt
[ 7],
6899 ptr
[15], ptr
[14]);
6901 else if (hash_mode
== 7200)
6903 uint
*ptr
= digest_buf
;
6905 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6907 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6911 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
6913 len_used
= strlen (out_buf
);
6915 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
6917 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
6919 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
6922 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",
6930 ptr
[15], ptr
[14]);
6932 else if (hash_mode
== 7300)
6934 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
6936 rakp_t
*rakp
= &rakps
[salt_pos
];
6938 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
6940 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
6943 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
6950 else if (hash_mode
== 7400)
6952 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6954 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6955 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6956 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6957 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6958 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6959 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6960 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6961 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6963 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6965 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
6967 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6971 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6974 else if (hash_mode
== 7500)
6976 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
6978 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
6980 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
6981 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
6985 char *ptr_data
= data
;
6987 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
6989 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
6992 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
6994 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
6999 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7001 (char *) krb5pa
->user
,
7002 (char *) krb5pa
->realm
,
7003 (char *) krb5pa
->salt
,
7006 else if (hash_mode
== 7700)
7008 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7009 (char *) salt
.salt_buf
,
7013 else if (hash_mode
== 7800)
7015 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7016 (char *) salt
.salt_buf
,
7023 else if (hash_mode
== 7900)
7025 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7029 char *tmp
= (char *) salt
.salt_buf_pc
;
7031 ptr_plain
[42] = tmp
[0];
7037 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7039 else if (hash_mode
== 8000)
7041 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7042 (unsigned char *) salt
.salt_buf
,
7052 else if (hash_mode
== 8100)
7054 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7055 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7057 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7058 (unsigned char *) salt
.salt_buf
,
7065 else if (hash_mode
== 8200)
7067 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7069 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7071 char data_buf
[4096];
7073 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7075 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7078 data_buf
[cloudkey
->data_len
* 2] = 0;
7080 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7081 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7082 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7083 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7084 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7085 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7086 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7087 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7089 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7090 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7091 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7092 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7094 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7110 else if (hash_mode
== 8300)
7114 char digest_buf_c
[33];
7116 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 32, (u8
*) digest_buf_c
);
7118 digest_buf_c
[32] = 0;
7122 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7124 char domain_buf_c
[33];
7126 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7128 for (uint i
= 0; i
< salt_pc_len
; i
++)
7130 const char next
= domain_buf_c
[i
];
7132 domain_buf_c
[i
] = '.';
7137 domain_buf_c
[salt_pc_len
] = 0;
7141 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7143 else if (hash_mode
== 8500)
7145 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7147 else if (hash_mode
== 2612)
7149 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7151 (char *) salt
.salt_buf
,
7157 else if (hash_mode
== 3711)
7159 char *salt_ptr
= (char *) salt
.salt_buf
;
7161 salt_ptr
[salt
.salt_len
- 1] = 0;
7163 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7164 SIGNATURE_MEDIAWIKI_B
,
7171 else if (hash_mode
== 8800)
7173 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7175 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7179 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7181 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7186 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7187 SIGNATURE_ANDROIDFDE
,
7188 byte_swap_32 (salt
.salt_buf
[0]),
7189 byte_swap_32 (salt
.salt_buf
[1]),
7190 byte_swap_32 (salt
.salt_buf
[2]),
7191 byte_swap_32 (salt
.salt_buf
[3]),
7192 byte_swap_32 (digest_buf
[0]),
7193 byte_swap_32 (digest_buf
[1]),
7194 byte_swap_32 (digest_buf
[2]),
7195 byte_swap_32 (digest_buf
[3]),
7198 else if (hash_mode
== 8900)
7200 uint N
= salt
.scrypt_N
;
7201 uint r
= salt
.scrypt_r
;
7202 uint p
= salt
.scrypt_p
;
7204 char base64_salt
[32];
7206 memset (base64_salt
, 0, 32);
7208 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7210 memset (tmp_buf
, 0, 46);
7212 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7213 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7214 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7215 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7216 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7217 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7218 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7219 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7220 digest_buf
[8] = 0; // needed for base64_encode ()
7222 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7224 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7232 else if (hash_mode
== 9000)
7234 snprintf (out_buf
, len
-1, "%s", hashfile
);
7236 else if (hash_mode
== 9200)
7240 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7242 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7244 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7248 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7249 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7250 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7251 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7252 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7253 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7254 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7255 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7256 digest_buf
[8] = 0; // needed for base64_encode ()
7259 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7261 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7262 tmp_buf
[43] = 0; // cut it here
7266 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7268 else if (hash_mode
== 9300)
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 ()
7281 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7283 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7284 tmp_buf
[43] = 0; // cut it here
7286 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7288 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7290 else if (hash_mode
== 9400)
7292 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7294 office2007_t
*office2007
= &office2007s
[salt_pos
];
7296 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7297 SIGNATURE_OFFICE2007
,
7300 office2007
->keySize
,
7306 office2007
->encryptedVerifier
[0],
7307 office2007
->encryptedVerifier
[1],
7308 office2007
->encryptedVerifier
[2],
7309 office2007
->encryptedVerifier
[3],
7310 office2007
->encryptedVerifierHash
[0],
7311 office2007
->encryptedVerifierHash
[1],
7312 office2007
->encryptedVerifierHash
[2],
7313 office2007
->encryptedVerifierHash
[3],
7314 office2007
->encryptedVerifierHash
[4]);
7316 else if (hash_mode
== 9500)
7318 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7320 office2010_t
*office2010
= &office2010s
[salt_pos
];
7322 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,
7328 office2010
->encryptedVerifier
[0],
7329 office2010
->encryptedVerifier
[1],
7330 office2010
->encryptedVerifier
[2],
7331 office2010
->encryptedVerifier
[3],
7332 office2010
->encryptedVerifierHash
[0],
7333 office2010
->encryptedVerifierHash
[1],
7334 office2010
->encryptedVerifierHash
[2],
7335 office2010
->encryptedVerifierHash
[3],
7336 office2010
->encryptedVerifierHash
[4],
7337 office2010
->encryptedVerifierHash
[5],
7338 office2010
->encryptedVerifierHash
[6],
7339 office2010
->encryptedVerifierHash
[7]);
7341 else if (hash_mode
== 9600)
7343 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7345 office2013_t
*office2013
= &office2013s
[salt_pos
];
7347 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,
7353 office2013
->encryptedVerifier
[0],
7354 office2013
->encryptedVerifier
[1],
7355 office2013
->encryptedVerifier
[2],
7356 office2013
->encryptedVerifier
[3],
7357 office2013
->encryptedVerifierHash
[0],
7358 office2013
->encryptedVerifierHash
[1],
7359 office2013
->encryptedVerifierHash
[2],
7360 office2013
->encryptedVerifierHash
[3],
7361 office2013
->encryptedVerifierHash
[4],
7362 office2013
->encryptedVerifierHash
[5],
7363 office2013
->encryptedVerifierHash
[6],
7364 office2013
->encryptedVerifierHash
[7]);
7366 else if (hash_mode
== 9700)
7368 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7370 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7372 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7373 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7374 byte_swap_32 (salt
.salt_buf
[0]),
7375 byte_swap_32 (salt
.salt_buf
[1]),
7376 byte_swap_32 (salt
.salt_buf
[2]),
7377 byte_swap_32 (salt
.salt_buf
[3]),
7378 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7379 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7380 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7381 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7382 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7383 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7384 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7385 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7387 else if (hash_mode
== 9710)
7389 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7391 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7393 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7394 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7395 byte_swap_32 (salt
.salt_buf
[0]),
7396 byte_swap_32 (salt
.salt_buf
[1]),
7397 byte_swap_32 (salt
.salt_buf
[2]),
7398 byte_swap_32 (salt
.salt_buf
[3]),
7399 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7400 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7401 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7402 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7403 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7404 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7405 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7406 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7408 else if (hash_mode
== 9720)
7410 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7412 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7414 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7416 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7417 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7418 byte_swap_32 (salt
.salt_buf
[0]),
7419 byte_swap_32 (salt
.salt_buf
[1]),
7420 byte_swap_32 (salt
.salt_buf
[2]),
7421 byte_swap_32 (salt
.salt_buf
[3]),
7422 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7423 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7424 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7425 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7426 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7427 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7428 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7429 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7436 else if (hash_mode
== 9800)
7438 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7440 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7442 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7443 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7448 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7449 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7450 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7451 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7452 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7453 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7454 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7455 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7456 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7458 else if (hash_mode
== 9810)
7460 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7462 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7464 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7465 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7470 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7471 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7472 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7473 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7474 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7475 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7476 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7477 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7478 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7480 else if (hash_mode
== 9820)
7482 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7484 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7486 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7488 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7489 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7494 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7495 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7496 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7497 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7498 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7499 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7500 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7501 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7502 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7509 else if (hash_mode
== 10000)
7513 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7515 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7517 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7521 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7522 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7523 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7524 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7525 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7526 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7527 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7528 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7529 digest_buf
[8] = 0; // needed for base64_encode ()
7532 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7534 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7538 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7540 else if (hash_mode
== 10100)
7542 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7547 byte_swap_32 (salt
.salt_buf
[0]),
7548 byte_swap_32 (salt
.salt_buf
[1]),
7549 byte_swap_32 (salt
.salt_buf
[2]),
7550 byte_swap_32 (salt
.salt_buf
[3]));
7552 else if (hash_mode
== 10200)
7554 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7556 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7560 char challenge
[100];
7562 memset (challenge
, 0, sizeof (challenge
));
7564 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7570 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7571 (char *) cram_md5
->user
,
7579 memset (response
, 0, sizeof (response
));
7581 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7583 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7585 else if (hash_mode
== 10300)
7589 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7591 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7592 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7594 uint tmp_len
= 20 + salt
.salt_len
;
7598 char base64_encoded
[100];
7600 memset (base64_encoded
, 0, sizeof (base64_encoded
));
7602 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7604 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7606 else if (hash_mode
== 10400)
7608 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7610 pdf_t
*pdf
= &pdfs
[salt_pos
];
7612 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",
7620 byte_swap_32 (pdf
->id_buf
[0]),
7621 byte_swap_32 (pdf
->id_buf
[1]),
7622 byte_swap_32 (pdf
->id_buf
[2]),
7623 byte_swap_32 (pdf
->id_buf
[3]),
7625 byte_swap_32 (pdf
->u_buf
[0]),
7626 byte_swap_32 (pdf
->u_buf
[1]),
7627 byte_swap_32 (pdf
->u_buf
[2]),
7628 byte_swap_32 (pdf
->u_buf
[3]),
7629 byte_swap_32 (pdf
->u_buf
[4]),
7630 byte_swap_32 (pdf
->u_buf
[5]),
7631 byte_swap_32 (pdf
->u_buf
[6]),
7632 byte_swap_32 (pdf
->u_buf
[7]),
7634 byte_swap_32 (pdf
->o_buf
[0]),
7635 byte_swap_32 (pdf
->o_buf
[1]),
7636 byte_swap_32 (pdf
->o_buf
[2]),
7637 byte_swap_32 (pdf
->o_buf
[3]),
7638 byte_swap_32 (pdf
->o_buf
[4]),
7639 byte_swap_32 (pdf
->o_buf
[5]),
7640 byte_swap_32 (pdf
->o_buf
[6]),
7641 byte_swap_32 (pdf
->o_buf
[7])
7644 else if (hash_mode
== 10410)
7646 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7648 pdf_t
*pdf
= &pdfs
[salt_pos
];
7650 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",
7658 byte_swap_32 (pdf
->id_buf
[0]),
7659 byte_swap_32 (pdf
->id_buf
[1]),
7660 byte_swap_32 (pdf
->id_buf
[2]),
7661 byte_swap_32 (pdf
->id_buf
[3]),
7663 byte_swap_32 (pdf
->u_buf
[0]),
7664 byte_swap_32 (pdf
->u_buf
[1]),
7665 byte_swap_32 (pdf
->u_buf
[2]),
7666 byte_swap_32 (pdf
->u_buf
[3]),
7667 byte_swap_32 (pdf
->u_buf
[4]),
7668 byte_swap_32 (pdf
->u_buf
[5]),
7669 byte_swap_32 (pdf
->u_buf
[6]),
7670 byte_swap_32 (pdf
->u_buf
[7]),
7672 byte_swap_32 (pdf
->o_buf
[0]),
7673 byte_swap_32 (pdf
->o_buf
[1]),
7674 byte_swap_32 (pdf
->o_buf
[2]),
7675 byte_swap_32 (pdf
->o_buf
[3]),
7676 byte_swap_32 (pdf
->o_buf
[4]),
7677 byte_swap_32 (pdf
->o_buf
[5]),
7678 byte_swap_32 (pdf
->o_buf
[6]),
7679 byte_swap_32 (pdf
->o_buf
[7])
7682 else if (hash_mode
== 10420)
7684 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7686 pdf_t
*pdf
= &pdfs
[salt_pos
];
7688 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7690 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",
7698 byte_swap_32 (pdf
->id_buf
[0]),
7699 byte_swap_32 (pdf
->id_buf
[1]),
7700 byte_swap_32 (pdf
->id_buf
[2]),
7701 byte_swap_32 (pdf
->id_buf
[3]),
7703 byte_swap_32 (pdf
->u_buf
[0]),
7704 byte_swap_32 (pdf
->u_buf
[1]),
7705 byte_swap_32 (pdf
->u_buf
[2]),
7706 byte_swap_32 (pdf
->u_buf
[3]),
7707 byte_swap_32 (pdf
->u_buf
[4]),
7708 byte_swap_32 (pdf
->u_buf
[5]),
7709 byte_swap_32 (pdf
->u_buf
[6]),
7710 byte_swap_32 (pdf
->u_buf
[7]),
7712 byte_swap_32 (pdf
->o_buf
[0]),
7713 byte_swap_32 (pdf
->o_buf
[1]),
7714 byte_swap_32 (pdf
->o_buf
[2]),
7715 byte_swap_32 (pdf
->o_buf
[3]),
7716 byte_swap_32 (pdf
->o_buf
[4]),
7717 byte_swap_32 (pdf
->o_buf
[5]),
7718 byte_swap_32 (pdf
->o_buf
[6]),
7719 byte_swap_32 (pdf
->o_buf
[7]),
7727 else if (hash_mode
== 10500)
7729 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7731 pdf_t
*pdf
= &pdfs
[salt_pos
];
7733 if (pdf
->id_len
== 32)
7735 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",
7743 byte_swap_32 (pdf
->id_buf
[0]),
7744 byte_swap_32 (pdf
->id_buf
[1]),
7745 byte_swap_32 (pdf
->id_buf
[2]),
7746 byte_swap_32 (pdf
->id_buf
[3]),
7747 byte_swap_32 (pdf
->id_buf
[4]),
7748 byte_swap_32 (pdf
->id_buf
[5]),
7749 byte_swap_32 (pdf
->id_buf
[6]),
7750 byte_swap_32 (pdf
->id_buf
[7]),
7752 byte_swap_32 (pdf
->u_buf
[0]),
7753 byte_swap_32 (pdf
->u_buf
[1]),
7754 byte_swap_32 (pdf
->u_buf
[2]),
7755 byte_swap_32 (pdf
->u_buf
[3]),
7756 byte_swap_32 (pdf
->u_buf
[4]),
7757 byte_swap_32 (pdf
->u_buf
[5]),
7758 byte_swap_32 (pdf
->u_buf
[6]),
7759 byte_swap_32 (pdf
->u_buf
[7]),
7761 byte_swap_32 (pdf
->o_buf
[0]),
7762 byte_swap_32 (pdf
->o_buf
[1]),
7763 byte_swap_32 (pdf
->o_buf
[2]),
7764 byte_swap_32 (pdf
->o_buf
[3]),
7765 byte_swap_32 (pdf
->o_buf
[4]),
7766 byte_swap_32 (pdf
->o_buf
[5]),
7767 byte_swap_32 (pdf
->o_buf
[6]),
7768 byte_swap_32 (pdf
->o_buf
[7])
7773 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",
7781 byte_swap_32 (pdf
->id_buf
[0]),
7782 byte_swap_32 (pdf
->id_buf
[1]),
7783 byte_swap_32 (pdf
->id_buf
[2]),
7784 byte_swap_32 (pdf
->id_buf
[3]),
7786 byte_swap_32 (pdf
->u_buf
[0]),
7787 byte_swap_32 (pdf
->u_buf
[1]),
7788 byte_swap_32 (pdf
->u_buf
[2]),
7789 byte_swap_32 (pdf
->u_buf
[3]),
7790 byte_swap_32 (pdf
->u_buf
[4]),
7791 byte_swap_32 (pdf
->u_buf
[5]),
7792 byte_swap_32 (pdf
->u_buf
[6]),
7793 byte_swap_32 (pdf
->u_buf
[7]),
7795 byte_swap_32 (pdf
->o_buf
[0]),
7796 byte_swap_32 (pdf
->o_buf
[1]),
7797 byte_swap_32 (pdf
->o_buf
[2]),
7798 byte_swap_32 (pdf
->o_buf
[3]),
7799 byte_swap_32 (pdf
->o_buf
[4]),
7800 byte_swap_32 (pdf
->o_buf
[5]),
7801 byte_swap_32 (pdf
->o_buf
[6]),
7802 byte_swap_32 (pdf
->o_buf
[7])
7806 else if (hash_mode
== 10600)
7808 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7810 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7811 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7813 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7815 else if (hash_mode
== 10700)
7817 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7819 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7820 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7822 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7824 else if (hash_mode
== 10900)
7826 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7828 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7829 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7831 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7833 else if (hash_mode
== 11100)
7835 u32 salt_challenge
= salt
.salt_buf
[0];
7837 salt_challenge
= byte_swap_32 (salt_challenge
);
7839 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7841 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7842 SIGNATURE_POSTGRESQL_AUTH
,
7850 else if (hash_mode
== 11200)
7852 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7853 SIGNATURE_MYSQL_AUTH
,
7854 (unsigned char *) salt
.salt_buf
,
7861 else if (hash_mode
== 11300)
7863 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7865 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7867 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7868 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7869 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7871 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7872 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7873 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7875 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7877 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7879 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7882 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7884 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7886 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7889 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7891 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
7893 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7896 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
7897 SIGNATURE_BITCOIN_WALLET
,
7901 (unsigned char *) salt
.salt_buf
,
7909 free (cry_master_buf
);
7911 free (public_key_buf
);
7913 else if (hash_mode
== 11400)
7915 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7917 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7918 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7920 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7922 else if (hash_mode
== 11600)
7924 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
7926 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
7928 const uint data_len
= seven_zip
->data_len
;
7930 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
7932 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
7934 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
7936 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
7939 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
7940 SIGNATURE_SEVEN_ZIP
,
7944 (char *) seven_zip
->salt_buf
,
7946 seven_zip
->iv_buf
[0],
7947 seven_zip
->iv_buf
[1],
7948 seven_zip
->iv_buf
[2],
7949 seven_zip
->iv_buf
[3],
7951 seven_zip
->data_len
,
7952 seven_zip
->unpack_size
,
7957 else if (hash_mode
== 11700)
7959 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
7969 else if (hash_mode
== 11800)
7971 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
7989 else if (hash_mode
== 11900)
7991 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7993 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7994 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7996 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7998 else if (hash_mode
== 12000)
8000 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8002 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8003 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8005 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8007 else if (hash_mode
== 12100)
8009 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8011 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8012 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8014 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8016 else if (hash_mode
== 12200)
8018 uint
*ptr_digest
= digest_buf
;
8019 uint
*ptr_salt
= salt
.salt_buf
;
8021 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8028 else if (hash_mode
== 12300)
8030 uint
*ptr_digest
= digest_buf
;
8031 uint
*ptr_salt
= salt
.salt_buf
;
8033 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",
8034 ptr_digest
[ 0], ptr_digest
[ 1],
8035 ptr_digest
[ 2], ptr_digest
[ 3],
8036 ptr_digest
[ 4], ptr_digest
[ 5],
8037 ptr_digest
[ 6], ptr_digest
[ 7],
8038 ptr_digest
[ 8], ptr_digest
[ 9],
8039 ptr_digest
[10], ptr_digest
[11],
8040 ptr_digest
[12], ptr_digest
[13],
8041 ptr_digest
[14], ptr_digest
[15],
8047 else if (hash_mode
== 12400)
8049 // encode iteration count
8053 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8054 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8055 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8056 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8061 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8062 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8063 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8064 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8069 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8071 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8072 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8074 memcpy (tmp_buf
, digest_buf
, 8);
8076 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8080 // fill the resulting buffer
8082 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8084 else if (hash_mode
== 12500)
8086 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8088 byte_swap_32 (salt
.salt_buf
[0]),
8089 byte_swap_32 (salt
.salt_buf
[1]),
8095 else if (hash_mode
== 12600)
8097 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8098 digest_buf
[0] + salt
.salt_buf_pc
[0],
8099 digest_buf
[1] + salt
.salt_buf_pc
[1],
8100 digest_buf
[2] + salt
.salt_buf_pc
[2],
8101 digest_buf
[3] + salt
.salt_buf_pc
[3],
8102 digest_buf
[4] + salt
.salt_buf_pc
[4],
8103 digest_buf
[5] + salt
.salt_buf_pc
[5],
8104 digest_buf
[6] + salt
.salt_buf_pc
[6],
8105 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8107 else if (hash_mode
== 12700)
8109 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8111 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8112 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8114 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8116 else if (hash_mode
== 12800)
8118 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8120 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",
8133 byte_swap_32 (digest_buf
[0]),
8134 byte_swap_32 (digest_buf
[1]),
8135 byte_swap_32 (digest_buf
[2]),
8136 byte_swap_32 (digest_buf
[3]),
8137 byte_swap_32 (digest_buf
[4]),
8138 byte_swap_32 (digest_buf
[5]),
8139 byte_swap_32 (digest_buf
[6]),
8140 byte_swap_32 (digest_buf
[7])
8143 else if (hash_mode
== 12900)
8145 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",
8154 byte_swap_32 (digest_buf
[0]),
8155 byte_swap_32 (digest_buf
[1]),
8156 byte_swap_32 (digest_buf
[2]),
8157 byte_swap_32 (digest_buf
[3]),
8158 byte_swap_32 (digest_buf
[4]),
8159 byte_swap_32 (digest_buf
[5]),
8160 byte_swap_32 (digest_buf
[6]),
8161 byte_swap_32 (digest_buf
[7]),
8168 else if (hash_mode
== 13000)
8170 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8172 rar5_t
*rar5
= &rar5s
[salt_pos
];
8174 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8184 byte_swap_32 (digest_buf
[0]),
8185 byte_swap_32 (digest_buf
[1])
8190 if (hash_type
== HASH_TYPE_MD4
)
8192 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8198 else if (hash_type
== HASH_TYPE_MD5
)
8200 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8206 else if (hash_type
== HASH_TYPE_SHA1
)
8208 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8215 else if (hash_type
== HASH_TYPE_SHA256
)
8217 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8227 else if (hash_type
== HASH_TYPE_SHA384
)
8229 uint
*ptr
= digest_buf
;
8231 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8239 else if (hash_type
== HASH_TYPE_SHA512
)
8241 uint
*ptr
= digest_buf
;
8243 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8253 else if (hash_type
== HASH_TYPE_LM
)
8255 snprintf (out_buf
, len
-1, "%08x%08x",
8259 else if (hash_type
== HASH_TYPE_ORACLEH
)
8261 snprintf (out_buf
, len
-1, "%08X%08X",
8265 else if (hash_type
== HASH_TYPE_BCRYPT
)
8267 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8268 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8270 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8272 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8274 else if (hash_type
== HASH_TYPE_KECCAK
)
8276 uint
*ptr
= digest_buf
;
8278 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%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",
8306 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8308 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8310 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8317 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8319 digest_buf
[ 0] = digest_buf
[ 0];
8320 digest_buf
[ 1] = digest_buf
[ 1];
8321 digest_buf
[ 2] = digest_buf
[ 2];
8322 digest_buf
[ 3] = digest_buf
[ 3];
8323 digest_buf
[ 4] = digest_buf
[ 4];
8324 digest_buf
[ 5] = digest_buf
[ 5];
8325 digest_buf
[ 6] = digest_buf
[ 6];
8326 digest_buf
[ 7] = digest_buf
[ 7];
8327 digest_buf
[ 8] = digest_buf
[ 8];
8328 digest_buf
[ 9] = digest_buf
[ 9];
8329 digest_buf
[10] = digest_buf
[10];
8330 digest_buf
[11] = digest_buf
[11];
8331 digest_buf
[12] = digest_buf
[12];
8332 digest_buf
[13] = digest_buf
[13];
8333 digest_buf
[14] = digest_buf
[14];
8334 digest_buf
[15] = digest_buf
[15];
8336 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8354 else if (hash_type
== HASH_TYPE_GOST
)
8356 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8366 else if (hash_type
== HASH_TYPE_MYSQL
)
8368 snprintf (out_buf
, len
-1, "%08x%08x",
8372 else if (hash_type
== HASH_TYPE_LOTUS5
)
8374 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8380 else if (hash_type
== HASH_TYPE_LOTUS6
)
8382 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8383 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8384 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8385 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8389 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8390 memcpy (buf
+ 5, digest_buf
, 9);
8394 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8396 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8399 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8401 else if (hash_type
== HASH_TYPE_LOTUS8
)
8405 memset (buf
, 0, sizeof (buf
));
8409 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8415 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8419 buf
[26] = salt
.salt_buf_pc
[0];
8420 buf
[27] = salt
.salt_buf_pc
[1];
8424 memcpy (buf
+ 28, digest_buf
, 8);
8426 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8430 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8432 else if (hash_type
== HASH_TYPE_CRC32
)
8434 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8438 if (salt_type
== SALT_TYPE_INTERN
)
8440 size_t pos
= strlen (out_buf
);
8442 out_buf
[pos
] = data
.separator
;
8444 char *ptr
= (char *) salt
.salt_buf
;
8446 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8448 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8452 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8454 memset (hccap
, 0, sizeof (hccap_t
));
8456 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8458 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8460 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8461 wpa_t
*wpa
= &wpas
[salt_pos
];
8463 hccap
->keyver
= wpa
->keyver
;
8465 hccap
->eapol_size
= wpa
->eapol_size
;
8467 if (wpa
->keyver
!= 1)
8471 for (uint i
= 0; i
< 64; i
++)
8473 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8476 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8480 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8485 for (int i
= 5; i
< 25; i
++)
8487 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8490 char *pke_ptr
= (char *) pke_tmp
;
8492 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8493 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8494 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8495 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8497 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8499 uint dgst_size
= data
.dgst_size
;
8501 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8503 if (wpa
->keyver
!= 1)
8507 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8508 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8509 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8510 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8512 memcpy (hccap
->keymic
, digest_tmp
, 16);
8516 memcpy (hccap
->keymic
, digest_ptr
, 16);
8520 void SuspendThreads ()
8522 if (data
.devices_status
== STATUS_RUNNING
)
8524 hc_timer_set (&data
.timer_paused
);
8526 data
.devices_status
= STATUS_PAUSED
;
8528 log_info ("Paused");
8532 void ResumeThreads ()
8534 if (data
.devices_status
== STATUS_PAUSED
)
8538 hc_timer_get (data
.timer_paused
, ms_paused
);
8540 data
.ms_paused
+= ms_paused
;
8542 data
.devices_status
= STATUS_RUNNING
;
8544 log_info ("Resumed");
8550 if (data
.devices_status
!= STATUS_RUNNING
) return;
8552 data
.devices_status
= STATUS_BYPASS
;
8554 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8557 void stop_at_checkpoint ()
8559 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8561 if (data
.devices_status
!= STATUS_RUNNING
) return;
8564 // this feature only makes sense if --restore-disable was not specified
8566 if (data
.restore_disable
== 1)
8568 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8573 // check if monitoring of Restore Point updates should be enabled or disabled
8575 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8577 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8579 // save the current restore point value
8581 data
.checkpoint_cur_words
= get_lowest_words_done ();
8583 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8587 data
.devices_status
= STATUS_RUNNING
;
8589 // reset the global value for checkpoint checks
8591 data
.checkpoint_cur_words
= 0;
8593 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8599 if (data
.devices_status
== STATUS_INIT
) return;
8600 if (data
.devices_status
== STATUS_STARTING
) return;
8602 data
.devices_status
= STATUS_ABORTED
;
8607 if (data
.devices_status
== STATUS_INIT
) return;
8608 if (data
.devices_status
== STATUS_STARTING
) return;
8610 data
.devices_status
= STATUS_QUIT
;
8613 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8617 if ((fp
= fopen (kernel_file
, "rb")) != NULL
)
8621 memset (&st
, 0, sizeof (st
));
8623 stat (kernel_file
, &st
);
8625 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8627 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8629 if (num_read
!= (size_t) st
.st_size
)
8631 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8638 buf
[st
.st_size
] = 0;
8640 for (int i
= 0; i
< num_devices
; i
++)
8642 kernel_lengths
[i
] = (size_t) st
.st_size
;
8644 kernel_sources
[i
] = buf
;
8649 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8657 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8659 FILE *fp
= fopen (dst
, "wb");
8661 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8671 restore_data_t
*init_restore (int argc
, char **argv
)
8673 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8675 if (data
.restore_disable
== 0)
8677 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8681 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8685 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8694 char pidbin
[BUFSIZ
];
8699 memset (pidbin
, 0, sizeof (pidbin
));
8701 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8703 FILE *fd
= fopen (pidbin
, "rb");
8707 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8709 pidbin
[pidbin_len
] = 0;
8713 char *argv0_r
= strrchr (argv
[0], '/');
8715 char *pidbin_r
= strrchr (pidbin
, '/');
8717 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8719 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8721 if (strcmp (argv0_r
, pidbin_r
) == 0)
8723 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8730 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8732 char pidbin2
[BUFSIZ
];
8736 memset (pidbin2
, 0, sizeof (pidbin2
));
8738 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8739 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8741 pidbin
[pidbin_len
] = 0;
8742 pidbin2
[pidbin2_len
] = 0;
8746 if (strcmp (pidbin
, pidbin2
) == 0)
8748 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8756 if (rd
->version_bin
< RESTORE_MIN
)
8758 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8765 memset (rd
, 0, sizeof (restore_data_t
));
8767 rd
->version_bin
= VERSION_BIN
;
8770 rd
->pid
= getpid ();
8772 rd
->pid
= GetCurrentProcessId ();
8775 if (getcwd (rd
->cwd
, 255) == NULL
)
8788 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8790 FILE *fp
= fopen (eff_restore_file
, "rb");
8794 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8799 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8801 log_error ("ERROR: cannot read %s", eff_restore_file
);
8806 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8808 for (uint i
= 0; i
< rd
->argc
; i
++)
8812 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8814 log_error ("ERROR: cannot read %s", eff_restore_file
);
8819 size_t len
= strlen (buf
);
8821 if (len
) buf
[len
- 1] = 0;
8823 rd
->argv
[i
] = mystrdup (buf
);
8830 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8834 log_error ("Restore file is corrupted");
8837 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8839 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8841 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8846 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8850 if (chdir (rd
->cwd
))
8852 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8858 u64
get_lowest_words_done ()
8862 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8864 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8866 if (device_param
->skipped
) continue;
8868 const u64 words_done
= device_param
->words_done
;
8870 if (words_done
< words_cur
) words_cur
= words_done
;
8873 // It's possible that a device's workload isn't finished right after a restore-case.
8874 // In that case, this function would return 0 and overwrite the real restore point
8875 // There's also data.words_cur which is set to rd->words_cur but it changes while
8876 // the attack is running therefore we should stick to rd->words_cur.
8877 // Note that -s influences rd->words_cur we should keep a close look on that.
8879 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
8884 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
8886 u64 words_cur
= get_lowest_words_done ();
8888 rd
->words_cur
= words_cur
;
8890 FILE *fp
= fopen (new_restore_file
, "wb");
8894 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
8899 if (setvbuf (fp
, NULL
, _IONBF
, 0))
8901 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
8906 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
8908 for (uint i
= 0; i
< rd
->argc
; i
++)
8910 fprintf (fp
, "%s", rd
->argv
[i
]);
8916 fsync (fileno (fp
));
8921 void cycle_restore ()
8923 const char *eff_restore_file
= data
.eff_restore_file
;
8924 const char *new_restore_file
= data
.new_restore_file
;
8926 restore_data_t
*rd
= data
.rd
;
8928 write_restore (new_restore_file
, rd
);
8932 memset (&st
, 0, sizeof(st
));
8934 if (stat (eff_restore_file
, &st
) == 0)
8936 if (unlink (eff_restore_file
))
8938 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
8942 if (rename (new_restore_file
, eff_restore_file
))
8944 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
8948 void check_checkpoint ()
8950 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
8952 u64 words_cur
= get_lowest_words_done ();
8954 if (words_cur
!= data
.checkpoint_cur_words
)
8964 uint
set_kernel_accel (uint hash_mode
)
8968 case 0: return GET_ACCEL (0);
8969 case 10: return GET_ACCEL (10);
8970 case 11: return GET_ACCEL (11);
8971 case 12: return GET_ACCEL (12);
8972 case 20: return GET_ACCEL (20);
8973 case 21: return GET_ACCEL (21);
8974 case 22: return GET_ACCEL (22);
8975 case 23: return GET_ACCEL (23);
8976 case 30: return GET_ACCEL (30);
8977 case 40: return GET_ACCEL (40);
8978 case 50: return GET_ACCEL (50);
8979 case 60: return GET_ACCEL (60);
8980 case 100: return GET_ACCEL (100);
8981 case 101: return GET_ACCEL (101);
8982 case 110: return GET_ACCEL (110);
8983 case 111: return GET_ACCEL (111);
8984 case 112: return GET_ACCEL (112);
8985 case 120: return GET_ACCEL (120);
8986 case 121: return GET_ACCEL (121);
8987 case 122: return GET_ACCEL (122);
8988 case 124: return GET_ACCEL (124);
8989 case 130: return GET_ACCEL (130);
8990 case 131: return GET_ACCEL (131);
8991 case 132: return GET_ACCEL (132);
8992 case 133: return GET_ACCEL (133);
8993 case 140: return GET_ACCEL (140);
8994 case 141: return GET_ACCEL (141);
8995 case 150: return GET_ACCEL (150);
8996 case 160: return GET_ACCEL (160);
8997 case 190: return GET_ACCEL (190);
8998 case 200: return GET_ACCEL (200);
8999 case 300: return GET_ACCEL (300);
9000 case 400: return GET_ACCEL (400);
9001 case 500: return GET_ACCEL (500);
9002 case 501: return GET_ACCEL (501);
9003 case 900: return GET_ACCEL (900);
9004 case 910: return GET_ACCEL (910);
9005 case 1000: return GET_ACCEL (1000);
9006 case 1100: return GET_ACCEL (1100);
9007 case 1400: return GET_ACCEL (1400);
9008 case 1410: return GET_ACCEL (1410);
9009 case 1420: return GET_ACCEL (1420);
9010 case 1421: return GET_ACCEL (1421);
9011 case 1430: return GET_ACCEL (1430);
9012 case 1440: return GET_ACCEL (1440);
9013 case 1441: return GET_ACCEL (1441);
9014 case 1450: return GET_ACCEL (1450);
9015 case 1460: return GET_ACCEL (1460);
9016 case 1500: return GET_ACCEL (1500);
9017 case 1600: return GET_ACCEL (1600);
9018 case 1700: return GET_ACCEL (1700);
9019 case 1710: return GET_ACCEL (1710);
9020 case 1711: return GET_ACCEL (1711);
9021 case 1720: return GET_ACCEL (1720);
9022 case 1722: return GET_ACCEL (1722);
9023 case 1730: return GET_ACCEL (1730);
9024 case 1731: return GET_ACCEL (1731);
9025 case 1740: return GET_ACCEL (1740);
9026 case 1750: return GET_ACCEL (1750);
9027 case 1760: return GET_ACCEL (1760);
9028 case 1800: return GET_ACCEL (1800);
9029 case 2100: return GET_ACCEL (2100);
9030 case 2400: return GET_ACCEL (2400);
9031 case 2410: return GET_ACCEL (2410);
9032 case 2500: return GET_ACCEL (2500);
9033 case 2600: return GET_ACCEL (2600);
9034 case 2611: return GET_ACCEL (2611);
9035 case 2612: return GET_ACCEL (2612);
9036 case 2711: return GET_ACCEL (2711);
9037 case 2811: return GET_ACCEL (2811);
9038 case 3000: return GET_ACCEL (3000);
9039 case 3100: return GET_ACCEL (3100);
9040 case 3200: return GET_ACCEL (3200);
9041 case 3710: return GET_ACCEL (3710);
9042 case 3711: return GET_ACCEL (3711);
9043 case 3800: return GET_ACCEL (3800);
9044 case 4300: return GET_ACCEL (4300);
9045 case 4400: return GET_ACCEL (4400);
9046 case 4500: return GET_ACCEL (4500);
9047 case 4700: return GET_ACCEL (4700);
9048 case 4800: return GET_ACCEL (4800);
9049 case 4900: return GET_ACCEL (4900);
9050 case 5000: return GET_ACCEL (5000);
9051 case 5100: return GET_ACCEL (5100);
9052 case 5200: return GET_ACCEL (5200);
9053 case 5300: return GET_ACCEL (5300);
9054 case 5400: return GET_ACCEL (5400);
9055 case 5500: return GET_ACCEL (5500);
9056 case 5600: return GET_ACCEL (5600);
9057 case 5700: return GET_ACCEL (5700);
9058 case 5800: return GET_ACCEL (5800);
9059 case 6000: return GET_ACCEL (6000);
9060 case 6100: return GET_ACCEL (6100);
9061 case 6211: return GET_ACCEL (6211);
9062 case 6212: return GET_ACCEL (6212);
9063 case 6213: return GET_ACCEL (6213);
9064 case 6221: return GET_ACCEL (6221);
9065 case 6222: return GET_ACCEL (6222);
9066 case 6223: return GET_ACCEL (6223);
9067 case 6231: return GET_ACCEL (6231);
9068 case 6232: return GET_ACCEL (6232);
9069 case 6233: return GET_ACCEL (6233);
9070 case 6241: return GET_ACCEL (6241);
9071 case 6242: return GET_ACCEL (6242);
9072 case 6243: return GET_ACCEL (6243);
9073 case 6300: return GET_ACCEL (6300);
9074 case 6400: return GET_ACCEL (6400);
9075 case 6500: return GET_ACCEL (6500);
9076 case 6600: return GET_ACCEL (6600);
9077 case 6700: return GET_ACCEL (6700);
9078 case 6800: return GET_ACCEL (6800);
9079 case 6900: return GET_ACCEL (6900);
9080 case 7100: return GET_ACCEL (7100);
9081 case 7200: return GET_ACCEL (7200);
9082 case 7300: return GET_ACCEL (7300);
9083 case 7400: return GET_ACCEL (7400);
9084 case 7500: return GET_ACCEL (7500);
9085 case 7600: return GET_ACCEL (7600);
9086 case 7700: return GET_ACCEL (7700);
9087 case 7800: return GET_ACCEL (7800);
9088 case 7900: return GET_ACCEL (7900);
9089 case 8000: return GET_ACCEL (8000);
9090 case 8100: return GET_ACCEL (8100);
9091 case 8200: return GET_ACCEL (8200);
9092 case 8300: return GET_ACCEL (8300);
9093 case 8400: return GET_ACCEL (8400);
9094 case 8500: return GET_ACCEL (8500);
9095 case 8600: return GET_ACCEL (8600);
9096 case 8700: return GET_ACCEL (8700);
9097 case 8800: return GET_ACCEL (8800);
9098 case 8900: return GET_ACCEL (8900);
9099 case 9000: return GET_ACCEL (9000);
9100 case 9100: return GET_ACCEL (9100);
9101 case 9200: return GET_ACCEL (9200);
9102 case 9300: return GET_ACCEL (9300);
9103 case 9400: return GET_ACCEL (9400);
9104 case 9500: return GET_ACCEL (9500);
9105 case 9600: return GET_ACCEL (9600);
9106 case 9700: return GET_ACCEL (9700);
9107 case 9710: return GET_ACCEL (9710);
9108 case 9720: return GET_ACCEL (9720);
9109 case 9800: return GET_ACCEL (9800);
9110 case 9810: return GET_ACCEL (9810);
9111 case 9820: return GET_ACCEL (9820);
9112 case 9900: return GET_ACCEL (9900);
9113 case 10000: return GET_ACCEL (10000);
9114 case 10100: return GET_ACCEL (10100);
9115 case 10200: return GET_ACCEL (10200);
9116 case 10300: return GET_ACCEL (10300);
9117 case 10400: return GET_ACCEL (10400);
9118 case 10410: return GET_ACCEL (10410);
9119 case 10420: return GET_ACCEL (10420);
9120 case 10500: return GET_ACCEL (10500);
9121 case 10600: return GET_ACCEL (10600);
9122 case 10700: return GET_ACCEL (10700);
9123 case 10800: return GET_ACCEL (10800);
9124 case 10900: return GET_ACCEL (10900);
9125 case 11000: return GET_ACCEL (11000);
9126 case 11100: return GET_ACCEL (11100);
9127 case 11200: return GET_ACCEL (11200);
9128 case 11300: return GET_ACCEL (11300);
9129 case 11400: return GET_ACCEL (11400);
9130 case 11500: return GET_ACCEL (11500);
9131 case 11600: return GET_ACCEL (11600);
9132 case 11700: return GET_ACCEL (11700);
9133 case 11800: return GET_ACCEL (11800);
9134 case 11900: return GET_ACCEL (11900);
9135 case 12000: return GET_ACCEL (12000);
9136 case 12100: return GET_ACCEL (12100);
9137 case 12200: return GET_ACCEL (12200);
9138 case 12300: return GET_ACCEL (12300);
9139 case 12400: return GET_ACCEL (12400);
9140 case 12500: return GET_ACCEL (12500);
9141 case 12600: return GET_ACCEL (12600);
9142 case 12700: return GET_ACCEL (12700);
9143 case 12800: return GET_ACCEL (12800);
9144 case 12900: return GET_ACCEL (12900);
9145 case 13000: return GET_ACCEL (13000);
9151 uint
set_kernel_loops (uint hash_mode
)
9155 case 0: return GET_LOOPS (0);
9156 case 10: return GET_LOOPS (10);
9157 case 11: return GET_LOOPS (11);
9158 case 12: return GET_LOOPS (12);
9159 case 20: return GET_LOOPS (20);
9160 case 21: return GET_LOOPS (21);
9161 case 22: return GET_LOOPS (22);
9162 case 23: return GET_LOOPS (23);
9163 case 30: return GET_LOOPS (30);
9164 case 40: return GET_LOOPS (40);
9165 case 50: return GET_LOOPS (50);
9166 case 60: return GET_LOOPS (60);
9167 case 100: return GET_LOOPS (100);
9168 case 101: return GET_LOOPS (101);
9169 case 110: return GET_LOOPS (110);
9170 case 111: return GET_LOOPS (111);
9171 case 112: return GET_LOOPS (112);
9172 case 120: return GET_LOOPS (120);
9173 case 121: return GET_LOOPS (121);
9174 case 122: return GET_LOOPS (122);
9175 case 124: return GET_LOOPS (124);
9176 case 130: return GET_LOOPS (130);
9177 case 131: return GET_LOOPS (131);
9178 case 132: return GET_LOOPS (132);
9179 case 133: return GET_LOOPS (133);
9180 case 140: return GET_LOOPS (140);
9181 case 141: return GET_LOOPS (141);
9182 case 150: return GET_LOOPS (150);
9183 case 160: return GET_LOOPS (160);
9184 case 190: return GET_LOOPS (190);
9185 case 200: return GET_LOOPS (200);
9186 case 300: return GET_LOOPS (300);
9187 case 400: return GET_LOOPS (400);
9188 case 500: return GET_LOOPS (500);
9189 case 501: return GET_LOOPS (501);
9190 case 900: return GET_LOOPS (900);
9191 case 910: return GET_LOOPS (910);
9192 case 1000: return GET_LOOPS (1000);
9193 case 1100: return GET_LOOPS (1100);
9194 case 1400: return GET_LOOPS (1400);
9195 case 1410: return GET_LOOPS (1410);
9196 case 1420: return GET_LOOPS (1420);
9197 case 1421: return GET_LOOPS (1421);
9198 case 1430: return GET_LOOPS (1430);
9199 case 1440: return GET_LOOPS (1440);
9200 case 1441: return GET_LOOPS (1441);
9201 case 1450: return GET_LOOPS (1450);
9202 case 1460: return GET_LOOPS (1460);
9203 case 1500: return GET_LOOPS (1500);
9204 case 1600: return GET_LOOPS (1600);
9205 case 1700: return GET_LOOPS (1700);
9206 case 1710: return GET_LOOPS (1710);
9207 case 1711: return GET_LOOPS (1711);
9208 case 1720: return GET_LOOPS (1720);
9209 case 1722: return GET_LOOPS (1722);
9210 case 1730: return GET_LOOPS (1730);
9211 case 1731: return GET_LOOPS (1731);
9212 case 1740: return GET_LOOPS (1740);
9213 case 1750: return GET_LOOPS (1750);
9214 case 1760: return GET_LOOPS (1760);
9215 case 1800: return GET_LOOPS (1800);
9216 case 2100: return GET_LOOPS (2100);
9217 case 2400: return GET_LOOPS (2400);
9218 case 2410: return GET_LOOPS (2410);
9219 case 2500: return GET_LOOPS (2500);
9220 case 2600: return GET_LOOPS (2600);
9221 case 2611: return GET_LOOPS (2611);
9222 case 2612: return GET_LOOPS (2612);
9223 case 2711: return GET_LOOPS (2711);
9224 case 2811: return GET_LOOPS (2811);
9225 case 3000: return GET_LOOPS (3000);
9226 case 3100: return GET_LOOPS (3100);
9227 case 3200: return GET_LOOPS (3200);
9228 case 3710: return GET_LOOPS (3710);
9229 case 3711: return GET_LOOPS (3711);
9230 case 3800: return GET_LOOPS (3800);
9231 case 4300: return GET_LOOPS (4300);
9232 case 4400: return GET_LOOPS (4400);
9233 case 4500: return GET_LOOPS (4500);
9234 case 4700: return GET_LOOPS (4700);
9235 case 4800: return GET_LOOPS (4800);
9236 case 4900: return GET_LOOPS (4900);
9237 case 5000: return GET_LOOPS (5000);
9238 case 5100: return GET_LOOPS (5100);
9239 case 5200: return GET_LOOPS (5200);
9240 case 5300: return GET_LOOPS (5300);
9241 case 5400: return GET_LOOPS (5400);
9242 case 5500: return GET_LOOPS (5500);
9243 case 5600: return GET_LOOPS (5600);
9244 case 5700: return GET_LOOPS (5700);
9245 case 5800: return GET_LOOPS (5800);
9246 case 6000: return GET_LOOPS (6000);
9247 case 6100: return GET_LOOPS (6100);
9248 case 6211: return GET_LOOPS (6211);
9249 case 6212: return GET_LOOPS (6212);
9250 case 6213: return GET_LOOPS (6213);
9251 case 6221: return GET_LOOPS (6221);
9252 case 6222: return GET_LOOPS (6222);
9253 case 6223: return GET_LOOPS (6223);
9254 case 6231: return GET_LOOPS (6231);
9255 case 6232: return GET_LOOPS (6232);
9256 case 6233: return GET_LOOPS (6233);
9257 case 6241: return GET_LOOPS (6241);
9258 case 6242: return GET_LOOPS (6242);
9259 case 6243: return GET_LOOPS (6243);
9260 case 6300: return GET_LOOPS (6300);
9261 case 6400: return GET_LOOPS (6400);
9262 case 6500: return GET_LOOPS (6500);
9263 case 6600: return GET_LOOPS (6600);
9264 case 6700: return GET_LOOPS (6700);
9265 case 6800: return GET_LOOPS (6800);
9266 case 6900: return GET_LOOPS (6900);
9267 case 7100: return GET_LOOPS (7100);
9268 case 7200: return GET_LOOPS (7200);
9269 case 7300: return GET_LOOPS (7300);
9270 case 7400: return GET_LOOPS (7400);
9271 case 7500: return GET_LOOPS (7500);
9272 case 7600: return GET_LOOPS (7600);
9273 case 7700: return GET_LOOPS (7700);
9274 case 7800: return GET_LOOPS (7800);
9275 case 7900: return GET_LOOPS (7900);
9276 case 8000: return GET_LOOPS (8000);
9277 case 8100: return GET_LOOPS (8100);
9278 case 8200: return GET_LOOPS (8200);
9279 case 8300: return GET_LOOPS (8300);
9280 case 8400: return GET_LOOPS (8400);
9281 case 8500: return GET_LOOPS (8500);
9282 case 8600: return GET_LOOPS (8600);
9283 case 8700: return GET_LOOPS (8700);
9284 case 8800: return GET_LOOPS (8800);
9285 case 8900: return GET_LOOPS (8900);
9286 case 9000: return GET_LOOPS (9000);
9287 case 9100: return GET_LOOPS (9100);
9288 case 9200: return GET_LOOPS (9200);
9289 case 9300: return GET_LOOPS (9300);
9290 case 9400: return GET_LOOPS (9400);
9291 case 9500: return GET_LOOPS (9500);
9292 case 9600: return GET_LOOPS (9600);
9293 case 9700: return GET_LOOPS (9700);
9294 case 9710: return GET_LOOPS (9710);
9295 case 9720: return GET_LOOPS (9720);
9296 case 9800: return GET_LOOPS (9800);
9297 case 9810: return GET_LOOPS (9810);
9298 case 9820: return GET_LOOPS (9820);
9299 case 9900: return GET_LOOPS (9900);
9300 case 10000: return GET_LOOPS (10000);
9301 case 10100: return GET_LOOPS (10100);
9302 case 10200: return GET_LOOPS (10200);
9303 case 10300: return GET_LOOPS (10300);
9304 case 10400: return GET_LOOPS (10400);
9305 case 10410: return GET_LOOPS (10410);
9306 case 10420: return GET_LOOPS (10420);
9307 case 10500: return GET_LOOPS (10500);
9308 case 10600: return GET_LOOPS (10600);
9309 case 10700: return GET_LOOPS (10700);
9310 case 10800: return GET_LOOPS (10800);
9311 case 10900: return GET_LOOPS (10900);
9312 case 11000: return GET_LOOPS (11000);
9313 case 11100: return GET_LOOPS (11100);
9314 case 11200: return GET_LOOPS (11200);
9315 case 11300: return GET_LOOPS (11300);
9316 case 11400: return GET_LOOPS (11400);
9317 case 11500: return GET_LOOPS (11500);
9318 case 11600: return GET_LOOPS (11600);
9319 case 11700: return GET_LOOPS (11700);
9320 case 11800: return GET_LOOPS (11800);
9321 case 11900: return GET_LOOPS (11900);
9322 case 12000: return GET_LOOPS (12000);
9323 case 12100: return GET_LOOPS (12100);
9324 case 12200: return GET_LOOPS (12200);
9325 case 12300: return GET_LOOPS (12300);
9326 case 12400: return GET_LOOPS (12400);
9327 case 12500: return GET_LOOPS (12500);
9328 case 12600: return GET_LOOPS (12600);
9329 case 12700: return GET_LOOPS (12700);
9330 case 12800: return GET_LOOPS (12800);
9331 case 12900: return GET_LOOPS (12900);
9332 case 13000: return GET_LOOPS (13000);
9342 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9346 if (salt_len
> sizeof (tmp
))
9351 memset (tmp
, 0, sizeof (tmp
));
9352 memcpy (tmp
, in
, salt_len
);
9354 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9356 if ((salt_len
% 2) == 0)
9358 u32 new_salt_len
= salt_len
/ 2;
9360 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9365 tmp
[i
] = hex_convert (p1
) << 0;
9366 tmp
[i
] |= hex_convert (p0
) << 4;
9369 salt_len
= new_salt_len
;
9376 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9378 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9381 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9383 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9387 u32
*tmp_uint
= (u32
*) tmp
;
9389 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9390 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9391 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9392 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9393 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9394 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9395 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9396 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9397 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9398 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9400 salt_len
= salt_len
* 2;
9408 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9410 lowercase (tmp
, salt_len
);
9413 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9415 uppercase (tmp
, salt_len
);
9420 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9425 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9430 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9432 u32
*tmp_uint
= (uint
*) tmp
;
9438 for (u32 i
= 0; i
< max
; i
++)
9440 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9443 // Important: we may need to increase the length of memcpy since
9444 // we don't want to "loose" some swapped bytes (could happen if
9445 // they do not perfectly fit in the 4-byte blocks)
9446 // Memcpy does always copy the bytes in the BE order, but since
9447 // we swapped them, some important bytes could be in positions
9448 // we normally skip with the original len
9450 if (len
% 4) len
+= 4 - (len
% 4);
9453 memcpy (out
, tmp
, len
);
9458 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9460 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9462 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9464 u32
*digest
= (u32
*) hash_buf
->digest
;
9466 salt_t
*salt
= hash_buf
->salt
;
9468 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9470 char *iter_pos
= input_buf
+ 4;
9472 salt
->salt_iter
= 1 << atoi (iter_pos
);
9474 char *salt_pos
= strchr (iter_pos
, '$');
9476 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9482 salt
->salt_len
= salt_len
;
9486 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9488 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9490 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9492 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9494 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9495 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9496 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9497 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9499 char *hash_pos
= salt_pos
+ 22;
9501 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9503 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9505 memcpy (digest
, tmp_buf
, 24);
9507 digest
[0] = byte_swap_32 (digest
[0]);
9508 digest
[1] = byte_swap_32 (digest
[1]);
9509 digest
[2] = byte_swap_32 (digest
[2]);
9510 digest
[3] = byte_swap_32 (digest
[3]);
9511 digest
[4] = byte_swap_32 (digest
[4]);
9512 digest
[5] = byte_swap_32 (digest
[5]);
9514 digest
[5] &= ~0xff; // its just 23 not 24 !
9519 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9521 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9523 u32
*digest
= (u32
*) hash_buf
->digest
;
9527 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9529 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9531 memcpy (digest
, tmp_buf
, 32);
9533 digest
[0] = byte_swap_32 (digest
[0]);
9534 digest
[1] = byte_swap_32 (digest
[1]);
9535 digest
[2] = byte_swap_32 (digest
[2]);
9536 digest
[3] = byte_swap_32 (digest
[3]);
9537 digest
[4] = byte_swap_32 (digest
[4]);
9538 digest
[5] = byte_swap_32 (digest
[5]);
9539 digest
[6] = byte_swap_32 (digest
[6]);
9540 digest
[7] = byte_swap_32 (digest
[7]);
9542 digest
[0] -= SHA256M_A
;
9543 digest
[1] -= SHA256M_B
;
9544 digest
[2] -= SHA256M_C
;
9545 digest
[3] -= SHA256M_D
;
9546 digest
[4] -= SHA256M_E
;
9547 digest
[5] -= SHA256M_F
;
9548 digest
[6] -= SHA256M_G
;
9549 digest
[7] -= SHA256M_H
;
9554 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9556 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9558 u32
*digest
= (u32
*) hash_buf
->digest
;
9560 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9561 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9563 digest
[0] = byte_swap_32 (digest
[0]);
9564 digest
[1] = byte_swap_32 (digest
[1]);
9568 IP (digest
[0], digest
[1], tt
);
9570 digest
[0] = digest
[0];
9571 digest
[1] = digest
[1];
9578 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9580 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9582 u32
*digest
= (u32
*) hash_buf
->digest
;
9584 salt_t
*salt
= hash_buf
->salt
;
9586 char *hash_pos
= input_buf
+ 8;
9588 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9589 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9590 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9591 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9592 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9594 digest
[0] -= SHA1M_A
;
9595 digest
[1] -= SHA1M_B
;
9596 digest
[2] -= SHA1M_C
;
9597 digest
[3] -= SHA1M_D
;
9598 digest
[4] -= SHA1M_E
;
9602 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9604 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9606 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9608 salt
->salt_len
= salt_len
;
9613 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9615 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9617 u64
*digest
= (u64
*) hash_buf
->digest
;
9619 salt_t
*salt
= hash_buf
->salt
;
9621 char *hash_pos
= input_buf
+ 8;
9623 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9624 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9625 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9626 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9627 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9628 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9629 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9630 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9632 digest
[0] -= SHA512M_A
;
9633 digest
[1] -= SHA512M_B
;
9634 digest
[2] -= SHA512M_C
;
9635 digest
[3] -= SHA512M_D
;
9636 digest
[4] -= SHA512M_E
;
9637 digest
[5] -= SHA512M_F
;
9638 digest
[6] -= SHA512M_G
;
9639 digest
[7] -= SHA512M_H
;
9643 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9645 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9647 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9649 salt
->salt_len
= salt_len
;
9654 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9656 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9658 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9662 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9665 u32
*digest
= (u32
*) hash_buf
->digest
;
9667 salt_t
*salt
= hash_buf
->salt
;
9669 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9670 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9671 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9672 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9674 digest
[0] = byte_swap_32 (digest
[0]);
9675 digest
[1] = byte_swap_32 (digest
[1]);
9676 digest
[2] = byte_swap_32 (digest
[2]);
9677 digest
[3] = byte_swap_32 (digest
[3]);
9679 digest
[0] -= MD5M_A
;
9680 digest
[1] -= MD5M_B
;
9681 digest
[2] -= MD5M_C
;
9682 digest
[3] -= MD5M_D
;
9684 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9686 uint salt_len
= input_len
- 32 - 1;
9688 char *salt_buf
= input_buf
+ 32 + 1;
9690 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9692 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9694 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9696 salt
->salt_len
= salt_len
;
9701 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9703 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9705 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9709 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9714 char clean_input_buf
[32];
9716 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9717 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9719 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9723 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9729 clean_input_buf
[k
] = input_buf
[i
];
9737 u32
*digest
= (u32
*) hash_buf
->digest
;
9739 salt_t
*salt
= hash_buf
->salt
;
9741 u32 a
, b
, c
, d
, e
, f
;
9743 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9744 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9745 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9746 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9747 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9748 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9750 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9751 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9753 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9754 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9755 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9756 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9757 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9758 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9760 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9761 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9763 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9764 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9765 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9766 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9767 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9768 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9770 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9771 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9773 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9774 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9775 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9776 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9777 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9778 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9780 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9781 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9783 digest
[0] = byte_swap_32 (digest
[0]);
9784 digest
[1] = byte_swap_32 (digest
[1]);
9785 digest
[2] = byte_swap_32 (digest
[2]);
9786 digest
[3] = byte_swap_32 (digest
[3]);
9788 digest
[0] -= MD5M_A
;
9789 digest
[1] -= MD5M_B
;
9790 digest
[2] -= MD5M_C
;
9791 digest
[3] -= MD5M_D
;
9793 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9795 uint salt_len
= input_len
- 30 - 1;
9797 char *salt_buf
= input_buf
+ 30 + 1;
9799 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9801 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9803 // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
9804 if (salt_len
> 10) return (PARSER_SALT_LENGTH
);
9806 salt
->salt_len
= salt_len
;
9808 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9810 salt
->salt_len
+= 22;
9815 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9817 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9819 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9823 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9826 u32
*digest
= (u32
*) hash_buf
->digest
;
9828 salt_t
*salt
= hash_buf
->salt
;
9830 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9831 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9832 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9833 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9834 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
9836 digest
[0] -= SHA1M_A
;
9837 digest
[1] -= SHA1M_B
;
9838 digest
[2] -= SHA1M_C
;
9839 digest
[3] -= SHA1M_D
;
9840 digest
[4] -= SHA1M_E
;
9842 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9844 uint salt_len
= input_len
- 40 - 1;
9846 char *salt_buf
= input_buf
+ 40 + 1;
9848 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9850 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9852 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9854 salt
->salt_len
= salt_len
;
9859 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9861 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9863 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9867 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9870 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9872 char *iter_pos
= input_buf
+ 6;
9874 salt_t
*salt
= hash_buf
->salt
;
9876 uint iter
= atoi (iter_pos
);
9883 salt
->salt_iter
= iter
- 1;
9885 char *salt_pos
= strchr (iter_pos
, '#');
9887 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9891 char *digest_pos
= strchr (salt_pos
, '#');
9893 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9897 uint salt_len
= digest_pos
- salt_pos
- 1;
9899 u32
*digest
= (u32
*) hash_buf
->digest
;
9901 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
9902 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
9903 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
9904 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
9906 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9908 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9910 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9912 salt
->salt_len
= salt_len
;
9917 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9919 u32
*digest
= (u32
*) hash_buf
->digest
;
9921 salt_t
*salt
= hash_buf
->salt
;
9923 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
9927 memcpy (&in
, input_buf
, input_len
);
9929 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
9931 memcpy (digest
, in
.keymic
, 16);
9934 http://www.one-net.eu/jsw/j_sec/m_ptype.html
9935 The phrase "Pairwise key expansion"
9936 Access Point Address (Referred to as Authenticator Address AA)
9937 Supplicant Address (referred to as Supplicant Address SA)
9938 Access Point Nonce (referred to as Authenticator Anonce)
9939 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
9942 uint salt_len
= strlen (in
.essid
);
9944 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
9946 salt
->salt_len
= salt_len
;
9948 salt
->salt_iter
= ROUNDS_WPA2
- 1;
9950 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
9952 memcpy (pke_ptr
, "Pairwise key expansion", 23);
9954 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
9956 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
9957 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
9961 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
9962 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
9965 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
9967 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
9968 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
9972 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
9973 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
9976 for (int i
= 0; i
< 25; i
++)
9978 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
9981 wpa
->keyver
= in
.keyver
;
9983 if (wpa
->keyver
> 255)
9985 log_info ("ATTENTION!");
9986 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
9987 log_info (" This could be due to a recent aircrack-ng bug.");
9988 log_info (" The key version was automatically reset to a reasonable value.");
9991 wpa
->keyver
&= 0xff;
9994 wpa
->eapol_size
= in
.eapol_size
;
9996 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
9998 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10000 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10002 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10004 if (wpa
->keyver
== 1)
10010 digest
[0] = byte_swap_32 (digest
[0]);
10011 digest
[1] = byte_swap_32 (digest
[1]);
10012 digest
[2] = byte_swap_32 (digest
[2]);
10013 digest
[3] = byte_swap_32 (digest
[3]);
10015 for (int i
= 0; i
< 64; i
++)
10017 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10021 salt
->salt_buf
[10] = digest
[1];
10022 salt
->salt_buf
[11] = digest
[2];
10024 return (PARSER_OK
);
10027 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10029 u32
*digest
= (u32
*) hash_buf
->digest
;
10031 salt_t
*salt
= hash_buf
->salt
;
10033 if (input_len
== 0)
10035 log_error ("Password Safe v2 container not specified");
10040 FILE *fp
= fopen (input_buf
, "rb");
10044 log_error ("%s: %s", input_buf
, strerror (errno
));
10053 u32 salt
[5]; // unused, but makes better valid check
10054 u32 iv
[2]; // unused, but makes better valid check
10060 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10064 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10066 salt
->salt_buf
[0] = buf
.random
[0];
10067 salt
->salt_buf
[1] = buf
.random
[1];
10069 salt
->salt_len
= 8;
10070 salt
->salt_iter
= 1000;
10072 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10073 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10074 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10075 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10076 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10078 return (PARSER_OK
);
10081 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10083 u32
*digest
= (u32
*) hash_buf
->digest
;
10085 salt_t
*salt
= hash_buf
->salt
;
10087 if (input_len
== 0)
10089 log_error (".psafe3 not specified");
10094 FILE *fp
= fopen (input_buf
, "rb");
10098 log_error ("%s: %s", input_buf
, strerror (errno
));
10105 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10109 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10111 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10113 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10115 salt
->salt_iter
= in
.iterations
+ 1;
10117 salt
->salt_buf
[0] = in
.salt_buf
[0];
10118 salt
->salt_buf
[1] = in
.salt_buf
[1];
10119 salt
->salt_buf
[2] = in
.salt_buf
[2];
10120 salt
->salt_buf
[3] = in
.salt_buf
[3];
10121 salt
->salt_buf
[4] = in
.salt_buf
[4];
10122 salt
->salt_buf
[5] = in
.salt_buf
[5];
10123 salt
->salt_buf
[6] = in
.salt_buf
[6];
10124 salt
->salt_buf
[7] = in
.salt_buf
[7];
10126 salt
->salt_len
= 32;
10128 digest
[0] = in
.hash_buf
[0];
10129 digest
[1] = in
.hash_buf
[1];
10130 digest
[2] = in
.hash_buf
[2];
10131 digest
[3] = in
.hash_buf
[3];
10132 digest
[4] = in
.hash_buf
[4];
10133 digest
[5] = in
.hash_buf
[5];
10134 digest
[6] = in
.hash_buf
[6];
10135 digest
[7] = in
.hash_buf
[7];
10137 digest
[0] = byte_swap_32 (digest
[0]);
10138 digest
[1] = byte_swap_32 (digest
[1]);
10139 digest
[2] = byte_swap_32 (digest
[2]);
10140 digest
[3] = byte_swap_32 (digest
[3]);
10141 digest
[4] = byte_swap_32 (digest
[4]);
10142 digest
[5] = byte_swap_32 (digest
[5]);
10143 digest
[6] = byte_swap_32 (digest
[6]);
10144 digest
[7] = byte_swap_32 (digest
[7]);
10146 return (PARSER_OK
);
10149 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10151 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10153 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10155 u32
*digest
= (u32
*) hash_buf
->digest
;
10157 salt_t
*salt
= hash_buf
->salt
;
10159 char *iter_pos
= input_buf
+ 3;
10161 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10163 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10165 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10167 salt
->salt_iter
= salt_iter
;
10169 char *salt_pos
= iter_pos
+ 1;
10173 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10175 salt
->salt_len
= salt_len
;
10177 char *hash_pos
= salt_pos
+ salt_len
;
10179 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10181 return (PARSER_OK
);
10184 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10186 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10188 u32
*digest
= (u32
*) hash_buf
->digest
;
10190 salt_t
*salt
= hash_buf
->salt
;
10192 char *salt_pos
= input_buf
+ 3;
10194 uint iterations_len
= 0;
10196 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10200 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10202 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10203 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10207 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10211 iterations_len
+= 8;
10215 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10218 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10220 char *hash_pos
= strchr (salt_pos
, '$');
10222 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10224 uint salt_len
= hash_pos
- salt_pos
;
10226 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10228 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10230 salt
->salt_len
= salt_len
;
10234 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10236 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10238 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10240 return (PARSER_OK
);
10243 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10245 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10247 u32
*digest
= (u32
*) hash_buf
->digest
;
10249 salt_t
*salt
= hash_buf
->salt
;
10251 char *salt_pos
= input_buf
+ 6;
10253 uint iterations_len
= 0;
10255 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10259 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10261 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10262 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10266 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10270 iterations_len
+= 8;
10274 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10277 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10279 char *hash_pos
= strchr (salt_pos
, '$');
10281 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10283 uint salt_len
= hash_pos
- salt_pos
;
10285 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10287 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10289 salt
->salt_len
= salt_len
;
10293 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10295 return (PARSER_OK
);
10298 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10300 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10302 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10304 u32
*digest
= (u32
*) hash_buf
->digest
;
10306 salt_t
*salt
= hash_buf
->salt
;
10308 char *salt_pos
= input_buf
+ 14;
10310 char *hash_pos
= strchr (salt_pos
, '*');
10312 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10316 uint salt_len
= hash_pos
- salt_pos
- 1;
10318 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10320 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10322 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10324 salt
->salt_len
= salt_len
;
10328 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10330 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10332 memcpy (digest
, tmp_buf
, 20);
10334 digest
[0] = byte_swap_32 (digest
[0]);
10335 digest
[1] = byte_swap_32 (digest
[1]);
10336 digest
[2] = byte_swap_32 (digest
[2]);
10337 digest
[3] = byte_swap_32 (digest
[3]);
10338 digest
[4] = byte_swap_32 (digest
[4]);
10340 digest
[0] -= SHA1M_A
;
10341 digest
[1] -= SHA1M_B
;
10342 digest
[2] -= SHA1M_C
;
10343 digest
[3] -= SHA1M_D
;
10344 digest
[4] -= SHA1M_E
;
10346 return (PARSER_OK
);
10349 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10351 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10353 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10355 if (c12
& 3) return (PARSER_HASH_VALUE
);
10357 u32
*digest
= (u32
*) hash_buf
->digest
;
10359 salt_t
*salt
= hash_buf
->salt
;
10361 // for ascii_digest
10362 salt
->salt_sign
[0] = input_buf
[0];
10363 salt
->salt_sign
[1] = input_buf
[1];
10365 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10366 | itoa64_to_int (input_buf
[1]) << 6;
10368 salt
->salt_len
= 2;
10372 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10374 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10376 memcpy (digest
, tmp_buf
, 8);
10380 IP (digest
[0], digest
[1], tt
);
10385 return (PARSER_OK
);
10388 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10390 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10392 u32
*digest
= (u32
*) hash_buf
->digest
;
10394 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10395 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10396 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10397 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10399 digest
[0] = byte_swap_32 (digest
[0]);
10400 digest
[1] = byte_swap_32 (digest
[1]);
10401 digest
[2] = byte_swap_32 (digest
[2]);
10402 digest
[3] = byte_swap_32 (digest
[3]);
10404 digest
[0] -= MD4M_A
;
10405 digest
[1] -= MD4M_B
;
10406 digest
[2] -= MD4M_C
;
10407 digest
[3] -= MD4M_D
;
10409 return (PARSER_OK
);
10412 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10414 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10416 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10420 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10423 u32
*digest
= (u32
*) hash_buf
->digest
;
10425 salt_t
*salt
= hash_buf
->salt
;
10427 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10428 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10429 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10430 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10432 digest
[0] = byte_swap_32 (digest
[0]);
10433 digest
[1] = byte_swap_32 (digest
[1]);
10434 digest
[2] = byte_swap_32 (digest
[2]);
10435 digest
[3] = byte_swap_32 (digest
[3]);
10437 digest
[0] -= MD4M_A
;
10438 digest
[1] -= MD4M_B
;
10439 digest
[2] -= MD4M_C
;
10440 digest
[3] -= MD4M_D
;
10442 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10444 uint salt_len
= input_len
- 32 - 1;
10446 char *salt_buf
= input_buf
+ 32 + 1;
10448 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10450 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10452 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10454 salt
->salt_len
= salt_len
;
10456 return (PARSER_OK
);
10459 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10461 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10463 u32
*digest
= (u32
*) hash_buf
->digest
;
10465 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10466 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10467 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10468 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10470 digest
[0] = byte_swap_32 (digest
[0]);
10471 digest
[1] = byte_swap_32 (digest
[1]);
10472 digest
[2] = byte_swap_32 (digest
[2]);
10473 digest
[3] = byte_swap_32 (digest
[3]);
10475 digest
[0] -= MD5M_A
;
10476 digest
[1] -= MD5M_B
;
10477 digest
[2] -= MD5M_C
;
10478 digest
[3] -= MD5M_D
;
10480 return (PARSER_OK
);
10483 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10485 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10487 u32
*digest
= (u32
*) hash_buf
->digest
;
10489 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10490 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10494 digest
[0] = byte_swap_32 (digest
[0]);
10495 digest
[1] = byte_swap_32 (digest
[1]);
10497 return (PARSER_OK
);
10500 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10502 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10504 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10508 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10511 u32
*digest
= (u32
*) hash_buf
->digest
;
10513 salt_t
*salt
= hash_buf
->salt
;
10515 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10516 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10517 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10518 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10520 digest
[0] = byte_swap_32 (digest
[0]);
10521 digest
[1] = byte_swap_32 (digest
[1]);
10522 digest
[2] = byte_swap_32 (digest
[2]);
10523 digest
[3] = byte_swap_32 (digest
[3]);
10525 digest
[0] -= MD5M_A
;
10526 digest
[1] -= MD5M_B
;
10527 digest
[2] -= MD5M_C
;
10528 digest
[3] -= MD5M_D
;
10530 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10532 uint salt_len
= input_len
- 32 - 1;
10534 char *salt_buf
= input_buf
+ 32 + 1;
10536 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10538 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10540 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10542 salt
->salt_len
= salt_len
;
10544 return (PARSER_OK
);
10547 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10549 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10551 u32
*digest
= (u32
*) hash_buf
->digest
;
10553 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10554 | itoa64_to_int (input_buf
[ 1]) << 6
10555 | itoa64_to_int (input_buf
[ 2]) << 12
10556 | itoa64_to_int (input_buf
[ 3]) << 18;
10557 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10558 | itoa64_to_int (input_buf
[ 5]) << 6
10559 | itoa64_to_int (input_buf
[ 6]) << 12
10560 | itoa64_to_int (input_buf
[ 7]) << 18;
10561 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10562 | itoa64_to_int (input_buf
[ 9]) << 6
10563 | itoa64_to_int (input_buf
[10]) << 12
10564 | itoa64_to_int (input_buf
[11]) << 18;
10565 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10566 | itoa64_to_int (input_buf
[13]) << 6
10567 | itoa64_to_int (input_buf
[14]) << 12
10568 | itoa64_to_int (input_buf
[15]) << 18;
10570 digest
[0] -= MD5M_A
;
10571 digest
[1] -= MD5M_B
;
10572 digest
[2] -= MD5M_C
;
10573 digest
[3] -= MD5M_D
;
10575 digest
[0] &= 0x00ffffff;
10576 digest
[1] &= 0x00ffffff;
10577 digest
[2] &= 0x00ffffff;
10578 digest
[3] &= 0x00ffffff;
10580 return (PARSER_OK
);
10583 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10585 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10587 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10591 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10594 u32
*digest
= (u32
*) hash_buf
->digest
;
10596 salt_t
*salt
= hash_buf
->salt
;
10598 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10599 | itoa64_to_int (input_buf
[ 1]) << 6
10600 | itoa64_to_int (input_buf
[ 2]) << 12
10601 | itoa64_to_int (input_buf
[ 3]) << 18;
10602 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10603 | itoa64_to_int (input_buf
[ 5]) << 6
10604 | itoa64_to_int (input_buf
[ 6]) << 12
10605 | itoa64_to_int (input_buf
[ 7]) << 18;
10606 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10607 | itoa64_to_int (input_buf
[ 9]) << 6
10608 | itoa64_to_int (input_buf
[10]) << 12
10609 | itoa64_to_int (input_buf
[11]) << 18;
10610 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10611 | itoa64_to_int (input_buf
[13]) << 6
10612 | itoa64_to_int (input_buf
[14]) << 12
10613 | itoa64_to_int (input_buf
[15]) << 18;
10615 digest
[0] -= MD5M_A
;
10616 digest
[1] -= MD5M_B
;
10617 digest
[2] -= MD5M_C
;
10618 digest
[3] -= MD5M_D
;
10620 digest
[0] &= 0x00ffffff;
10621 digest
[1] &= 0x00ffffff;
10622 digest
[2] &= 0x00ffffff;
10623 digest
[3] &= 0x00ffffff;
10625 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10627 uint salt_len
= input_len
- 16 - 1;
10629 char *salt_buf
= input_buf
+ 16 + 1;
10631 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10633 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10635 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10637 salt
->salt_len
= salt_len
;
10639 return (PARSER_OK
);
10642 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10644 key
[0] = (nthash
[0] >> 0);
10645 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10646 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10647 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10648 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10649 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10650 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10651 key
[7] = (nthash
[6] << 1);
10663 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10665 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10667 u32
*digest
= (u32
*) hash_buf
->digest
;
10669 salt_t
*salt
= hash_buf
->salt
;
10671 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10677 char *user_pos
= input_buf
;
10679 char *unused_pos
= strchr (user_pos
, ':');
10681 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10683 uint user_len
= unused_pos
- user_pos
;
10685 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10689 char *domain_pos
= strchr (unused_pos
, ':');
10691 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10693 uint unused_len
= domain_pos
- unused_pos
;
10695 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10699 char *srvchall_pos
= strchr (domain_pos
, ':');
10701 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10703 uint domain_len
= srvchall_pos
- domain_pos
;
10705 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10709 char *hash_pos
= strchr (srvchall_pos
, ':');
10711 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10713 uint srvchall_len
= hash_pos
- srvchall_pos
;
10715 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10719 char *clichall_pos
= strchr (hash_pos
, ':');
10721 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10723 uint hash_len
= clichall_pos
- hash_pos
;
10725 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10729 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10731 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10734 * store some data for later use
10737 netntlm
->user_len
= user_len
* 2;
10738 netntlm
->domain_len
= domain_len
* 2;
10739 netntlm
->srvchall_len
= srvchall_len
/ 2;
10740 netntlm
->clichall_len
= clichall_len
/ 2;
10742 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10743 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10746 * handle username and domainname
10749 for (uint i
= 0; i
< user_len
; i
++)
10751 *userdomain_ptr
++ = user_pos
[i
];
10752 *userdomain_ptr
++ = 0;
10755 for (uint i
= 0; i
< domain_len
; i
++)
10757 *userdomain_ptr
++ = domain_pos
[i
];
10758 *userdomain_ptr
++ = 0;
10762 * handle server challenge encoding
10765 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10767 const char p0
= srvchall_pos
[i
+ 0];
10768 const char p1
= srvchall_pos
[i
+ 1];
10770 *chall_ptr
++ = hex_convert (p1
) << 0
10771 | hex_convert (p0
) << 4;
10775 * handle client challenge encoding
10778 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10780 const char p0
= clichall_pos
[i
+ 0];
10781 const char p1
= clichall_pos
[i
+ 1];
10783 *chall_ptr
++ = hex_convert (p1
) << 0
10784 | hex_convert (p0
) << 4;
10791 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10793 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10795 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10797 salt
->salt_len
= salt_len
;
10799 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10800 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10801 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10802 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10804 digest
[0] = byte_swap_32 (digest
[0]);
10805 digest
[1] = byte_swap_32 (digest
[1]);
10806 digest
[2] = byte_swap_32 (digest
[2]);
10807 digest
[3] = byte_swap_32 (digest
[3]);
10809 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10811 uint digest_tmp
[2];
10813 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10814 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
10816 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10817 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10819 /* special case 2: ESS */
10821 if (srvchall_len
== 48)
10823 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10827 w
[ 0] = netntlm
->chall_buf
[6];
10828 w
[ 1] = netntlm
->chall_buf
[7];
10829 w
[ 2] = netntlm
->chall_buf
[0];
10830 w
[ 3] = netntlm
->chall_buf
[1];
10853 salt
->salt_buf
[0] = dgst
[0];
10854 salt
->salt_buf
[1] = dgst
[1];
10858 /* precompute netntlmv1 exploit start */
10860 for (uint i
= 0; i
< 0x10000; i
++)
10862 uint key_md4
[2] = { i
, 0 };
10863 uint key_des
[2] = { 0, 0 };
10865 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
10870 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10872 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10874 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10876 if (data3
[0] != digest_tmp
[0]) continue;
10877 if (data3
[1] != digest_tmp
[1]) continue;
10879 salt
->salt_buf
[2] = i
;
10881 salt
->salt_len
= 24;
10886 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10887 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10889 /* precompute netntlmv1 exploit stop */
10893 IP (digest
[0], digest
[1], tt
);
10894 IP (digest
[2], digest
[3], tt
);
10896 digest
[0] = rotr32 (digest
[0], 29);
10897 digest
[1] = rotr32 (digest
[1], 29);
10898 digest
[2] = rotr32 (digest
[2], 29);
10899 digest
[3] = rotr32 (digest
[3], 29);
10901 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10903 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
10904 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
10906 return (PARSER_OK
);
10909 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10911 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10913 u32
*digest
= (u32
*) hash_buf
->digest
;
10915 salt_t
*salt
= hash_buf
->salt
;
10917 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10923 char *user_pos
= input_buf
;
10925 char *unused_pos
= strchr (user_pos
, ':');
10927 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10929 uint user_len
= unused_pos
- user_pos
;
10931 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10935 char *domain_pos
= strchr (unused_pos
, ':');
10937 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10939 uint unused_len
= domain_pos
- unused_pos
;
10941 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10945 char *srvchall_pos
= strchr (domain_pos
, ':');
10947 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10949 uint domain_len
= srvchall_pos
- domain_pos
;
10951 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10955 char *hash_pos
= strchr (srvchall_pos
, ':');
10957 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10959 uint srvchall_len
= hash_pos
- srvchall_pos
;
10961 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
10965 char *clichall_pos
= strchr (hash_pos
, ':');
10967 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10969 uint hash_len
= clichall_pos
- hash_pos
;
10971 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
10975 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10977 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
10979 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
10982 * store some data for later use
10985 netntlm
->user_len
= user_len
* 2;
10986 netntlm
->domain_len
= domain_len
* 2;
10987 netntlm
->srvchall_len
= srvchall_len
/ 2;
10988 netntlm
->clichall_len
= clichall_len
/ 2;
10990 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10991 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10994 * handle username and domainname
10997 for (uint i
= 0; i
< user_len
; i
++)
10999 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11000 *userdomain_ptr
++ = 0;
11003 for (uint i
= 0; i
< domain_len
; i
++)
11005 *userdomain_ptr
++ = domain_pos
[i
];
11006 *userdomain_ptr
++ = 0;
11009 *userdomain_ptr
++ = 0x80;
11012 * handle server challenge encoding
11015 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11017 const char p0
= srvchall_pos
[i
+ 0];
11018 const char p1
= srvchall_pos
[i
+ 1];
11020 *chall_ptr
++ = hex_convert (p1
) << 0
11021 | hex_convert (p0
) << 4;
11025 * handle client challenge encoding
11028 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11030 const char p0
= clichall_pos
[i
+ 0];
11031 const char p1
= clichall_pos
[i
+ 1];
11033 *chall_ptr
++ = hex_convert (p1
) << 0
11034 | hex_convert (p0
) << 4;
11037 *chall_ptr
++ = 0x80;
11040 * handle hash itself
11043 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11044 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11045 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11046 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11048 digest
[0] = byte_swap_32 (digest
[0]);
11049 digest
[1] = byte_swap_32 (digest
[1]);
11050 digest
[2] = byte_swap_32 (digest
[2]);
11051 digest
[3] = byte_swap_32 (digest
[3]);
11054 * reuse challange data as salt_buf, its the buffer that is most likely unique
11057 salt
->salt_buf
[0] = 0;
11058 salt
->salt_buf
[1] = 0;
11059 salt
->salt_buf
[2] = 0;
11060 salt
->salt_buf
[3] = 0;
11061 salt
->salt_buf
[4] = 0;
11062 salt
->salt_buf
[5] = 0;
11063 salt
->salt_buf
[6] = 0;
11064 salt
->salt_buf
[7] = 0;
11068 uptr
= (uint
*) netntlm
->userdomain_buf
;
11070 for (uint i
= 0; i
< 16; i
+= 16)
11072 md5_64 (uptr
, salt
->salt_buf
);
11075 uptr
= (uint
*) netntlm
->chall_buf
;
11077 for (uint i
= 0; i
< 256; i
+= 16)
11079 md5_64 (uptr
, salt
->salt_buf
);
11082 salt
->salt_len
= 16;
11084 return (PARSER_OK
);
11087 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11089 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11091 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11095 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11098 u32
*digest
= (u32
*) hash_buf
->digest
;
11100 salt_t
*salt
= hash_buf
->salt
;
11102 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11103 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11104 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11105 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11107 digest
[0] = byte_swap_32 (digest
[0]);
11108 digest
[1] = byte_swap_32 (digest
[1]);
11109 digest
[2] = byte_swap_32 (digest
[2]);
11110 digest
[3] = byte_swap_32 (digest
[3]);
11112 digest
[0] -= MD5M_A
;
11113 digest
[1] -= MD5M_B
;
11114 digest
[2] -= MD5M_C
;
11115 digest
[3] -= MD5M_D
;
11117 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11119 uint salt_len
= input_len
- 32 - 1;
11121 char *salt_buf
= input_buf
+ 32 + 1;
11123 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11125 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11127 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11129 salt
->salt_len
= salt_len
;
11131 return (PARSER_OK
);
11134 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11136 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11138 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11142 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11145 u32
*digest
= (u32
*) hash_buf
->digest
;
11147 salt_t
*salt
= hash_buf
->salt
;
11149 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11150 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11151 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11152 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11154 digest
[0] = byte_swap_32 (digest
[0]);
11155 digest
[1] = byte_swap_32 (digest
[1]);
11156 digest
[2] = byte_swap_32 (digest
[2]);
11157 digest
[3] = byte_swap_32 (digest
[3]);
11159 digest
[0] -= MD5M_A
;
11160 digest
[1] -= MD5M_B
;
11161 digest
[2] -= MD5M_C
;
11162 digest
[3] -= MD5M_D
;
11164 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11166 uint salt_len
= input_len
- 32 - 1;
11168 char *salt_buf
= input_buf
+ 32 + 1;
11170 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11172 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11174 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11176 salt
->salt_len
= salt_len
;
11178 return (PARSER_OK
);
11181 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11183 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11185 u32
*digest
= (u32
*) hash_buf
->digest
;
11187 salt_t
*salt
= hash_buf
->salt
;
11189 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11190 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11191 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11192 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11194 digest
[0] = byte_swap_32 (digest
[0]);
11195 digest
[1] = byte_swap_32 (digest
[1]);
11196 digest
[2] = byte_swap_32 (digest
[2]);
11197 digest
[3] = byte_swap_32 (digest
[3]);
11199 digest
[0] -= MD5M_A
;
11200 digest
[1] -= MD5M_B
;
11201 digest
[2] -= MD5M_C
;
11202 digest
[3] -= MD5M_D
;
11205 * This is a virtual salt. While the algorithm is basically not salted
11206 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11207 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11210 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11212 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11214 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11216 salt
->salt_len
= salt_len
;
11218 return (PARSER_OK
);
11221 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11223 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11225 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11229 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11232 u32
*digest
= (u32
*) hash_buf
->digest
;
11234 salt_t
*salt
= hash_buf
->salt
;
11236 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11237 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11238 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11239 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11241 digest
[0] = byte_swap_32 (digest
[0]);
11242 digest
[1] = byte_swap_32 (digest
[1]);
11243 digest
[2] = byte_swap_32 (digest
[2]);
11244 digest
[3] = byte_swap_32 (digest
[3]);
11246 digest
[0] -= MD5M_A
;
11247 digest
[1] -= MD5M_B
;
11248 digest
[2] -= MD5M_C
;
11249 digest
[3] -= MD5M_D
;
11251 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11253 uint salt_len
= input_len
- 32 - 1;
11255 char *salt_buf
= input_buf
+ 32 + 1;
11257 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11259 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11261 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11263 salt
->salt_len
= salt_len
;
11265 return (PARSER_OK
);
11268 int vb30_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_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11276 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) 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 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11295 uint salt_len
= input_len
- 32 - 1;
11297 char *salt_buf
= input_buf
+ 32 + 1;
11299 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11301 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11303 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11305 salt
->salt_len
= salt_len
;
11307 return (PARSER_OK
);
11310 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11312 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11314 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11318 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11321 u32
*digest
= (u32
*) hash_buf
->digest
;
11323 salt_t
*salt
= hash_buf
->salt
;
11325 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11326 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11327 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11328 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11330 digest
[0] = byte_swap_32 (digest
[0]);
11331 digest
[1] = byte_swap_32 (digest
[1]);
11332 digest
[2] = byte_swap_32 (digest
[2]);
11333 digest
[3] = byte_swap_32 (digest
[3]);
11335 digest
[0] -= MD4M_A
;
11336 digest
[1] -= MD4M_B
;
11337 digest
[2] -= MD4M_C
;
11338 digest
[3] -= MD4M_D
;
11340 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11342 uint salt_len
= input_len
- 32 - 1;
11344 char *salt_buf
= input_buf
+ 32 + 1;
11346 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11348 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11350 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11352 salt
->salt_len
= salt_len
;
11354 return (PARSER_OK
);
11357 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11359 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11361 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11365 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11368 u32
*digest
= (u32
*) hash_buf
->digest
;
11370 salt_t
*salt
= hash_buf
->salt
;
11372 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11373 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11374 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11375 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11377 digest
[0] = byte_swap_32 (digest
[0]);
11378 digest
[1] = byte_swap_32 (digest
[1]);
11379 digest
[2] = byte_swap_32 (digest
[2]);
11380 digest
[3] = byte_swap_32 (digest
[3]);
11382 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11384 uint salt_len
= input_len
- 32 - 1;
11386 char *salt_buf
= input_buf
+ 32 + 1;
11388 uint salt_pc_block
[16];
11390 memset (salt_pc_block
, 0, sizeof (salt_pc_block
));
11392 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11394 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11396 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11398 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11400 salt_pc_block
[14] = salt_len
* 8;
11402 uint salt_pc_digest
[4];
11404 salt_pc_digest
[0] = MAGIC_A
;
11405 salt_pc_digest
[1] = MAGIC_B
;
11406 salt_pc_digest
[2] = MAGIC_C
;
11407 salt_pc_digest
[3] = MAGIC_D
;
11409 md5_64 (salt_pc_block
, salt_pc_digest
);
11411 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11412 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11413 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11414 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11416 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11418 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11420 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11422 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11423 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11424 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11425 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11427 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11429 return (PARSER_OK
);
11432 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11434 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11436 u32
*digest
= (u32
*) hash_buf
->digest
;
11438 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11439 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11440 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11441 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11442 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11444 digest
[0] -= SHA1M_A
;
11445 digest
[1] -= SHA1M_B
;
11446 digest
[2] -= SHA1M_C
;
11447 digest
[3] -= SHA1M_D
;
11448 digest
[4] -= SHA1M_E
;
11450 return (PARSER_OK
);
11453 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11455 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11457 u32
*digest
= (u32
*) hash_buf
->digest
;
11459 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11460 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11461 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11462 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11463 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11465 return (PARSER_OK
);
11468 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11470 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11472 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11476 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11479 u32
*digest
= (u32
*) hash_buf
->digest
;
11481 salt_t
*salt
= hash_buf
->salt
;
11483 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11484 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11485 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11486 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11487 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11489 digest
[0] -= SHA1M_A
;
11490 digest
[1] -= SHA1M_B
;
11491 digest
[2] -= SHA1M_C
;
11492 digest
[3] -= SHA1M_D
;
11493 digest
[4] -= SHA1M_E
;
11495 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11497 uint salt_len
= input_len
- 40 - 1;
11499 char *salt_buf
= input_buf
+ 40 + 1;
11501 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11503 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11505 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11507 salt
->salt_len
= salt_len
;
11509 return (PARSER_OK
);
11512 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11514 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11516 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11518 u32
*digest
= (u32
*) hash_buf
->digest
;
11522 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11524 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11526 memcpy (digest
, tmp_buf
, 20);
11528 digest
[0] = byte_swap_32 (digest
[0]);
11529 digest
[1] = byte_swap_32 (digest
[1]);
11530 digest
[2] = byte_swap_32 (digest
[2]);
11531 digest
[3] = byte_swap_32 (digest
[3]);
11532 digest
[4] = byte_swap_32 (digest
[4]);
11534 digest
[0] -= SHA1M_A
;
11535 digest
[1] -= SHA1M_B
;
11536 digest
[2] -= SHA1M_C
;
11537 digest
[3] -= SHA1M_D
;
11538 digest
[4] -= SHA1M_E
;
11540 return (PARSER_OK
);
11543 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11545 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11547 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11549 u32
*digest
= (u32
*) hash_buf
->digest
;
11551 salt_t
*salt
= hash_buf
->salt
;
11555 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11557 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11559 memcpy (digest
, tmp_buf
, 20);
11561 salt
->salt_len
= tmp_len
- 20;
11563 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11565 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11567 char *ptr
= (char *) salt
->salt_buf
;
11569 ptr
[salt
->salt_len
] = 0x80;
11572 digest
[0] = byte_swap_32 (digest
[0]);
11573 digest
[1] = byte_swap_32 (digest
[1]);
11574 digest
[2] = byte_swap_32 (digest
[2]);
11575 digest
[3] = byte_swap_32 (digest
[3]);
11576 digest
[4] = byte_swap_32 (digest
[4]);
11578 digest
[0] -= SHA1M_A
;
11579 digest
[1] -= SHA1M_B
;
11580 digest
[2] -= SHA1M_C
;
11581 digest
[3] -= SHA1M_D
;
11582 digest
[4] -= SHA1M_E
;
11584 return (PARSER_OK
);
11587 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11589 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11591 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11593 u32
*digest
= (u32
*) hash_buf
->digest
;
11595 salt_t
*salt
= hash_buf
->salt
;
11597 char *salt_buf
= input_buf
+ 6;
11601 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11603 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11605 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11607 salt
->salt_len
= salt_len
;
11609 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11611 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11612 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11613 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11614 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11615 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11617 digest
[0] -= SHA1M_A
;
11618 digest
[1] -= SHA1M_B
;
11619 digest
[2] -= SHA1M_C
;
11620 digest
[3] -= SHA1M_D
;
11621 digest
[4] -= SHA1M_E
;
11623 return (PARSER_OK
);
11626 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11628 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11630 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11632 u32
*digest
= (u32
*) hash_buf
->digest
;
11634 salt_t
*salt
= hash_buf
->salt
;
11636 char *salt_buf
= input_buf
+ 6;
11640 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11642 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11644 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11646 salt
->salt_len
= salt_len
;
11648 char *hash_pos
= input_buf
+ 6 + 8;
11650 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11651 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11652 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11653 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11654 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11656 digest
[0] -= SHA1M_A
;
11657 digest
[1] -= SHA1M_B
;
11658 digest
[2] -= SHA1M_C
;
11659 digest
[3] -= SHA1M_D
;
11660 digest
[4] -= SHA1M_E
;
11662 return (PARSER_OK
);
11665 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11667 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11669 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11671 u64
*digest
= (u64
*) hash_buf
->digest
;
11673 salt_t
*salt
= hash_buf
->salt
;
11675 char *salt_buf
= input_buf
+ 6;
11679 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11681 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11683 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11685 salt
->salt_len
= salt_len
;
11687 char *hash_pos
= input_buf
+ 6 + 8;
11689 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11690 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11691 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11692 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11693 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11694 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11695 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11696 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11698 digest
[0] -= SHA512M_A
;
11699 digest
[1] -= SHA512M_B
;
11700 digest
[2] -= SHA512M_C
;
11701 digest
[3] -= SHA512M_D
;
11702 digest
[4] -= SHA512M_E
;
11703 digest
[5] -= SHA512M_F
;
11704 digest
[6] -= SHA512M_G
;
11705 digest
[7] -= SHA512M_H
;
11707 return (PARSER_OK
);
11710 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11712 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11714 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11718 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11721 u32
*digest
= (u32
*) hash_buf
->digest
;
11723 salt_t
*salt
= hash_buf
->salt
;
11725 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11726 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11730 digest
[0] = byte_swap_32 (digest
[0]);
11731 digest
[1] = byte_swap_32 (digest
[1]);
11733 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11735 uint salt_len
= input_len
- 16 - 1;
11737 char *salt_buf
= input_buf
+ 16 + 1;
11739 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11741 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11743 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11745 salt
->salt_len
= salt_len
;
11747 return (PARSER_OK
);
11750 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11752 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11754 u32
*digest
= (u32
*) hash_buf
->digest
;
11756 salt_t
*salt
= hash_buf
->salt
;
11758 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11759 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11760 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11761 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11762 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11764 digest
[0] -= SHA1M_A
;
11765 digest
[1] -= SHA1M_B
;
11766 digest
[2] -= SHA1M_C
;
11767 digest
[3] -= SHA1M_D
;
11768 digest
[4] -= SHA1M_E
;
11770 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11772 uint salt_len
= input_len
- 40 - 1;
11774 char *salt_buf
= input_buf
+ 40 + 1;
11776 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11778 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11780 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11782 salt
->salt_len
= salt_len
;
11784 return (PARSER_OK
);
11787 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11789 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11791 u32
*digest
= (u32
*) hash_buf
->digest
;
11793 salt_t
*salt
= hash_buf
->salt
;
11795 char *hash_pos
= input_buf
;
11797 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11798 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11799 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
11800 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
11801 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
11802 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
11803 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
11804 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
11805 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
11806 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
11807 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
11808 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
11809 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
11810 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
11811 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
11812 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
11814 char *salt_pos
= input_buf
+ 128;
11816 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
11817 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
11818 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
11819 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
11821 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11822 salt
->salt_len
= 16;
11824 return (PARSER_OK
);
11827 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11829 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11831 u32
*digest
= (u32
*) hash_buf
->digest
;
11833 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11834 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11835 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11836 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11837 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11838 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11839 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11840 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11842 digest
[0] -= SHA256M_A
;
11843 digest
[1] -= SHA256M_B
;
11844 digest
[2] -= SHA256M_C
;
11845 digest
[3] -= SHA256M_D
;
11846 digest
[4] -= SHA256M_E
;
11847 digest
[5] -= SHA256M_F
;
11848 digest
[6] -= SHA256M_G
;
11849 digest
[7] -= SHA256M_H
;
11851 return (PARSER_OK
);
11854 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11856 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11858 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11862 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11865 u32
*digest
= (u32
*) hash_buf
->digest
;
11867 salt_t
*salt
= hash_buf
->salt
;
11869 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11870 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11871 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11872 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11873 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11874 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11875 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11876 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11878 digest
[0] -= SHA256M_A
;
11879 digest
[1] -= SHA256M_B
;
11880 digest
[2] -= SHA256M_C
;
11881 digest
[3] -= SHA256M_D
;
11882 digest
[4] -= SHA256M_E
;
11883 digest
[5] -= SHA256M_F
;
11884 digest
[6] -= SHA256M_G
;
11885 digest
[7] -= SHA256M_H
;
11887 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11889 uint salt_len
= input_len
- 64 - 1;
11891 char *salt_buf
= input_buf
+ 64 + 1;
11893 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11895 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11897 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11899 salt
->salt_len
= salt_len
;
11901 return (PARSER_OK
);
11904 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11906 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11908 u64
*digest
= (u64
*) hash_buf
->digest
;
11910 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11911 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11912 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11913 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11914 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11915 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11919 digest
[0] -= SHA384M_A
;
11920 digest
[1] -= SHA384M_B
;
11921 digest
[2] -= SHA384M_C
;
11922 digest
[3] -= SHA384M_D
;
11923 digest
[4] -= SHA384M_E
;
11924 digest
[5] -= SHA384M_F
;
11928 return (PARSER_OK
);
11931 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11933 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
11935 u64
*digest
= (u64
*) hash_buf
->digest
;
11937 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11938 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11939 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11940 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11941 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11942 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11943 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11944 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11946 digest
[0] -= SHA512M_A
;
11947 digest
[1] -= SHA512M_B
;
11948 digest
[2] -= SHA512M_C
;
11949 digest
[3] -= SHA512M_D
;
11950 digest
[4] -= SHA512M_E
;
11951 digest
[5] -= SHA512M_F
;
11952 digest
[6] -= SHA512M_G
;
11953 digest
[7] -= SHA512M_H
;
11955 return (PARSER_OK
);
11958 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11960 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11962 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
11966 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
11969 u64
*digest
= (u64
*) hash_buf
->digest
;
11971 salt_t
*salt
= hash_buf
->salt
;
11973 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11974 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11975 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11976 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11977 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11978 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11979 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11980 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11982 digest
[0] -= SHA512M_A
;
11983 digest
[1] -= SHA512M_B
;
11984 digest
[2] -= SHA512M_C
;
11985 digest
[3] -= SHA512M_D
;
11986 digest
[4] -= SHA512M_E
;
11987 digest
[5] -= SHA512M_F
;
11988 digest
[6] -= SHA512M_G
;
11989 digest
[7] -= SHA512M_H
;
11991 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11993 uint salt_len
= input_len
- 128 - 1;
11995 char *salt_buf
= input_buf
+ 128 + 1;
11997 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11999 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12001 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12003 salt
->salt_len
= salt_len
;
12005 return (PARSER_OK
);
12008 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12010 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12012 u64
*digest
= (u64
*) hash_buf
->digest
;
12014 salt_t
*salt
= hash_buf
->salt
;
12016 char *salt_pos
= input_buf
+ 3;
12018 uint iterations_len
= 0;
12020 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12024 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12026 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12027 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12031 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12035 iterations_len
+= 8;
12039 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12042 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12044 char *hash_pos
= strchr (salt_pos
, '$');
12046 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12048 uint salt_len
= hash_pos
- salt_pos
;
12050 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12052 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12054 salt
->salt_len
= salt_len
;
12058 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12060 return (PARSER_OK
);
12063 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12065 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12067 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12069 u64
*digest
= (u64
*) hash_buf
->digest
;
12071 salt_t
*salt
= hash_buf
->salt
;
12073 uint keccak_mdlen
= input_len
/ 2;
12075 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12077 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12079 digest
[i
] = byte_swap_64 (digest
[i
]);
12082 salt
->keccak_mdlen
= keccak_mdlen
;
12084 return (PARSER_OK
);
12087 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12089 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12091 u32
*digest
= (u32
*) hash_buf
->digest
;
12093 salt_t
*salt
= hash_buf
->salt
;
12095 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12098 * Parse that strange long line
12105 in_off
[0] = strtok (input_buf
, ":");
12107 in_len
[0] = strlen (in_off
[0]);
12111 for (i
= 1; i
< 9; i
++)
12113 in_off
[i
] = strtok (NULL
, ":");
12115 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12117 in_len
[i
] = strlen (in_off
[i
]);
12122 ptr
= (char *) ikepsk
->msg_buf
;
12124 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12125 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12126 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12127 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12128 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12129 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12133 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12135 ptr
= (char *) ikepsk
->nr_buf
;
12137 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12138 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12142 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12145 * Store to database
12150 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12151 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12152 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12153 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12155 digest
[0] = byte_swap_32 (digest
[0]);
12156 digest
[1] = byte_swap_32 (digest
[1]);
12157 digest
[2] = byte_swap_32 (digest
[2]);
12158 digest
[3] = byte_swap_32 (digest
[3]);
12160 salt
->salt_len
= 32;
12162 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12163 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12164 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12165 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12166 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12167 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12168 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12169 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12171 return (PARSER_OK
);
12174 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12176 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12178 u32
*digest
= (u32
*) hash_buf
->digest
;
12180 salt_t
*salt
= hash_buf
->salt
;
12182 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12185 * Parse that strange long line
12192 in_off
[0] = strtok (input_buf
, ":");
12194 in_len
[0] = strlen (in_off
[0]);
12198 for (i
= 1; i
< 9; i
++)
12200 in_off
[i
] = strtok (NULL
, ":");
12202 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12204 in_len
[i
] = strlen (in_off
[i
]);
12209 ptr
= (char *) ikepsk
->msg_buf
;
12211 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12212 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12213 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12214 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12215 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12216 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12220 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12222 ptr
= (char *) ikepsk
->nr_buf
;
12224 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12225 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12229 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12232 * Store to database
12237 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12238 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12239 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12240 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12241 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12243 salt
->salt_len
= 32;
12245 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12246 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12247 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12248 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12249 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12250 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12251 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12252 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12254 return (PARSER_OK
);
12257 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12259 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12261 u32
*digest
= (u32
*) hash_buf
->digest
;
12263 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12264 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12265 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12266 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12267 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12269 digest
[0] = byte_swap_32 (digest
[0]);
12270 digest
[1] = byte_swap_32 (digest
[1]);
12271 digest
[2] = byte_swap_32 (digest
[2]);
12272 digest
[3] = byte_swap_32 (digest
[3]);
12273 digest
[4] = byte_swap_32 (digest
[4]);
12275 return (PARSER_OK
);
12278 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12280 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12282 u32
*digest
= (u32
*) hash_buf
->digest
;
12284 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12285 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12286 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12287 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12288 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12289 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12290 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12291 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12292 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12293 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12294 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12295 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12296 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12297 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12298 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12299 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12301 return (PARSER_OK
);
12304 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12306 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12308 u32
*digest
= (u32
*) hash_buf
->digest
;
12310 salt_t
*salt
= hash_buf
->salt
;
12312 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12313 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12314 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12315 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12316 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12318 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12320 uint salt_len
= input_len
- 40 - 1;
12322 char *salt_buf
= input_buf
+ 40 + 1;
12324 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12326 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12328 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12330 salt
->salt_len
= salt_len
;
12332 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12334 return (PARSER_OK
);
12337 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12339 u32
*digest
= (u32
*) hash_buf
->digest
;
12341 salt_t
*salt
= hash_buf
->salt
;
12343 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12345 if (input_len
== 0)
12347 log_error ("TrueCrypt container not specified");
12352 FILE *fp
= fopen (input_buf
, "rb");
12356 log_error ("%s: %s", input_buf
, strerror (errno
));
12363 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12367 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12369 memcpy (tc
->salt_buf
, buf
, 64);
12371 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12373 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12375 salt
->salt_len
= 4;
12377 salt
->salt_iter
= 1000 - 1;
12379 digest
[0] = tc
->data_buf
[0];
12381 return (PARSER_OK
);
12384 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12386 u32
*digest
= (u32
*) hash_buf
->digest
;
12388 salt_t
*salt
= hash_buf
->salt
;
12390 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12392 if (input_len
== 0)
12394 log_error ("TrueCrypt container not specified");
12399 FILE *fp
= fopen (input_buf
, "rb");
12403 log_error ("%s: %s", input_buf
, strerror (errno
));
12410 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12414 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12416 memcpy (tc
->salt_buf
, buf
, 64);
12418 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12420 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12422 salt
->salt_len
= 4;
12424 salt
->salt_iter
= 2000 - 1;
12426 digest
[0] = tc
->data_buf
[0];
12428 return (PARSER_OK
);
12431 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12433 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12435 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12437 u32
*digest
= (u32
*) hash_buf
->digest
;
12439 salt_t
*salt
= hash_buf
->salt
;
12441 char *salt_pos
= input_buf
+ 6;
12443 char *hash_pos
= strchr (salt_pos
, '$');
12445 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12447 uint salt_len
= hash_pos
- salt_pos
;
12449 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12451 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12453 salt
->salt_len
= salt_len
;
12455 salt
->salt_iter
= 1000;
12459 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12461 return (PARSER_OK
);
12464 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12466 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12468 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12470 u32
*digest
= (u32
*) hash_buf
->digest
;
12472 salt_t
*salt
= hash_buf
->salt
;
12474 char *iter_pos
= input_buf
+ 7;
12476 char *salt_pos
= strchr (iter_pos
, '$');
12478 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12482 char *hash_pos
= strchr (salt_pos
, '$');
12484 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12486 uint salt_len
= hash_pos
- salt_pos
;
12488 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12490 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12492 salt
->salt_len
= salt_len
;
12494 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12496 salt
->salt_sign
[0] = atoi (salt_iter
);
12498 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12502 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12504 digest
[0] = byte_swap_32 (digest
[0]);
12505 digest
[1] = byte_swap_32 (digest
[1]);
12506 digest
[2] = byte_swap_32 (digest
[2]);
12507 digest
[3] = byte_swap_32 (digest
[3]);
12508 digest
[4] = byte_swap_32 (digest
[4]);
12510 return (PARSER_OK
);
12513 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12515 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12517 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12519 u32
*digest
= (u32
*) hash_buf
->digest
;
12521 salt_t
*salt
= hash_buf
->salt
;
12523 char *iter_pos
= input_buf
+ 9;
12525 char *salt_pos
= strchr (iter_pos
, '$');
12527 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12531 char *hash_pos
= strchr (salt_pos
, '$');
12533 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12535 uint salt_len
= hash_pos
- salt_pos
;
12537 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12539 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12541 salt
->salt_len
= salt_len
;
12543 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12545 salt
->salt_sign
[0] = atoi (salt_iter
);
12547 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12551 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12553 digest
[0] = byte_swap_32 (digest
[0]);
12554 digest
[1] = byte_swap_32 (digest
[1]);
12555 digest
[2] = byte_swap_32 (digest
[2]);
12556 digest
[3] = byte_swap_32 (digest
[3]);
12557 digest
[4] = byte_swap_32 (digest
[4]);
12558 digest
[5] = byte_swap_32 (digest
[5]);
12559 digest
[6] = byte_swap_32 (digest
[6]);
12560 digest
[7] = byte_swap_32 (digest
[7]);
12562 return (PARSER_OK
);
12565 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12567 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12569 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12571 u64
*digest
= (u64
*) hash_buf
->digest
;
12573 salt_t
*salt
= hash_buf
->salt
;
12575 char *iter_pos
= input_buf
+ 9;
12577 char *salt_pos
= strchr (iter_pos
, '$');
12579 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12583 char *hash_pos
= strchr (salt_pos
, '$');
12585 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12587 uint salt_len
= hash_pos
- salt_pos
;
12589 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12591 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12593 salt
->salt_len
= salt_len
;
12595 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12597 salt
->salt_sign
[0] = atoi (salt_iter
);
12599 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12603 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12605 digest
[0] = byte_swap_64 (digest
[0]);
12606 digest
[1] = byte_swap_64 (digest
[1]);
12607 digest
[2] = byte_swap_64 (digest
[2]);
12608 digest
[3] = byte_swap_64 (digest
[3]);
12609 digest
[4] = byte_swap_64 (digest
[4]);
12610 digest
[5] = byte_swap_64 (digest
[5]);
12611 digest
[6] = byte_swap_64 (digest
[6]);
12612 digest
[7] = byte_swap_64 (digest
[7]);
12614 return (PARSER_OK
);
12617 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12619 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12621 u32
*digest
= (u32
*) hash_buf
->digest
;
12623 salt_t
*salt
= hash_buf
->salt
;
12625 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12631 char *iterations_pos
= input_buf
;
12633 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12635 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12637 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12639 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12643 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12645 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12647 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12649 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12651 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12653 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12658 * pbkdf2 iterations
12661 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12664 * handle salt encoding
12667 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12669 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12671 const char p0
= saltbuf_pos
[i
+ 0];
12672 const char p1
= saltbuf_pos
[i
+ 1];
12674 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12675 | hex_convert (p0
) << 4;
12678 salt
->salt_len
= saltbuf_len
/ 2;
12681 * handle cipher encoding
12684 uint
*tmp
= (uint
*) mymalloc (32);
12686 char *cipherbuf_ptr
= (char *) tmp
;
12688 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12690 const char p0
= cipherbuf_pos
[i
+ 0];
12691 const char p1
= cipherbuf_pos
[i
+ 1];
12693 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12694 | hex_convert (p0
) << 4;
12697 // iv is stored at salt_buf 4 (length 16)
12698 // data is stored at salt_buf 8 (length 16)
12700 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12701 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12702 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12703 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12705 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12706 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12707 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12708 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12712 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12714 const char p0
= cipherbuf_pos
[j
+ 0];
12715 const char p1
= cipherbuf_pos
[j
+ 1];
12717 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12718 | hex_convert (p0
) << 4;
12725 digest
[0] = 0x10101010;
12726 digest
[1] = 0x10101010;
12727 digest
[2] = 0x10101010;
12728 digest
[3] = 0x10101010;
12730 return (PARSER_OK
);
12733 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12735 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12737 u32
*digest
= (u32
*) hash_buf
->digest
;
12739 salt_t
*salt
= hash_buf
->salt
;
12741 char *hashbuf_pos
= input_buf
;
12743 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12745 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12747 uint hash_len
= iterations_pos
- hashbuf_pos
;
12749 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12753 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12755 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12757 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12761 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12763 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12765 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12767 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12769 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12771 salt
->salt_len
= salt_len
;
12773 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12775 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
12776 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
12777 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
12778 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
12780 return (PARSER_OK
);
12783 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12785 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12787 u32
*digest
= (u32
*) hash_buf
->digest
;
12789 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12790 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12791 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12792 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12793 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12794 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12795 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12796 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12798 digest
[0] = byte_swap_32 (digest
[0]);
12799 digest
[1] = byte_swap_32 (digest
[1]);
12800 digest
[2] = byte_swap_32 (digest
[2]);
12801 digest
[3] = byte_swap_32 (digest
[3]);
12802 digest
[4] = byte_swap_32 (digest
[4]);
12803 digest
[5] = byte_swap_32 (digest
[5]);
12804 digest
[6] = byte_swap_32 (digest
[6]);
12805 digest
[7] = byte_swap_32 (digest
[7]);
12807 return (PARSER_OK
);
12810 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12812 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12814 u32
*digest
= (u32
*) hash_buf
->digest
;
12816 salt_t
*salt
= hash_buf
->salt
;
12818 char *salt_pos
= input_buf
+ 3;
12820 uint iterations_len
= 0;
12822 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12826 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12828 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12829 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12833 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12837 iterations_len
+= 8;
12841 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12844 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12846 char *hash_pos
= strchr (salt_pos
, '$');
12848 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12850 uint salt_len
= hash_pos
- salt_pos
;
12852 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12854 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12856 salt
->salt_len
= salt_len
;
12860 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12862 return (PARSER_OK
);
12865 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12867 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12869 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12871 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12873 u64
*digest
= (u64
*) hash_buf
->digest
;
12875 salt_t
*salt
= hash_buf
->salt
;
12877 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12879 char *iter_pos
= input_buf
+ 4;
12881 char *salt_pos
= strchr (iter_pos
, '$');
12883 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12887 char *hash_pos
= strchr (salt_pos
, '$');
12889 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12891 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12895 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12896 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12897 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12898 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12899 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12900 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12901 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12902 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12904 uint salt_len
= hash_pos
- salt_pos
- 1;
12906 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12908 salt
->salt_len
= salt_len
/ 2;
12910 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12911 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12912 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12913 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12914 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
12915 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
12916 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
12917 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
12919 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12920 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12921 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12922 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12923 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12924 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12925 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12926 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12927 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12928 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12930 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12932 salt
->salt_iter
= atoi (iter_pos
) - 1;
12934 return (PARSER_OK
);
12937 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12939 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12941 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12943 u32
*digest
= (u32
*) hash_buf
->digest
;
12945 salt_t
*salt
= hash_buf
->salt
;
12947 char *salt_pos
= input_buf
+ 14;
12949 char *hash_pos
= strchr (salt_pos
, '*');
12951 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12955 uint salt_len
= hash_pos
- salt_pos
- 1;
12957 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12959 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
12961 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12963 salt
->salt_len
= salt_len
;
12967 memset (tmp_buf
, 0, sizeof (tmp_buf
));
12969 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
12971 memcpy (digest
, tmp_buf
, 32);
12973 digest
[0] = byte_swap_32 (digest
[0]);
12974 digest
[1] = byte_swap_32 (digest
[1]);
12975 digest
[2] = byte_swap_32 (digest
[2]);
12976 digest
[3] = byte_swap_32 (digest
[3]);
12977 digest
[4] = byte_swap_32 (digest
[4]);
12978 digest
[5] = byte_swap_32 (digest
[5]);
12979 digest
[6] = byte_swap_32 (digest
[6]);
12980 digest
[7] = byte_swap_32 (digest
[7]);
12982 digest
[0] -= SHA256M_A
;
12983 digest
[1] -= SHA256M_B
;
12984 digest
[2] -= SHA256M_C
;
12985 digest
[3] -= SHA256M_D
;
12986 digest
[4] -= SHA256M_E
;
12987 digest
[5] -= SHA256M_F
;
12988 digest
[6] -= SHA256M_G
;
12989 digest
[7] -= SHA256M_H
;
12991 return (PARSER_OK
);
12994 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12996 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
12998 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13000 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13002 u64
*digest
= (u64
*) hash_buf
->digest
;
13004 salt_t
*salt
= hash_buf
->salt
;
13006 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13008 char *iter_pos
= input_buf
+ 19;
13010 char *salt_pos
= strchr (iter_pos
, '.');
13012 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13016 char *hash_pos
= strchr (salt_pos
, '.');
13018 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13020 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13024 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13025 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13026 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13027 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13028 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13029 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13030 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13031 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13033 uint salt_len
= hash_pos
- salt_pos
- 1;
13037 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13041 for (i
= 0; i
< salt_len
; i
++)
13043 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13046 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13047 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13049 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13051 salt
->salt_len
= salt_len
;
13053 salt
->salt_iter
= atoi (iter_pos
) - 1;
13055 return (PARSER_OK
);
13058 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13060 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13062 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13064 u64
*digest
= (u64
*) hash_buf
->digest
;
13066 salt_t
*salt
= hash_buf
->salt
;
13070 memset (tmp_buf
, 0, sizeof (tmp_buf
));
13072 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13074 memcpy (digest
, tmp_buf
, 64);
13076 digest
[0] = byte_swap_64 (digest
[0]);
13077 digest
[1] = byte_swap_64 (digest
[1]);
13078 digest
[2] = byte_swap_64 (digest
[2]);
13079 digest
[3] = byte_swap_64 (digest
[3]);
13080 digest
[4] = byte_swap_64 (digest
[4]);
13081 digest
[5] = byte_swap_64 (digest
[5]);
13082 digest
[6] = byte_swap_64 (digest
[6]);
13083 digest
[7] = byte_swap_64 (digest
[7]);
13085 digest
[0] -= SHA512M_A
;
13086 digest
[1] -= SHA512M_B
;
13087 digest
[2] -= SHA512M_C
;
13088 digest
[3] -= SHA512M_D
;
13089 digest
[4] -= SHA512M_E
;
13090 digest
[5] -= SHA512M_F
;
13091 digest
[6] -= SHA512M_G
;
13092 digest
[7] -= SHA512M_H
;
13094 salt
->salt_len
= tmp_len
- 64;
13096 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13098 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13100 char *ptr
= (char *) salt
->salt_buf
;
13102 ptr
[salt
->salt_len
] = 0x80;
13105 return (PARSER_OK
);
13108 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13110 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13112 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13116 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13119 u32
*digest
= (u32
*) hash_buf
->digest
;
13121 salt_t
*salt
= hash_buf
->salt
;
13123 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13124 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13125 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13126 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13128 digest
[0] = byte_swap_32 (digest
[0]);
13129 digest
[1] = byte_swap_32 (digest
[1]);
13130 digest
[2] = byte_swap_32 (digest
[2]);
13131 digest
[3] = byte_swap_32 (digest
[3]);
13133 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13135 uint salt_len
= input_len
- 32 - 1;
13137 char *salt_buf
= input_buf
+ 32 + 1;
13139 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13141 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13143 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13145 salt
->salt_len
= salt_len
;
13147 return (PARSER_OK
);
13150 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13152 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13154 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13158 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13161 u32
*digest
= (u32
*) hash_buf
->digest
;
13163 salt_t
*salt
= hash_buf
->salt
;
13165 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13166 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13167 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13168 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13169 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13171 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13173 uint salt_len
= input_len
- 40 - 1;
13175 char *salt_buf
= input_buf
+ 40 + 1;
13177 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13179 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13181 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13183 salt
->salt_len
= salt_len
;
13185 return (PARSER_OK
);
13188 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13190 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13192 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13196 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13199 u32
*digest
= (u32
*) hash_buf
->digest
;
13201 salt_t
*salt
= hash_buf
->salt
;
13203 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13204 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13205 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13206 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13207 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13208 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13209 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13210 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13212 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13214 uint salt_len
= input_len
- 64 - 1;
13216 char *salt_buf
= input_buf
+ 64 + 1;
13218 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13220 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13222 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13224 salt
->salt_len
= salt_len
;
13226 return (PARSER_OK
);
13229 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13231 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13233 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13237 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13240 u64
*digest
= (u64
*) hash_buf
->digest
;
13242 salt_t
*salt
= hash_buf
->salt
;
13244 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13245 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13246 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13247 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13248 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13249 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13250 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13251 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13253 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13255 uint salt_len
= input_len
- 128 - 1;
13257 char *salt_buf
= input_buf
+ 128 + 1;
13259 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13261 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13263 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13265 salt
->salt_len
= salt_len
;
13267 return (PARSER_OK
);
13270 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13272 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13274 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13276 u32
*digest
= (u32
*) hash_buf
->digest
;
13278 salt_t
*salt
= hash_buf
->salt
;
13280 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13286 char *user_pos
= input_buf
+ 10 + 1;
13288 char *realm_pos
= strchr (user_pos
, '$');
13290 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13292 uint user_len
= realm_pos
- user_pos
;
13294 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13298 char *salt_pos
= strchr (realm_pos
, '$');
13300 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13302 uint realm_len
= salt_pos
- realm_pos
;
13304 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13308 char *data_pos
= strchr (salt_pos
, '$');
13310 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13312 uint salt_len
= data_pos
- salt_pos
;
13314 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13318 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13320 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13326 memcpy (krb5pa
->user
, user_pos
, user_len
);
13327 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13328 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13330 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13332 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13334 const char p0
= data_pos
[i
+ 0];
13335 const char p1
= data_pos
[i
+ 1];
13337 *timestamp_ptr
++ = hex_convert (p1
) << 0
13338 | hex_convert (p0
) << 4;
13341 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13343 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13345 const char p0
= data_pos
[i
+ 0];
13346 const char p1
= data_pos
[i
+ 1];
13348 *checksum_ptr
++ = hex_convert (p1
) << 0
13349 | hex_convert (p0
) << 4;
13353 * copy some data to generic buffers to make sorting happy
13356 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13357 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13358 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13359 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13360 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13361 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13362 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13363 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13364 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13366 salt
->salt_len
= 36;
13368 digest
[0] = krb5pa
->checksum
[0];
13369 digest
[1] = krb5pa
->checksum
[1];
13370 digest
[2] = krb5pa
->checksum
[2];
13371 digest
[3] = krb5pa
->checksum
[3];
13373 return (PARSER_OK
);
13376 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13378 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13380 u32
*digest
= (u32
*) hash_buf
->digest
;
13382 salt_t
*salt
= hash_buf
->salt
;
13388 char *salt_pos
= input_buf
;
13390 char *hash_pos
= strchr (salt_pos
, '$');
13392 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13394 uint salt_len
= hash_pos
- salt_pos
;
13396 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13400 uint hash_len
= input_len
- 1 - salt_len
;
13402 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13410 for (uint i
= 0; i
< salt_len
; i
++)
13412 if (salt_pos
[i
] == ' ') continue;
13417 // SAP user names cannot be longer than 12 characters
13418 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13420 // SAP user name cannot start with ! or ?
13421 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13427 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13429 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13431 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13433 salt
->salt_len
= salt_len
;
13435 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13436 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13440 digest
[0] = byte_swap_32 (digest
[0]);
13441 digest
[1] = byte_swap_32 (digest
[1]);
13443 return (PARSER_OK
);
13446 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13448 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13450 u32
*digest
= (u32
*) hash_buf
->digest
;
13452 salt_t
*salt
= hash_buf
->salt
;
13458 char *salt_pos
= input_buf
;
13460 char *hash_pos
= strchr (salt_pos
, '$');
13462 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13464 uint salt_len
= hash_pos
- salt_pos
;
13466 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13470 uint hash_len
= input_len
- 1 - salt_len
;
13472 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13480 for (uint i
= 0; i
< salt_len
; i
++)
13482 if (salt_pos
[i
] == ' ') continue;
13487 // SAP user names cannot be longer than 12 characters
13488 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13489 // so far nobody complained so we stay with this because it helps in optimization
13490 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13492 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13494 // SAP user name cannot start with ! or ?
13495 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13501 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13503 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13505 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13507 salt
->salt_len
= salt_len
;
13509 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13510 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13511 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13512 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13513 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13515 return (PARSER_OK
);
13518 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13520 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13522 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13524 u64
*digest
= (u64
*) hash_buf
->digest
;
13526 salt_t
*salt
= hash_buf
->salt
;
13528 char *iter_pos
= input_buf
+ 3;
13530 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13532 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13534 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13536 salt
->salt_iter
= salt_iter
;
13538 char *salt_pos
= iter_pos
+ 1;
13542 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13544 salt
->salt_len
= salt_len
;
13546 char *hash_pos
= salt_pos
+ salt_len
;
13548 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13552 char *tmp
= (char *) salt
->salt_buf_pc
;
13554 tmp
[0] = hash_pos
[42];
13558 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13559 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13560 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13561 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13567 return (PARSER_OK
);
13570 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13572 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13574 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13576 u32
*digest
= (u32
*) hash_buf
->digest
;
13578 salt_t
*salt
= hash_buf
->salt
;
13580 char *salt_buf
= input_buf
+ 6;
13582 uint salt_len
= 16;
13584 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13586 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13588 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13590 salt
->salt_len
= salt_len
;
13592 char *hash_pos
= input_buf
+ 6 + 16;
13594 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13595 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13596 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13597 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13598 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13599 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13600 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13601 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13603 return (PARSER_OK
);
13606 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13608 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13610 u32
*digest
= (u32
*) hash_buf
->digest
;
13612 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13613 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13617 return (PARSER_OK
);
13620 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13622 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13624 u32
*digest
= (u32
*) hash_buf
->digest
;
13626 salt_t
*salt
= hash_buf
->salt
;
13628 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13630 char *saltbuf_pos
= input_buf
;
13632 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13634 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13636 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13638 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13639 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13641 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13645 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13647 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13649 char *salt_ptr
= (char *) saltbuf_pos
;
13650 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13655 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13657 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13660 rakp_ptr
[j
] = 0x80;
13662 rakp
->salt_len
= j
;
13664 for (i
= 0; i
< 64; i
++)
13666 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13669 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13670 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13671 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13672 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13673 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13674 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13675 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13676 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13678 salt
->salt_len
= 32; // muss min. 32 haben
13680 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13681 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13682 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13683 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13684 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13686 return (PARSER_OK
);
13689 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13691 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13693 u32
*digest
= (u32
*) hash_buf
->digest
;
13695 salt_t
*salt
= hash_buf
->salt
;
13697 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13699 char *salt_pos
= input_buf
+ 1;
13701 memcpy (salt
->salt_buf
, salt_pos
, 8);
13703 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13704 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13706 salt
->salt_len
= 8;
13708 char *hash_pos
= salt_pos
+ 8;
13710 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13711 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13712 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13713 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13714 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13716 digest
[0] -= SHA1M_A
;
13717 digest
[1] -= SHA1M_B
;
13718 digest
[2] -= SHA1M_C
;
13719 digest
[3] -= SHA1M_D
;
13720 digest
[4] -= SHA1M_E
;
13722 return (PARSER_OK
);
13725 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13727 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13729 u32
*digest
= (u32
*) hash_buf
->digest
;
13731 salt_t
*salt
= hash_buf
->salt
;
13733 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13734 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13735 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13736 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13738 digest
[0] = byte_swap_32 (digest
[0]);
13739 digest
[1] = byte_swap_32 (digest
[1]);
13740 digest
[2] = byte_swap_32 (digest
[2]);
13741 digest
[3] = byte_swap_32 (digest
[3]);
13743 digest
[0] -= MD5M_A
;
13744 digest
[1] -= MD5M_B
;
13745 digest
[2] -= MD5M_C
;
13746 digest
[3] -= MD5M_D
;
13748 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13750 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13752 u32
*salt_buf
= salt
->salt_buf
;
13754 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
13755 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
13756 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
13757 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
13759 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13760 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13761 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13762 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13764 salt
->salt_len
= 16 + 1;
13766 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13768 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13770 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
13772 return (PARSER_OK
);
13775 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13777 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13779 u32
*digest
= (u32
*) hash_buf
->digest
;
13781 salt_t
*salt
= hash_buf
->salt
;
13783 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13789 char *hashbuf_pos
= input_buf
;
13791 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13793 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13795 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13797 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13801 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13803 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13805 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13807 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13811 char *databuf_pos
= strchr (iteration_pos
, ':');
13813 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13815 const uint iteration_len
= databuf_pos
- iteration_pos
;
13817 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13818 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13820 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13822 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13823 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13829 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13830 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13831 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13832 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13833 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13834 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
13835 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
13836 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
13840 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13842 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13844 const char p0
= saltbuf_pos
[i
+ 0];
13845 const char p1
= saltbuf_pos
[i
+ 1];
13847 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13848 | hex_convert (p0
) << 4;
13851 salt
->salt_buf
[4] = 0x01000000;
13852 salt
->salt_buf
[5] = 0x80;
13854 salt
->salt_len
= saltbuf_len
/ 2;
13858 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13862 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13864 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13866 const char p0
= databuf_pos
[i
+ 0];
13867 const char p1
= databuf_pos
[i
+ 1];
13869 *databuf_ptr
++ = hex_convert (p1
) << 0
13870 | hex_convert (p0
) << 4;
13873 *databuf_ptr
++ = 0x80;
13875 for (uint i
= 0; i
< 512; i
++)
13877 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13880 cloudkey
->data_len
= databuf_len
/ 2;
13882 return (PARSER_OK
);
13885 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13887 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13889 u32
*digest
= (u32
*) hash_buf
->digest
;
13891 salt_t
*salt
= hash_buf
->salt
;
13897 char *hashbuf_pos
= input_buf
;
13899 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13901 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13903 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13905 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13909 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13911 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13913 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13915 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13917 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13921 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13923 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13925 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13927 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13929 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13933 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13935 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13936 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13938 // ok, the plan for this algorithm is the following:
13939 // we have 2 salts here, the domain-name and a random salt
13940 // while both are used in the initial transformation,
13941 // only the random salt is used in the following iterations
13942 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13943 // and one that includes only the real salt (stored into salt_buf[]).
13944 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13948 memset (tmp_buf
, 0, sizeof (tmp_buf
));
13950 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
13952 memcpy (digest
, tmp_buf
, 20);
13954 digest
[0] = byte_swap_32 (digest
[0]);
13955 digest
[1] = byte_swap_32 (digest
[1]);
13956 digest
[2] = byte_swap_32 (digest
[2]);
13957 digest
[3] = byte_swap_32 (digest
[3]);
13958 digest
[4] = byte_swap_32 (digest
[4]);
13962 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13964 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
13966 char *len_ptr
= NULL
;
13968 for (uint i
= 0; i
< domainbuf_len
; i
++)
13970 if (salt_buf_pc_ptr
[i
] == '.')
13972 len_ptr
= &salt_buf_pc_ptr
[i
];
13982 salt
->salt_buf_pc
[7] = domainbuf_len
;
13986 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13988 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
13990 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13992 salt
->salt_len
= salt_len
;
13996 salt
->salt_iter
= atoi (iteration_pos
);
13998 return (PARSER_OK
);
14001 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14003 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14005 u32
*digest
= (u32
*) hash_buf
->digest
;
14007 salt_t
*salt
= hash_buf
->salt
;
14009 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14010 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14011 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14012 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14013 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14015 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14017 uint salt_len
= input_len
- 40 - 1;
14019 char *salt_buf
= input_buf
+ 40 + 1;
14021 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14023 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14025 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14027 salt
->salt_len
= salt_len
;
14029 return (PARSER_OK
);
14032 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14034 const u8 ascii_to_ebcdic
[] =
14036 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14037 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14038 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14039 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14040 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14041 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14042 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14043 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14044 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14045 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14046 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14047 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14048 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14049 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14050 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14051 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14054 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14056 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14058 u32
*digest
= (u32
*) hash_buf
->digest
;
14060 salt_t
*salt
= hash_buf
->salt
;
14062 char *salt_pos
= input_buf
+ 6 + 1;
14064 char *digest_pos
= strchr (salt_pos
, '*');
14066 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14068 uint salt_len
= digest_pos
- salt_pos
;
14070 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14072 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14074 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14078 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14079 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14081 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14083 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14085 salt
->salt_len
= salt_len
;
14087 for (uint i
= 0; i
< salt_len
; i
++)
14089 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14091 for (uint i
= salt_len
; i
< 8; i
++)
14093 salt_buf_pc_ptr
[i
] = 0x40;
14098 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14100 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14101 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14103 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14104 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14106 digest
[0] = byte_swap_32 (digest
[0]);
14107 digest
[1] = byte_swap_32 (digest
[1]);
14109 IP (digest
[0], digest
[1], tt
);
14111 digest
[0] = rotr32 (digest
[0], 29);
14112 digest
[1] = rotr32 (digest
[1], 29);
14116 return (PARSER_OK
);
14119 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14121 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14123 u32
*digest
= (u32
*) hash_buf
->digest
;
14125 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14126 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14127 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14128 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14130 digest
[0] = byte_swap_32 (digest
[0]);
14131 digest
[1] = byte_swap_32 (digest
[1]);
14132 digest
[2] = byte_swap_32 (digest
[2]);
14133 digest
[3] = byte_swap_32 (digest
[3]);
14135 return (PARSER_OK
);
14138 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14140 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14142 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14144 u32
*digest
= (u32
*) hash_buf
->digest
;
14146 salt_t
*salt
= hash_buf
->salt
;
14150 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14152 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14154 tmp_buf
[3] += -4; // dont ask!
14156 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14158 salt
->salt_len
= 5;
14160 memcpy (digest
, tmp_buf
+ 5, 9);
14162 // yes, only 9 byte are needed to crack, but 10 to display
14164 salt
->salt_buf_pc
[7] = input_buf
[20];
14166 return (PARSER_OK
);
14169 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14171 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14173 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14175 u32
*digest
= (u32
*) hash_buf
->digest
;
14177 salt_t
*salt
= hash_buf
->salt
;
14181 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14183 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14185 tmp_buf
[3] += -4; // dont ask!
14189 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14191 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)
14195 char tmp_iter_buf
[11];
14197 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14199 tmp_iter_buf
[10] = 0;
14201 salt
->salt_iter
= atoi (tmp_iter_buf
);
14203 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14205 return (PARSER_SALT_ITERATION
);
14208 salt
->salt_iter
--; // first round in init
14210 // 2 additional bytes for display only
14212 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14213 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14217 memcpy (digest
, tmp_buf
+ 28, 8);
14219 digest
[0] = byte_swap_32 (digest
[0]);
14220 digest
[1] = byte_swap_32 (digest
[1]);
14224 return (PARSER_OK
);
14227 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14229 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14231 u32
*digest
= (u32
*) hash_buf
->digest
;
14233 salt_t
*salt
= hash_buf
->salt
;
14235 char *salt_buf_pos
= input_buf
;
14237 char *hash_buf_pos
= salt_buf_pos
+ 6;
14239 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14240 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14241 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14242 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14243 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14244 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14245 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14246 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14248 digest
[0] -= SHA256M_A
;
14249 digest
[1] -= SHA256M_B
;
14250 digest
[2] -= SHA256M_C
;
14251 digest
[3] -= SHA256M_D
;
14252 digest
[4] -= SHA256M_E
;
14253 digest
[5] -= SHA256M_F
;
14254 digest
[6] -= SHA256M_G
;
14255 digest
[7] -= SHA256M_H
;
14257 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14259 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14261 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14263 salt
->salt_len
= salt_len
;
14265 return (PARSER_OK
);
14268 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14270 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14272 u32
*digest
= (u32
*) hash_buf
->digest
;
14274 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14276 salt_t
*salt
= hash_buf
->salt
;
14278 char *salt_buf
= input_buf
+ 6;
14280 char *digest_buf
= strchr (salt_buf
, '$');
14282 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14284 uint salt_len
= digest_buf
- salt_buf
;
14286 digest_buf
++; // skip the '$' symbol
14288 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14290 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14292 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14294 salt
->salt_len
= salt_len
;
14296 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14297 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14298 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14299 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14301 digest
[0] = byte_swap_32 (digest
[0]);
14302 digest
[1] = byte_swap_32 (digest
[1]);
14303 digest
[2] = byte_swap_32 (digest
[2]);
14304 digest
[3] = byte_swap_32 (digest
[3]);
14306 digest
[0] -= MD5M_A
;
14307 digest
[1] -= MD5M_B
;
14308 digest
[2] -= MD5M_C
;
14309 digest
[3] -= MD5M_D
;
14311 return (PARSER_OK
);
14314 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14316 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14318 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14320 u32
*digest
= (u32
*) hash_buf
->digest
;
14322 salt_t
*salt
= hash_buf
->salt
;
14324 char *salt_buf
= input_buf
+ 3;
14326 char *digest_buf
= strchr (salt_buf
, '$');
14328 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14330 uint salt_len
= digest_buf
- salt_buf
;
14332 digest_buf
++; // skip the '$' symbol
14334 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14336 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14338 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14340 salt_buf_ptr
[salt_len
] = 0x2d;
14342 salt
->salt_len
= salt_len
+ 1;
14344 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14345 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14346 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14347 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14349 digest
[0] = byte_swap_32 (digest
[0]);
14350 digest
[1] = byte_swap_32 (digest
[1]);
14351 digest
[2] = byte_swap_32 (digest
[2]);
14352 digest
[3] = byte_swap_32 (digest
[3]);
14354 digest
[0] -= MD5M_A
;
14355 digest
[1] -= MD5M_B
;
14356 digest
[2] -= MD5M_C
;
14357 digest
[3] -= MD5M_D
;
14359 return (PARSER_OK
);
14362 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14364 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14366 u32
*digest
= (u32
*) hash_buf
->digest
;
14370 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14372 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14374 memcpy (digest
, tmp_buf
, 20);
14376 digest
[0] = byte_swap_32 (digest
[0]);
14377 digest
[1] = byte_swap_32 (digest
[1]);
14378 digest
[2] = byte_swap_32 (digest
[2]);
14379 digest
[3] = byte_swap_32 (digest
[3]);
14380 digest
[4] = byte_swap_32 (digest
[4]);
14382 digest
[0] -= SHA1M_A
;
14383 digest
[1] -= SHA1M_B
;
14384 digest
[2] -= SHA1M_C
;
14385 digest
[3] -= SHA1M_D
;
14386 digest
[4] -= SHA1M_E
;
14388 return (PARSER_OK
);
14391 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14393 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14395 u32
*digest
= (u32
*) hash_buf
->digest
;
14397 salt_t
*salt
= hash_buf
->salt
;
14399 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14400 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14401 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14402 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14404 digest
[0] = byte_swap_32 (digest
[0]);
14405 digest
[1] = byte_swap_32 (digest
[1]);
14406 digest
[2] = byte_swap_32 (digest
[2]);
14407 digest
[3] = byte_swap_32 (digest
[3]);
14409 digest
[0] -= MD5M_A
;
14410 digest
[1] -= MD5M_B
;
14411 digest
[2] -= MD5M_C
;
14412 digest
[3] -= MD5M_D
;
14414 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14416 uint salt_len
= input_len
- 32 - 1;
14418 char *salt_buf
= input_buf
+ 32 + 1;
14420 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14422 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14424 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14427 * add static "salt" part
14430 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14434 salt
->salt_len
= salt_len
;
14436 return (PARSER_OK
);
14439 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14441 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14443 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14445 u32
*digest
= (u32
*) hash_buf
->digest
;
14447 salt_t
*salt
= hash_buf
->salt
;
14449 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14455 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14457 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14459 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14461 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14463 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14467 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14469 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14471 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14473 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14477 char *keybuf_pos
= strchr (keylen_pos
, '$');
14479 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14481 uint keylen_len
= keybuf_pos
- keylen_pos
;
14483 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14487 char *databuf_pos
= strchr (keybuf_pos
, '$');
14489 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14491 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14493 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14497 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14499 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14505 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14506 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14507 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14508 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14510 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14511 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14512 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14513 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14515 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14516 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14517 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14518 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14520 salt
->salt_len
= 16;
14521 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14523 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14525 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14528 return (PARSER_OK
);
14531 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14533 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14535 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14537 u32
*digest
= (u32
*) hash_buf
->digest
;
14539 salt_t
*salt
= hash_buf
->salt
;
14545 // first is the N salt parameter
14547 char *N_pos
= input_buf
+ 6;
14549 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14553 salt
->scrypt_N
= atoi (N_pos
);
14557 char *r_pos
= strchr (N_pos
, ':');
14559 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14563 salt
->scrypt_r
= atoi (r_pos
);
14567 char *p_pos
= strchr (r_pos
, ':');
14569 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14573 salt
->scrypt_p
= atoi (p_pos
);
14577 char *saltbuf_pos
= strchr (p_pos
, ':');
14579 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14583 char *hash_pos
= strchr (saltbuf_pos
, ':');
14585 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14593 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14595 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14597 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14599 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14601 salt
->salt_len
= tmp_len
;
14602 salt
->salt_iter
= 1;
14604 // digest - base64 decode
14606 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14608 tmp_len
= input_len
- (hash_pos
- input_buf
);
14610 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14612 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14614 memcpy (digest
, tmp_buf
, 32);
14616 return (PARSER_OK
);
14619 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14621 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14623 u32
*digest
= (u32
*) hash_buf
->digest
;
14625 salt_t
*salt
= hash_buf
->salt
;
14631 char decrypted
[76]; // iv + hash
14633 juniper_decrypt_hash (input_buf
, decrypted
);
14635 char *md5crypt_hash
= decrypted
+ 12;
14637 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14639 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14641 char *salt_pos
= md5crypt_hash
+ 3;
14643 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14645 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14647 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14651 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14653 return (PARSER_OK
);
14656 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14658 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14660 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14662 u32
*digest
= (u32
*) hash_buf
->digest
;
14664 salt_t
*salt
= hash_buf
->salt
;
14666 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14672 // first is *raw* salt
14674 char *salt_pos
= input_buf
+ 3;
14676 char *hash_pos
= strchr (salt_pos
, '$');
14678 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14680 uint salt_len
= hash_pos
- salt_pos
;
14682 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14686 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14688 memcpy (salt_buf_ptr
, salt_pos
, 14);
14690 salt_buf_ptr
[17] = 0x01;
14691 salt_buf_ptr
[18] = 0x80;
14693 // add some stuff to normal salt to make sorted happy
14695 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14696 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14697 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14698 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14700 salt
->salt_len
= salt_len
;
14701 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14703 // base64 decode hash
14707 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14709 uint hash_len
= input_len
- 3 - salt_len
- 1;
14711 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14713 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14715 memcpy (digest
, tmp_buf
, 32);
14717 digest
[0] = byte_swap_32 (digest
[0]);
14718 digest
[1] = byte_swap_32 (digest
[1]);
14719 digest
[2] = byte_swap_32 (digest
[2]);
14720 digest
[3] = byte_swap_32 (digest
[3]);
14721 digest
[4] = byte_swap_32 (digest
[4]);
14722 digest
[5] = byte_swap_32 (digest
[5]);
14723 digest
[6] = byte_swap_32 (digest
[6]);
14724 digest
[7] = byte_swap_32 (digest
[7]);
14726 return (PARSER_OK
);
14729 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14731 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14733 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14735 u32
*digest
= (u32
*) hash_buf
->digest
;
14737 salt_t
*salt
= hash_buf
->salt
;
14743 // first is *raw* salt
14745 char *salt_pos
= input_buf
+ 3;
14747 char *hash_pos
= strchr (salt_pos
, '$');
14749 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14751 uint salt_len
= hash_pos
- salt_pos
;
14753 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14755 salt
->salt_len
= salt_len
;
14758 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14760 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14761 salt_buf_ptr
[salt_len
] = 0;
14763 // base64 decode hash
14767 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14769 uint hash_len
= input_len
- 3 - salt_len
- 1;
14771 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14773 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14775 memcpy (digest
, tmp_buf
, 32);
14778 salt
->scrypt_N
= 16384;
14779 salt
->scrypt_r
= 1;
14780 salt
->scrypt_p
= 1;
14781 salt
->salt_iter
= 1;
14783 return (PARSER_OK
);
14786 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14788 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14790 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14792 u32
*digest
= (u32
*) hash_buf
->digest
;
14794 salt_t
*salt
= hash_buf
->salt
;
14796 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14802 char *version_pos
= input_buf
+ 8 + 1;
14804 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14806 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14808 u32 version_len
= verifierHashSize_pos
- version_pos
;
14810 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14812 verifierHashSize_pos
++;
14814 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14816 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14818 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14820 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14824 char *saltSize_pos
= strchr (keySize_pos
, '*');
14826 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14828 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14830 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14834 char *osalt_pos
= strchr (saltSize_pos
, '*');
14836 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14838 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14840 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14844 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14846 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14848 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14850 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14852 encryptedVerifier_pos
++;
14854 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14856 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14858 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14860 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14862 encryptedVerifierHash_pos
++;
14864 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;
14866 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14868 const uint version
= atoi (version_pos
);
14870 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14872 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14874 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14876 const uint keySize
= atoi (keySize_pos
);
14878 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14880 office2007
->keySize
= keySize
;
14882 const uint saltSize
= atoi (saltSize_pos
);
14884 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14890 salt
->salt_len
= 16;
14891 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14893 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
14894 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
14895 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
14896 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
14902 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
14903 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
14904 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
14905 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
14907 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
14908 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
14909 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
14910 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
14911 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
14917 digest
[0] = office2007
->encryptedVerifierHash
[0];
14918 digest
[1] = office2007
->encryptedVerifierHash
[1];
14919 digest
[2] = office2007
->encryptedVerifierHash
[2];
14920 digest
[3] = office2007
->encryptedVerifierHash
[3];
14922 return (PARSER_OK
);
14925 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14927 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14929 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14931 u32
*digest
= (u32
*) hash_buf
->digest
;
14933 salt_t
*salt
= hash_buf
->salt
;
14935 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14941 char *version_pos
= input_buf
+ 8 + 1;
14943 char *spinCount_pos
= strchr (version_pos
, '*');
14945 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14947 u32 version_len
= spinCount_pos
- version_pos
;
14949 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14953 char *keySize_pos
= strchr (spinCount_pos
, '*');
14955 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14957 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
14959 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14963 char *saltSize_pos
= strchr (keySize_pos
, '*');
14965 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14967 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14969 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14973 char *osalt_pos
= strchr (saltSize_pos
, '*');
14975 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14977 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14979 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14983 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14985 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14987 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14989 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14991 encryptedVerifier_pos
++;
14993 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14995 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14997 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14999 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15001 encryptedVerifierHash_pos
++;
15003 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;
15005 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15007 const uint version
= atoi (version_pos
);
15009 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15011 const uint spinCount
= atoi (spinCount_pos
);
15013 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15015 const uint keySize
= atoi (keySize_pos
);
15017 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15019 const uint saltSize
= atoi (saltSize_pos
);
15021 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15027 salt
->salt_len
= 16;
15028 salt
->salt_iter
= spinCount
;
15030 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15031 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15032 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15033 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15039 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15040 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15041 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15042 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15044 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15045 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15046 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15047 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15048 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15049 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15050 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15051 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15057 digest
[0] = office2010
->encryptedVerifierHash
[0];
15058 digest
[1] = office2010
->encryptedVerifierHash
[1];
15059 digest
[2] = office2010
->encryptedVerifierHash
[2];
15060 digest
[3] = office2010
->encryptedVerifierHash
[3];
15062 return (PARSER_OK
);
15065 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15067 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15069 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15071 u32
*digest
= (u32
*) hash_buf
->digest
;
15073 salt_t
*salt
= hash_buf
->salt
;
15075 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15081 char *version_pos
= input_buf
+ 8 + 1;
15083 char *spinCount_pos
= strchr (version_pos
, '*');
15085 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15087 u32 version_len
= spinCount_pos
- version_pos
;
15089 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15093 char *keySize_pos
= strchr (spinCount_pos
, '*');
15095 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15097 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15099 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15103 char *saltSize_pos
= strchr (keySize_pos
, '*');
15105 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15107 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15109 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15113 char *osalt_pos
= strchr (saltSize_pos
, '*');
15115 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15117 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15119 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15123 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15125 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15127 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15129 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15131 encryptedVerifier_pos
++;
15133 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15135 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15137 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15139 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15141 encryptedVerifierHash_pos
++;
15143 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;
15145 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15147 const uint version
= atoi (version_pos
);
15149 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15151 const uint spinCount
= atoi (spinCount_pos
);
15153 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15155 const uint keySize
= atoi (keySize_pos
);
15157 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15159 const uint saltSize
= atoi (saltSize_pos
);
15161 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15167 salt
->salt_len
= 16;
15168 salt
->salt_iter
= spinCount
;
15170 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15171 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15172 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15173 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15179 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15180 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15181 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15182 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15184 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15185 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15186 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15187 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15188 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15189 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15190 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15191 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15197 digest
[0] = office2013
->encryptedVerifierHash
[0];
15198 digest
[1] = office2013
->encryptedVerifierHash
[1];
15199 digest
[2] = office2013
->encryptedVerifierHash
[2];
15200 digest
[3] = office2013
->encryptedVerifierHash
[3];
15202 return (PARSER_OK
);
15205 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15207 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15209 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15211 u32
*digest
= (u32
*) hash_buf
->digest
;
15213 salt_t
*salt
= hash_buf
->salt
;
15215 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15221 char *version_pos
= input_buf
+ 11;
15223 char *osalt_pos
= strchr (version_pos
, '*');
15225 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15227 u32 version_len
= osalt_pos
- version_pos
;
15229 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15233 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15235 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15237 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15239 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15241 encryptedVerifier_pos
++;
15243 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15245 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15247 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15249 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15251 encryptedVerifierHash_pos
++;
15253 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15255 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15257 const uint version
= *version_pos
- 0x30;
15259 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15265 oldoffice01
->version
= version
;
15267 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15268 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15269 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15270 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15272 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15273 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15274 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15275 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15277 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15278 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15279 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15280 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15282 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15283 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15284 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15285 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15291 salt
->salt_len
= 16;
15293 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15294 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15295 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15296 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15298 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15299 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15300 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15301 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15303 // this is a workaround as office produces multiple documents with the same salt
15305 salt
->salt_len
+= 32;
15307 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15308 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15309 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15310 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15311 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15312 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15313 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15314 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15320 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15321 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15322 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15323 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15325 return (PARSER_OK
);
15328 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15330 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15333 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15335 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15337 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15339 u32
*digest
= (u32
*) hash_buf
->digest
;
15341 salt_t
*salt
= hash_buf
->salt
;
15343 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15349 char *version_pos
= input_buf
+ 11;
15351 char *osalt_pos
= strchr (version_pos
, '*');
15353 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15355 u32 version_len
= osalt_pos
- version_pos
;
15357 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15361 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15363 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15365 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15367 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15369 encryptedVerifier_pos
++;
15371 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15373 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15375 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15377 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15379 encryptedVerifierHash_pos
++;
15381 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15383 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15385 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15387 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15391 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15393 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15395 const uint version
= *version_pos
- 0x30;
15397 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15403 oldoffice01
->version
= version
;
15405 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15406 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15407 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15408 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15410 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15411 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15412 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15413 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15415 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15416 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15417 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15418 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15420 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15421 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15422 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15423 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15425 oldoffice01
->rc4key
[1] = 0;
15426 oldoffice01
->rc4key
[0] = 0;
15428 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15429 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15430 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15431 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15432 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15433 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15434 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15435 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15436 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15437 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15439 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15440 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15446 salt
->salt_len
= 16;
15448 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15449 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15450 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15451 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15453 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15454 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15455 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15456 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15458 // this is a workaround as office produces multiple documents with the same salt
15460 salt
->salt_len
+= 32;
15462 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15463 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15464 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15465 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15466 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15467 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15468 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15469 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15475 digest
[0] = oldoffice01
->rc4key
[0];
15476 digest
[1] = oldoffice01
->rc4key
[1];
15480 return (PARSER_OK
);
15483 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15485 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15487 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15489 u32
*digest
= (u32
*) hash_buf
->digest
;
15491 salt_t
*salt
= hash_buf
->salt
;
15493 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15499 char *version_pos
= input_buf
+ 11;
15501 char *osalt_pos
= strchr (version_pos
, '*');
15503 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15505 u32 version_len
= osalt_pos
- version_pos
;
15507 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15511 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15513 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15515 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15517 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15519 encryptedVerifier_pos
++;
15521 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15523 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15525 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15527 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15529 encryptedVerifierHash_pos
++;
15531 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15533 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15535 const uint version
= *version_pos
- 0x30;
15537 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15543 oldoffice34
->version
= version
;
15545 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15546 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15547 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15548 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15550 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15551 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15552 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15553 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15555 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15556 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15557 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15558 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15559 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15561 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15562 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15563 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15564 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15565 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15571 salt
->salt_len
= 16;
15573 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15574 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15575 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15576 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15578 // this is a workaround as office produces multiple documents with the same salt
15580 salt
->salt_len
+= 32;
15582 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15583 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15584 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15585 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15586 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15587 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15588 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15589 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15595 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15596 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15597 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15598 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15600 return (PARSER_OK
);
15603 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15605 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15607 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15610 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15612 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15614 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15616 u32
*digest
= (u32
*) hash_buf
->digest
;
15618 salt_t
*salt
= hash_buf
->salt
;
15620 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15626 char *version_pos
= input_buf
+ 11;
15628 char *osalt_pos
= strchr (version_pos
, '*');
15630 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15632 u32 version_len
= osalt_pos
- version_pos
;
15634 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15638 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15640 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15642 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15644 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15646 encryptedVerifier_pos
++;
15648 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15650 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15652 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15654 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15656 encryptedVerifierHash_pos
++;
15658 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15660 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15662 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15664 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15668 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15670 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15672 const uint version
= *version_pos
- 0x30;
15674 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15680 oldoffice34
->version
= version
;
15682 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15683 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15684 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15685 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15687 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15688 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15689 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15690 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15692 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15693 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15694 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15695 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15696 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15698 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15699 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15700 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15701 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15702 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15704 oldoffice34
->rc4key
[1] = 0;
15705 oldoffice34
->rc4key
[0] = 0;
15707 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15708 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15709 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15710 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15711 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15712 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15713 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15714 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15715 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15716 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15718 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15719 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15725 salt
->salt_len
= 16;
15727 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15728 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15729 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15730 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15732 // this is a workaround as office produces multiple documents with the same salt
15734 salt
->salt_len
+= 32;
15736 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15737 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15738 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15739 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15740 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15741 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15742 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15743 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15749 digest
[0] = oldoffice34
->rc4key
[0];
15750 digest
[1] = oldoffice34
->rc4key
[1];
15754 return (PARSER_OK
);
15757 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15759 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15761 u32
*digest
= (u32
*) hash_buf
->digest
;
15763 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15764 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15765 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15766 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15768 digest
[0] = byte_swap_32 (digest
[0]);
15769 digest
[1] = byte_swap_32 (digest
[1]);
15770 digest
[2] = byte_swap_32 (digest
[2]);
15771 digest
[3] = byte_swap_32 (digest
[3]);
15773 return (PARSER_OK
);
15776 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15778 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15780 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15782 u32
*digest
= (u32
*) hash_buf
->digest
;
15784 salt_t
*salt
= hash_buf
->salt
;
15786 char *signature_pos
= input_buf
;
15788 char *salt_pos
= strchr (signature_pos
, '$');
15790 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15792 u32 signature_len
= salt_pos
- signature_pos
;
15794 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15798 char *hash_pos
= strchr (salt_pos
, '$');
15800 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15802 u32 salt_len
= hash_pos
- salt_pos
;
15804 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15808 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15810 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15812 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
15813 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
15814 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
15815 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
15816 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
15818 digest
[0] -= SHA1M_A
;
15819 digest
[1] -= SHA1M_B
;
15820 digest
[2] -= SHA1M_C
;
15821 digest
[3] -= SHA1M_D
;
15822 digest
[4] -= SHA1M_E
;
15824 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15826 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15828 salt
->salt_len
= salt_len
;
15830 return (PARSER_OK
);
15833 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15835 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15837 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15839 u32
*digest
= (u32
*) hash_buf
->digest
;
15841 salt_t
*salt
= hash_buf
->salt
;
15843 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15849 char *iter_pos
= input_buf
+ 14;
15851 const int iter
= atoi (iter_pos
);
15853 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15855 salt
->salt_iter
= iter
- 1;
15857 char *salt_pos
= strchr (iter_pos
, '$');
15859 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15863 char *hash_pos
= strchr (salt_pos
, '$');
15865 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15867 const uint salt_len
= hash_pos
- salt_pos
;
15871 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15873 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15875 salt
->salt_len
= salt_len
;
15877 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15878 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15880 // add some stuff to normal salt to make sorted happy
15882 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15883 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15884 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15885 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15886 salt
->salt_buf
[4] = salt
->salt_iter
;
15888 // base64 decode hash
15892 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15894 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15896 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15898 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15900 memcpy (digest
, tmp_buf
, 32);
15902 digest
[0] = byte_swap_32 (digest
[0]);
15903 digest
[1] = byte_swap_32 (digest
[1]);
15904 digest
[2] = byte_swap_32 (digest
[2]);
15905 digest
[3] = byte_swap_32 (digest
[3]);
15906 digest
[4] = byte_swap_32 (digest
[4]);
15907 digest
[5] = byte_swap_32 (digest
[5]);
15908 digest
[6] = byte_swap_32 (digest
[6]);
15909 digest
[7] = byte_swap_32 (digest
[7]);
15911 return (PARSER_OK
);
15914 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15916 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15918 u32
*digest
= (u32
*) hash_buf
->digest
;
15920 salt_t
*salt
= hash_buf
->salt
;
15922 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15923 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15927 digest
[0] = byte_swap_32 (digest
[0]);
15928 digest
[1] = byte_swap_32 (digest
[1]);
15930 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15931 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15932 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15934 char iter_c
= input_buf
[17];
15935 char iter_d
= input_buf
[19];
15937 // atm only defaults, let's see if there's more request
15938 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15939 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15941 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15943 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
15944 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
15945 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
15946 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
15948 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15949 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15950 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15951 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15953 salt
->salt_len
= 16;
15955 return (PARSER_OK
);
15958 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15960 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
15962 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15964 u32
*digest
= (u32
*) hash_buf
->digest
;
15966 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
15968 salt_t
*salt
= hash_buf
->salt
;
15970 char *salt_pos
= input_buf
+ 10;
15972 char *hash_pos
= strchr (salt_pos
, '$');
15974 uint salt_len
= hash_pos
- salt_pos
;
15976 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15980 uint hash_len
= input_len
- 10 - salt_len
- 1;
15982 // base64 decode salt
15986 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15988 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
15990 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
15992 tmp_buf
[salt_len
] = 0x80;
15994 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
15996 salt
->salt_len
= salt_len
;
15998 // base64 decode salt
16000 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16002 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16004 uint user_len
= hash_len
- 32;
16006 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16008 user_len
--; // skip the trailing space
16010 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16011 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16012 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16013 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16015 digest
[0] = byte_swap_32 (digest
[0]);
16016 digest
[1] = byte_swap_32 (digest
[1]);
16017 digest
[2] = byte_swap_32 (digest
[2]);
16018 digest
[3] = byte_swap_32 (digest
[3]);
16020 // store username for host only (output hash if cracked)
16022 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16023 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16025 return (PARSER_OK
);
16028 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16030 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16032 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16034 u32
*digest
= (u32
*) hash_buf
->digest
;
16036 salt_t
*salt
= hash_buf
->salt
;
16038 char *iter_pos
= input_buf
+ 10;
16040 u32 iter
= atoi (iter_pos
);
16044 return (PARSER_SALT_ITERATION
);
16047 iter
--; // first iteration is special
16049 salt
->salt_iter
= iter
;
16051 char *base64_pos
= strchr (iter_pos
, '}');
16053 if (base64_pos
== NULL
)
16055 return (PARSER_SIGNATURE_UNMATCHED
);
16060 // base64 decode salt
16062 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16066 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16068 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16070 if (decoded_len
< 24)
16072 return (PARSER_SALT_LENGTH
);
16077 uint salt_len
= decoded_len
- 20;
16079 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16080 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16082 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16084 salt
->salt_len
= salt_len
;
16088 u32
*digest_ptr
= (u32
*) tmp_buf
;
16090 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16091 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16092 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16093 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16094 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16096 return (PARSER_OK
);
16099 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16101 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16103 u32
*digest
= (u32
*) hash_buf
->digest
;
16105 salt_t
*salt
= hash_buf
->salt
;
16107 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16108 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16109 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16110 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16111 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16113 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16115 uint salt_len
= input_len
- 40 - 1;
16117 char *salt_buf
= input_buf
+ 40 + 1;
16119 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16121 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16123 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16125 salt
->salt_len
= salt_len
;
16127 return (PARSER_OK
);
16130 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16132 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16134 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16136 u32
*digest
= (u32
*) hash_buf
->digest
;
16138 salt_t
*salt
= hash_buf
->salt
;
16140 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16146 char *V_pos
= input_buf
+ 5;
16148 char *R_pos
= strchr (V_pos
, '*');
16150 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16152 u32 V_len
= R_pos
- V_pos
;
16156 char *bits_pos
= strchr (R_pos
, '*');
16158 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16160 u32 R_len
= bits_pos
- R_pos
;
16164 char *P_pos
= strchr (bits_pos
, '*');
16166 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16168 u32 bits_len
= P_pos
- bits_pos
;
16172 char *enc_md_pos
= strchr (P_pos
, '*');
16174 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16176 u32 P_len
= enc_md_pos
- P_pos
;
16180 char *id_len_pos
= strchr (enc_md_pos
, '*');
16182 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16184 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16188 char *id_buf_pos
= strchr (id_len_pos
, '*');
16190 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16192 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16196 char *u_len_pos
= strchr (id_buf_pos
, '*');
16198 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16200 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16202 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16206 char *u_buf_pos
= strchr (u_len_pos
, '*');
16208 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16210 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16214 char *o_len_pos
= strchr (u_buf_pos
, '*');
16216 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16218 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16220 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16224 char *o_buf_pos
= strchr (o_len_pos
, '*');
16226 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16228 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16232 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;
16234 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16238 const int V
= atoi (V_pos
);
16239 const int R
= atoi (R_pos
);
16240 const int P
= atoi (P_pos
);
16242 if (V
!= 1) return (PARSER_SALT_VALUE
);
16243 if (R
!= 2) return (PARSER_SALT_VALUE
);
16245 const int enc_md
= atoi (enc_md_pos
);
16247 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16249 const int id_len
= atoi (id_len_pos
);
16250 const int u_len
= atoi (u_len_pos
);
16251 const int o_len
= atoi (o_len_pos
);
16253 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16254 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16255 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16257 const int bits
= atoi (bits_pos
);
16259 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16261 // copy data to esalt
16267 pdf
->enc_md
= enc_md
;
16269 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16270 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16271 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16272 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16273 pdf
->id_len
= id_len
;
16275 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16276 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16277 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16278 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16279 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16280 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16281 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16282 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16283 pdf
->u_len
= u_len
;
16285 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16286 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16287 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16288 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16289 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16290 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16291 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16292 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16293 pdf
->o_len
= o_len
;
16295 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16296 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16297 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16298 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16300 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16301 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16302 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16303 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16304 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16305 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16306 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16307 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16309 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16310 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16311 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16312 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16313 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16314 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16315 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16316 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16318 // we use ID for salt, maybe needs to change, we will see...
16320 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16321 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16322 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16323 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16324 salt
->salt_len
= pdf
->id_len
;
16326 digest
[0] = pdf
->u_buf
[0];
16327 digest
[1] = pdf
->u_buf
[1];
16328 digest
[2] = pdf
->u_buf
[2];
16329 digest
[3] = pdf
->u_buf
[3];
16331 return (PARSER_OK
);
16334 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16336 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16339 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16341 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16343 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16345 u32
*digest
= (u32
*) hash_buf
->digest
;
16347 salt_t
*salt
= hash_buf
->salt
;
16349 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16355 char *V_pos
= input_buf
+ 5;
16357 char *R_pos
= strchr (V_pos
, '*');
16359 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16361 u32 V_len
= R_pos
- V_pos
;
16365 char *bits_pos
= strchr (R_pos
, '*');
16367 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16369 u32 R_len
= bits_pos
- R_pos
;
16373 char *P_pos
= strchr (bits_pos
, '*');
16375 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16377 u32 bits_len
= P_pos
- bits_pos
;
16381 char *enc_md_pos
= strchr (P_pos
, '*');
16383 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16385 u32 P_len
= enc_md_pos
- P_pos
;
16389 char *id_len_pos
= strchr (enc_md_pos
, '*');
16391 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16393 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16397 char *id_buf_pos
= strchr (id_len_pos
, '*');
16399 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16401 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16405 char *u_len_pos
= strchr (id_buf_pos
, '*');
16407 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16409 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16411 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16415 char *u_buf_pos
= strchr (u_len_pos
, '*');
16417 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16419 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16423 char *o_len_pos
= strchr (u_buf_pos
, '*');
16425 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16427 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16429 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16433 char *o_buf_pos
= strchr (o_len_pos
, '*');
16435 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16437 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16441 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16443 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16445 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16447 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16451 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;
16453 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16457 const int V
= atoi (V_pos
);
16458 const int R
= atoi (R_pos
);
16459 const int P
= atoi (P_pos
);
16461 if (V
!= 1) return (PARSER_SALT_VALUE
);
16462 if (R
!= 2) return (PARSER_SALT_VALUE
);
16464 const int enc_md
= atoi (enc_md_pos
);
16466 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16468 const int id_len
= atoi (id_len_pos
);
16469 const int u_len
= atoi (u_len_pos
);
16470 const int o_len
= atoi (o_len_pos
);
16472 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16473 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16474 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16476 const int bits
= atoi (bits_pos
);
16478 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16480 // copy data to esalt
16486 pdf
->enc_md
= enc_md
;
16488 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16489 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16490 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16491 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16492 pdf
->id_len
= id_len
;
16494 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16495 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16496 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16497 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16498 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16499 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16500 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16501 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16502 pdf
->u_len
= u_len
;
16504 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16505 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16506 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16507 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16508 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16509 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16510 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16511 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16512 pdf
->o_len
= o_len
;
16514 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16515 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16516 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16517 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16519 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16520 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16521 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16522 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16523 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16524 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16525 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16526 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16528 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16529 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16530 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16531 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16532 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16533 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16534 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16535 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16537 pdf
->rc4key
[1] = 0;
16538 pdf
->rc4key
[0] = 0;
16540 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16541 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16542 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16543 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16544 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16545 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16546 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16547 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16548 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16549 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16551 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16552 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16554 // we use ID for salt, maybe needs to change, we will see...
16556 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16557 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16558 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16559 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16560 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16561 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16562 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16563 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16564 salt
->salt_len
= pdf
->id_len
+ 16;
16566 digest
[0] = pdf
->rc4key
[0];
16567 digest
[1] = pdf
->rc4key
[1];
16571 return (PARSER_OK
);
16574 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16576 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16578 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16580 u32
*digest
= (u32
*) hash_buf
->digest
;
16582 salt_t
*salt
= hash_buf
->salt
;
16584 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16590 char *V_pos
= input_buf
+ 5;
16592 char *R_pos
= strchr (V_pos
, '*');
16594 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16596 u32 V_len
= R_pos
- V_pos
;
16600 char *bits_pos
= strchr (R_pos
, '*');
16602 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16604 u32 R_len
= bits_pos
- R_pos
;
16608 char *P_pos
= strchr (bits_pos
, '*');
16610 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16612 u32 bits_len
= P_pos
- bits_pos
;
16616 char *enc_md_pos
= strchr (P_pos
, '*');
16618 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16620 u32 P_len
= enc_md_pos
- P_pos
;
16624 char *id_len_pos
= strchr (enc_md_pos
, '*');
16626 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16628 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16632 char *id_buf_pos
= strchr (id_len_pos
, '*');
16634 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16636 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16640 char *u_len_pos
= strchr (id_buf_pos
, '*');
16642 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16644 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16646 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16650 char *u_buf_pos
= strchr (u_len_pos
, '*');
16652 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16654 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16658 char *o_len_pos
= strchr (u_buf_pos
, '*');
16660 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16662 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16664 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16668 char *o_buf_pos
= strchr (o_len_pos
, '*');
16670 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16672 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16676 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;
16678 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16682 const int V
= atoi (V_pos
);
16683 const int R
= atoi (R_pos
);
16684 const int P
= atoi (P_pos
);
16688 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16689 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16691 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16693 const int id_len
= atoi (id_len_pos
);
16694 const int u_len
= atoi (u_len_pos
);
16695 const int o_len
= atoi (o_len_pos
);
16697 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16699 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16700 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16702 const int bits
= atoi (bits_pos
);
16704 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16710 enc_md
= atoi (enc_md_pos
);
16713 // copy data to esalt
16719 pdf
->enc_md
= enc_md
;
16721 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16722 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16723 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16724 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16728 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
16729 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
16730 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
16731 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
16734 pdf
->id_len
= id_len
;
16736 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16737 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16738 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16739 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16740 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16741 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16742 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16743 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16744 pdf
->u_len
= u_len
;
16746 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16747 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16748 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16749 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16750 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16751 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16752 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16753 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16754 pdf
->o_len
= o_len
;
16756 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16757 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16758 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16759 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16763 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16764 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16765 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16766 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16769 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16770 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16771 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16772 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16773 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16774 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16775 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16776 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16778 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16779 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16780 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16781 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16782 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16783 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16784 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16785 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16787 // precompute rc4 data for later use
16803 uint salt_pc_block
[32];
16805 char *salt_pc_ptr
= (char *) salt_pc_block
;
16807 memcpy (salt_pc_ptr
, padding
, 32);
16808 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16810 uint salt_pc_digest
[4];
16812 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16814 pdf
->rc4data
[0] = salt_pc_digest
[0];
16815 pdf
->rc4data
[1] = salt_pc_digest
[1];
16817 // we use ID for salt, maybe needs to change, we will see...
16819 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16820 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16821 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16822 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16823 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16824 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16825 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16826 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16827 salt
->salt_len
= pdf
->id_len
+ 16;
16829 salt
->salt_iter
= ROUNDS_PDF14
;
16831 digest
[0] = pdf
->u_buf
[0];
16832 digest
[1] = pdf
->u_buf
[1];
16836 return (PARSER_OK
);
16839 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16841 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16843 if (ret
!= PARSER_OK
)
16848 u32
*digest
= (u32
*) hash_buf
->digest
;
16850 salt_t
*salt
= hash_buf
->salt
;
16852 digest
[0] -= SHA256M_A
;
16853 digest
[1] -= SHA256M_B
;
16854 digest
[2] -= SHA256M_C
;
16855 digest
[3] -= SHA256M_D
;
16856 digest
[4] -= SHA256M_E
;
16857 digest
[5] -= SHA256M_F
;
16858 digest
[6] -= SHA256M_G
;
16859 digest
[7] -= SHA256M_H
;
16861 salt
->salt_buf
[2] = 0x80;
16863 return (PARSER_OK
);
16866 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16868 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16870 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16872 u32
*digest
= (u32
*) hash_buf
->digest
;
16874 salt_t
*salt
= hash_buf
->salt
;
16876 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16882 char *V_pos
= input_buf
+ 5;
16884 char *R_pos
= strchr (V_pos
, '*');
16886 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16888 u32 V_len
= R_pos
- V_pos
;
16892 char *bits_pos
= strchr (R_pos
, '*');
16894 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16896 u32 R_len
= bits_pos
- R_pos
;
16900 char *P_pos
= strchr (bits_pos
, '*');
16902 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16904 u32 bits_len
= P_pos
- bits_pos
;
16908 char *enc_md_pos
= strchr (P_pos
, '*');
16910 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16912 u32 P_len
= enc_md_pos
- P_pos
;
16916 char *id_len_pos
= strchr (enc_md_pos
, '*');
16918 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16920 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16924 char *id_buf_pos
= strchr (id_len_pos
, '*');
16926 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16928 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16932 char *u_len_pos
= strchr (id_buf_pos
, '*');
16934 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16936 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16940 char *u_buf_pos
= strchr (u_len_pos
, '*');
16942 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16944 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16948 char *o_len_pos
= strchr (u_buf_pos
, '*');
16950 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16952 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16956 char *o_buf_pos
= strchr (o_len_pos
, '*');
16958 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16960 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16964 char *last
= strchr (o_buf_pos
, '*');
16966 if (last
== NULL
) last
= input_buf
+ input_len
;
16968 u32 o_buf_len
= last
- o_buf_pos
;
16972 const int V
= atoi (V_pos
);
16973 const int R
= atoi (R_pos
);
16977 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
16978 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
16980 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16982 const int bits
= atoi (bits_pos
);
16984 if (bits
!= 256) return (PARSER_SALT_VALUE
);
16986 int enc_md
= atoi (enc_md_pos
);
16988 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
16990 const uint id_len
= atoi (id_len_pos
);
16991 const uint u_len
= atoi (u_len_pos
);
16992 const uint o_len
= atoi (o_len_pos
);
16994 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
16995 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
16996 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
16997 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
16998 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
16999 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17000 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17001 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17003 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17004 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17005 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17007 // copy data to esalt
17009 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17011 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17013 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17016 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17017 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17019 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17020 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17022 salt
->salt_len
= 8;
17023 salt
->salt_iter
= ROUNDS_PDF17L8
;
17025 digest
[0] = pdf
->u_buf
[0];
17026 digest
[1] = pdf
->u_buf
[1];
17027 digest
[2] = pdf
->u_buf
[2];
17028 digest
[3] = pdf
->u_buf
[3];
17029 digest
[4] = pdf
->u_buf
[4];
17030 digest
[5] = pdf
->u_buf
[5];
17031 digest
[6] = pdf
->u_buf
[6];
17032 digest
[7] = pdf
->u_buf
[7];
17034 return (PARSER_OK
);
17037 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17039 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17041 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17043 u32
*digest
= (u32
*) hash_buf
->digest
;
17045 salt_t
*salt
= hash_buf
->salt
;
17047 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17055 char *iter_pos
= input_buf
+ 7;
17057 u32 iter
= atoi (iter_pos
);
17059 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17060 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17062 // first is *raw* salt
17064 char *salt_pos
= strchr (iter_pos
, ':');
17066 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17070 char *hash_pos
= strchr (salt_pos
, ':');
17072 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17074 u32 salt_len
= hash_pos
- salt_pos
;
17076 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17080 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17082 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17086 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17088 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17090 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17092 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17093 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17095 salt
->salt_len
= salt_len
;
17096 salt
->salt_iter
= iter
- 1;
17102 memset (tmp_buf
, 0, sizeof (tmp_buf
));
17104 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17106 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17108 memcpy (digest
, tmp_buf
, 16);
17110 digest
[0] = byte_swap_32 (digest
[0]);
17111 digest
[1] = byte_swap_32 (digest
[1]);
17112 digest
[2] = byte_swap_32 (digest
[2]);
17113 digest
[3] = byte_swap_32 (digest
[3]);
17115 // add some stuff to normal salt to make sorted happy
17117 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17118 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17119 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17120 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17121 salt
->salt_buf
[4] = salt
->salt_iter
;
17123 return (PARSER_OK
);
17126 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17128 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17130 u32
*digest
= (u32
*) hash_buf
->digest
;
17132 salt_t
*salt
= hash_buf
->salt
;
17134 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17135 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17136 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17137 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17139 digest
[0] = byte_swap_32 (digest
[0]);
17140 digest
[1] = byte_swap_32 (digest
[1]);
17141 digest
[2] = byte_swap_32 (digest
[2]);
17142 digest
[3] = byte_swap_32 (digest
[3]);
17144 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17146 uint salt_len
= input_len
- 32 - 1;
17148 char *salt_buf
= input_buf
+ 32 + 1;
17150 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17152 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17154 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17156 salt
->salt_len
= salt_len
;
17158 return (PARSER_OK
);
17161 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17163 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17165 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17167 u32
*digest
= (u32
*) hash_buf
->digest
;
17169 salt_t
*salt
= hash_buf
->salt
;
17171 char *user_pos
= input_buf
+ 10;
17173 char *salt_pos
= strchr (user_pos
, '*');
17175 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17179 char *hash_pos
= strchr (salt_pos
, '*');
17183 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17185 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17187 uint user_len
= salt_pos
- user_pos
- 1;
17189 uint salt_len
= hash_pos
- salt_pos
- 1;
17191 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17197 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17198 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17199 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17200 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17202 digest
[0] = byte_swap_32 (digest
[0]);
17203 digest
[1] = byte_swap_32 (digest
[1]);
17204 digest
[2] = byte_swap_32 (digest
[2]);
17205 digest
[3] = byte_swap_32 (digest
[3]);
17207 digest
[0] -= MD5M_A
;
17208 digest
[1] -= MD5M_B
;
17209 digest
[2] -= MD5M_C
;
17210 digest
[3] -= MD5M_D
;
17216 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17218 // first 4 bytes are the "challenge"
17220 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17221 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17222 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17223 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17225 // append the user name
17227 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17229 salt
->salt_len
= 4 + user_len
;
17231 return (PARSER_OK
);
17234 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17236 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17238 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17240 u32
*digest
= (u32
*) hash_buf
->digest
;
17242 salt_t
*salt
= hash_buf
->salt
;
17244 char *salt_pos
= input_buf
+ 9;
17246 char *hash_pos
= strchr (salt_pos
, '*');
17248 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17252 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17254 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17256 uint salt_len
= hash_pos
- salt_pos
- 1;
17258 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17264 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17265 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17266 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17267 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17268 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17274 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17276 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17278 salt
->salt_len
= salt_len
;
17280 return (PARSER_OK
);
17283 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17285 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17287 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17289 u32
*digest
= (u32
*) hash_buf
->digest
;
17291 salt_t
*salt
= hash_buf
->salt
;
17293 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17299 char *cry_master_len_pos
= input_buf
+ 9;
17301 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17303 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17305 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17307 cry_master_buf_pos
++;
17309 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17311 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17313 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17315 cry_salt_len_pos
++;
17317 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17319 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17321 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17323 cry_salt_buf_pos
++;
17325 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17327 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17329 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17333 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17335 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17337 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17341 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17343 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17345 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17349 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17351 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17353 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17355 public_key_len_pos
++;
17357 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17359 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17361 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17363 public_key_buf_pos
++;
17365 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;
17367 const uint cry_master_len
= atoi (cry_master_len_pos
);
17368 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17369 const uint ckey_len
= atoi (ckey_len_pos
);
17370 const uint public_key_len
= atoi (public_key_len_pos
);
17372 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17373 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17374 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17375 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17377 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 8)
17379 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17381 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17384 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 8)
17386 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17388 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17391 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 8)
17393 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17395 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17398 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17399 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17400 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17403 * store digest (should be unique enought, hopefully)
17406 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17407 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17408 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17409 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17415 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17417 const uint cry_rounds
= atoi (cry_rounds_pos
);
17419 salt
->salt_iter
= cry_rounds
- 1;
17421 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17423 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17425 salt
->salt_len
= salt_len
;
17427 return (PARSER_OK
);
17430 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17432 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17434 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17436 u32
*digest
= (u32
*) hash_buf
->digest
;
17438 salt_t
*salt
= hash_buf
->salt
;
17440 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17442 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17444 char temp_input_buf
[input_len
+ 1];
17446 memset (temp_input_buf
, 0, sizeof (temp_input_buf
));
17447 memcpy (temp_input_buf
, input_buf
, input_len
);
17451 char *URI_server_pos
= temp_input_buf
+ 6;
17453 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17455 if (URI_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17457 URI_client_pos
[0] = 0;
17460 uint URI_server_len
= strlen (URI_server_pos
);
17462 if (URI_server_len
> 512) return (PARSER_SALT_LENGTH
);
17466 char *user_pos
= strchr (URI_client_pos
, '*');
17468 if (user_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17473 uint URI_client_len
= strlen (URI_client_pos
);
17475 if (URI_client_len
> 512) return (PARSER_SALT_LENGTH
);
17479 char *realm_pos
= strchr (user_pos
, '*');
17481 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17486 uint user_len
= strlen (user_pos
);
17488 if (user_len
> 116) return (PARSER_SALT_LENGTH
);
17492 char *method_pos
= strchr (realm_pos
, '*');
17494 if (method_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17499 uint realm_len
= strlen (realm_pos
);
17501 if (realm_len
> 116) return (PARSER_SALT_LENGTH
);
17505 char *URI_prefix_pos
= strchr (method_pos
, '*');
17507 if (URI_prefix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17509 URI_prefix_pos
[0] = 0;
17512 uint method_len
= strlen (method_pos
);
17514 if (method_len
> 246) return (PARSER_SALT_LENGTH
);
17518 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17520 if (URI_resource_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17522 URI_resource_pos
[0] = 0;
17523 URI_resource_pos
++;
17525 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17527 if (URI_prefix_len
> 245) return (PARSER_SALT_LENGTH
);
17531 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17533 if (URI_suffix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17535 URI_suffix_pos
[0] = 0;
17538 uint URI_resource_len
= strlen (URI_resource_pos
);
17540 if (URI_resource_len
< 1) return (PARSER_SALT_LENGTH
);
17541 if (URI_resource_len
> 246) return (PARSER_SALT_LENGTH
);
17545 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17547 if (nonce_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17552 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17554 if (URI_suffix_len
> 245) return (PARSER_SALT_LENGTH
);
17558 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17560 if (nonce_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17562 nonce_client_pos
[0] = 0;
17563 nonce_client_pos
++;
17565 uint nonce_len
= strlen (nonce_pos
);
17567 if (nonce_len
< 1) return (PARSER_SALT_LENGTH
);
17568 if (nonce_len
> 50) return (PARSER_SALT_LENGTH
);
17572 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17574 if (nonce_count_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17576 nonce_count_pos
[0] = 0;
17579 uint nonce_client_len
= strlen (nonce_client_pos
);
17581 if (nonce_client_len
> 50) return (PARSER_SALT_LENGTH
);
17585 char *qop_pos
= strchr (nonce_count_pos
, '*');
17587 if (qop_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17592 uint nonce_count_len
= strlen (nonce_count_pos
);
17594 if (nonce_count_len
> 50) return (PARSER_SALT_LENGTH
);
17598 char *directive_pos
= strchr (qop_pos
, '*');
17600 if (directive_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17602 directive_pos
[0] = 0;
17605 uint qop_len
= strlen (qop_pos
);
17607 if (qop_len
> 50) return (PARSER_SALT_LENGTH
);
17611 char *digest_pos
= strchr (directive_pos
, '*');
17613 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17618 uint directive_len
= strlen (directive_pos
);
17620 if (directive_len
!= 3) return (PARSER_SALT_LENGTH
);
17622 if (memcmp (directive_pos
, "MD5", 3))
17624 log_info ("ERROR: only the MD5 directive is currently supported\n");
17626 return (PARSER_SIP_AUTH_DIRECTIVE
);
17630 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17635 uint md5_max_len
= 4 * 64;
17637 uint md5_remaining_len
= md5_max_len
;
17639 uint tmp_md5_buf
[md5_max_len
/ 4];
17641 memset (tmp_md5_buf
, 0, sizeof (tmp_md5_buf
));
17643 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17645 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17647 md5_len
+= method_len
+ 1;
17648 tmp_md5_ptr
+= method_len
+ 1;
17650 if (URI_prefix_len
> 0)
17652 md5_remaining_len
= md5_max_len
- md5_len
;
17654 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17656 md5_len
+= URI_prefix_len
+ 1;
17657 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17660 md5_remaining_len
= md5_max_len
- md5_len
;
17662 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17664 md5_len
+= URI_resource_len
;
17665 tmp_md5_ptr
+= URI_resource_len
;
17667 if (URI_suffix_len
> 0)
17669 md5_remaining_len
= md5_max_len
- md5_len
;
17671 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17673 md5_len
+= 1 + URI_suffix_len
;
17676 uint tmp_digest
[4];
17678 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17680 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17681 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17682 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17683 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17689 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17691 uint esalt_len
= 0;
17693 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17695 // there are 2 possibilities for the esalt:
17697 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17699 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17701 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17703 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17715 esalt_len
= 1 + nonce_len
+ 1 + 32;
17717 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17719 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17727 // add 0x80 to esalt
17729 esalt_buf_ptr
[esalt_len
] = 0x80;
17731 sip
->esalt_len
= esalt_len
;
17737 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17739 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17741 uint max_salt_len
= 119;
17743 if (salt_len
> max_salt_len
) return (PARSER_SALT_LENGTH
);
17745 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17747 sip
->salt_len
= salt_len
;
17750 * fake salt (for sorting)
17753 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17757 uint fake_salt_len
= salt_len
;
17759 if (fake_salt_len
> max_salt_len
)
17761 fake_salt_len
= max_salt_len
;
17764 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17766 salt
->salt_len
= fake_salt_len
;
17772 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
17773 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
17774 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
17775 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
17777 digest
[0] = byte_swap_32 (digest
[0]);
17778 digest
[1] = byte_swap_32 (digest
[1]);
17779 digest
[2] = byte_swap_32 (digest
[2]);
17780 digest
[3] = byte_swap_32 (digest
[3]);
17782 return (PARSER_OK
);
17785 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17787 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17789 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17791 u32
*digest
= (u32
*) hash_buf
->digest
;
17793 salt_t
*salt
= hash_buf
->salt
;
17797 char *digest_pos
= input_buf
;
17799 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
17806 char *salt_buf
= input_buf
+ 8 + 1;
17810 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17812 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17814 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17816 salt
->salt_len
= salt_len
;
17818 return (PARSER_OK
);
17821 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17823 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
17825 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17827 u32
*digest
= (u32
*) hash_buf
->digest
;
17829 salt_t
*salt
= hash_buf
->salt
;
17831 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
17837 char *p_buf_pos
= input_buf
+ 4;
17839 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
17841 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17843 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
17845 NumCyclesPower_pos
++;
17847 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
17849 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17851 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
17855 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
17857 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17859 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
17863 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
17865 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17867 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
17871 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
17873 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17875 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
17879 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
17881 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17883 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
17887 char *data_len_pos
= strchr (crc_buf_pos
, '$');
17889 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17891 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
17895 char *unpack_size_pos
= strchr (data_len_pos
, '$');
17897 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17899 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
17903 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
17905 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17907 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
17911 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;
17913 const uint iter
= atoi (NumCyclesPower_pos
);
17914 const uint crc
= atoi (crc_buf_pos
);
17915 const uint p_buf
= atoi (p_buf_pos
);
17916 const uint salt_len
= atoi (salt_len_pos
);
17917 const uint iv_len
= atoi (iv_len_pos
);
17918 const uint unpack_size
= atoi (unpack_size_pos
);
17919 const uint data_len
= atoi (data_len_pos
);
17925 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
17926 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
17928 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
17930 if (data_len
> 384) return (PARSER_SALT_VALUE
);
17932 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
17938 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
17939 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
17940 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
17941 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
17943 seven_zip
->iv_len
= iv_len
;
17945 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
17947 seven_zip
->salt_len
= 0;
17949 seven_zip
->crc
= crc
;
17951 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
17953 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
17955 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
17958 seven_zip
->data_len
= data_len
;
17960 seven_zip
->unpack_size
= unpack_size
;
17964 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
17965 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
17966 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
17967 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
17969 salt
->salt_len
= 16;
17971 salt
->salt_sign
[0] = iter
;
17973 salt
->salt_iter
= 1 << iter
;
17984 return (PARSER_OK
);
17987 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17989 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
17991 u32
*digest
= (u32
*) hash_buf
->digest
;
17993 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17994 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17995 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17996 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17997 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
17998 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
17999 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18000 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18002 digest
[0] = byte_swap_32 (digest
[0]);
18003 digest
[1] = byte_swap_32 (digest
[1]);
18004 digest
[2] = byte_swap_32 (digest
[2]);
18005 digest
[3] = byte_swap_32 (digest
[3]);
18006 digest
[4] = byte_swap_32 (digest
[4]);
18007 digest
[5] = byte_swap_32 (digest
[5]);
18008 digest
[6] = byte_swap_32 (digest
[6]);
18009 digest
[7] = byte_swap_32 (digest
[7]);
18011 return (PARSER_OK
);
18014 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18016 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18018 u32
*digest
= (u32
*) hash_buf
->digest
;
18020 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18021 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18022 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18023 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18024 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18025 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18026 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18027 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18028 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18029 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18030 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18031 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18032 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18033 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18034 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18035 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18037 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18038 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18039 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18040 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18041 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18042 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18043 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18044 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18045 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18046 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18047 digest
[10] = byte_swap_32 (digest
[10]);
18048 digest
[11] = byte_swap_32 (digest
[11]);
18049 digest
[12] = byte_swap_32 (digest
[12]);
18050 digest
[13] = byte_swap_32 (digest
[13]);
18051 digest
[14] = byte_swap_32 (digest
[14]);
18052 digest
[15] = byte_swap_32 (digest
[15]);
18054 return (PARSER_OK
);
18057 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18059 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18061 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18063 u32
*digest
= (u32
*) hash_buf
->digest
;
18065 salt_t
*salt
= hash_buf
->salt
;
18067 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18075 char *iter_pos
= input_buf
+ 4;
18077 u32 iter
= atoi (iter_pos
);
18079 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18080 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18082 // first is *raw* salt
18084 char *salt_pos
= strchr (iter_pos
, ':');
18086 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18090 char *hash_pos
= strchr (salt_pos
, ':');
18092 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18094 u32 salt_len
= hash_pos
- salt_pos
;
18096 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18100 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18102 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18106 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18108 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18110 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18112 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18113 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18115 salt
->salt_len
= salt_len
;
18116 salt
->salt_iter
= iter
- 1;
18122 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18124 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18126 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18128 memcpy (digest
, tmp_buf
, 16);
18130 // add some stuff to normal salt to make sorted happy
18132 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18133 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18134 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18135 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18136 salt
->salt_buf
[4] = salt
->salt_iter
;
18138 return (PARSER_OK
);
18141 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18143 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18145 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18147 u32
*digest
= (u32
*) hash_buf
->digest
;
18149 salt_t
*salt
= hash_buf
->salt
;
18151 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18159 char *iter_pos
= input_buf
+ 5;
18161 u32 iter
= atoi (iter_pos
);
18163 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18164 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18166 // first is *raw* salt
18168 char *salt_pos
= strchr (iter_pos
, ':');
18170 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18174 char *hash_pos
= strchr (salt_pos
, ':');
18176 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18178 u32 salt_len
= hash_pos
- salt_pos
;
18180 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18184 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18186 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18190 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18192 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18194 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18196 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18197 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18199 salt
->salt_len
= salt_len
;
18200 salt
->salt_iter
= iter
- 1;
18206 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18208 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18210 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18212 memcpy (digest
, tmp_buf
, 16);
18214 digest
[0] = byte_swap_32 (digest
[0]);
18215 digest
[1] = byte_swap_32 (digest
[1]);
18216 digest
[2] = byte_swap_32 (digest
[2]);
18217 digest
[3] = byte_swap_32 (digest
[3]);
18219 // add some stuff to normal salt to make sorted happy
18221 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18222 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18223 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18224 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18225 salt
->salt_buf
[4] = salt
->salt_iter
;
18227 return (PARSER_OK
);
18230 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18232 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18234 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18236 u64
*digest
= (u64
*) hash_buf
->digest
;
18238 salt_t
*salt
= hash_buf
->salt
;
18240 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18248 char *iter_pos
= input_buf
+ 7;
18250 u32 iter
= atoi (iter_pos
);
18252 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18253 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18255 // first is *raw* salt
18257 char *salt_pos
= strchr (iter_pos
, ':');
18259 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18263 char *hash_pos
= strchr (salt_pos
, ':');
18265 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18267 u32 salt_len
= hash_pos
- salt_pos
;
18269 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18273 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18275 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18279 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18281 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18283 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18285 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18286 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18288 salt
->salt_len
= salt_len
;
18289 salt
->salt_iter
= iter
- 1;
18295 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18297 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18299 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18301 memcpy (digest
, tmp_buf
, 64);
18303 digest
[0] = byte_swap_64 (digest
[0]);
18304 digest
[1] = byte_swap_64 (digest
[1]);
18305 digest
[2] = byte_swap_64 (digest
[2]);
18306 digest
[3] = byte_swap_64 (digest
[3]);
18307 digest
[4] = byte_swap_64 (digest
[4]);
18308 digest
[5] = byte_swap_64 (digest
[5]);
18309 digest
[6] = byte_swap_64 (digest
[6]);
18310 digest
[7] = byte_swap_64 (digest
[7]);
18312 // add some stuff to normal salt to make sorted happy
18314 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18315 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18316 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18317 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18318 salt
->salt_buf
[4] = salt
->salt_iter
;
18320 return (PARSER_OK
);
18323 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18325 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18327 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18329 uint
*digest
= (uint
*) hash_buf
->digest
;
18331 salt_t
*salt
= hash_buf
->salt
;
18337 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18339 char *hash_pos
= strchr (salt_pos
, '$');
18341 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18343 u32 salt_len
= hash_pos
- salt_pos
;
18345 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18349 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18351 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18355 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18356 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18374 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18375 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18377 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18378 salt
->salt_len
= 8;
18380 return (PARSER_OK
);
18383 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18385 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18387 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18389 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18391 if (c19
& 3) return (PARSER_HASH_VALUE
);
18393 salt_t
*salt
= hash_buf
->salt
;
18395 u32
*digest
= (u32
*) hash_buf
->digest
;
18399 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18400 | itoa64_to_int (input_buf
[2]) << 6
18401 | itoa64_to_int (input_buf
[3]) << 12
18402 | itoa64_to_int (input_buf
[4]) << 18;
18406 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18407 | itoa64_to_int (input_buf
[6]) << 6
18408 | itoa64_to_int (input_buf
[7]) << 12
18409 | itoa64_to_int (input_buf
[8]) << 18;
18411 salt
->salt_len
= 4;
18415 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18417 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18419 memcpy (digest
, tmp_buf
, 8);
18423 IP (digest
[0], digest
[1], tt
);
18425 digest
[0] = rotr32 (digest
[0], 31);
18426 digest
[1] = rotr32 (digest
[1], 31);
18430 return (PARSER_OK
);
18433 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18435 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18437 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18439 u32
*digest
= (u32
*) hash_buf
->digest
;
18441 salt_t
*salt
= hash_buf
->salt
;
18447 char *type_pos
= input_buf
+ 6 + 1;
18449 char *salt_pos
= strchr (type_pos
, '*');
18451 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18453 u32 type_len
= salt_pos
- type_pos
;
18455 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18459 char *crypted_pos
= strchr (salt_pos
, '*');
18461 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18463 u32 salt_len
= crypted_pos
- salt_pos
;
18465 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18469 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18471 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18477 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18478 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18480 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18481 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18483 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18484 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18485 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18486 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18488 salt
->salt_len
= 24;
18489 salt
->salt_iter
= ROUNDS_RAR3
;
18491 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18492 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18494 digest
[0] = 0xc43d7b00;
18495 digest
[1] = 0x40070000;
18499 return (PARSER_OK
);
18502 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18504 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18506 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18508 u32
*digest
= (u32
*) hash_buf
->digest
;
18510 salt_t
*salt
= hash_buf
->salt
;
18512 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18518 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18520 char *param1_pos
= strchr (param0_pos
, '$');
18522 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18524 u32 param0_len
= param1_pos
- param0_pos
;
18528 char *param2_pos
= strchr (param1_pos
, '$');
18530 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18532 u32 param1_len
= param2_pos
- param1_pos
;
18536 char *param3_pos
= strchr (param2_pos
, '$');
18538 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18540 u32 param2_len
= param3_pos
- param2_pos
;
18544 char *param4_pos
= strchr (param3_pos
, '$');
18546 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18548 u32 param3_len
= param4_pos
- param3_pos
;
18552 char *param5_pos
= strchr (param4_pos
, '$');
18554 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18556 u32 param4_len
= param5_pos
- param4_pos
;
18560 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18562 char *salt_buf
= param1_pos
;
18563 char *iv
= param3_pos
;
18564 char *pswcheck
= param5_pos
;
18566 const uint salt_len
= atoi (param0_pos
);
18567 const uint iterations
= atoi (param2_pos
);
18568 const uint pswcheck_len
= atoi (param4_pos
);
18574 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18575 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18576 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18578 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18579 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18580 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18586 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18587 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18588 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18589 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
18591 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
18592 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
18593 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
18594 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
18596 salt
->salt_len
= 16;
18598 salt
->salt_sign
[0] = iterations
;
18600 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18606 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
18607 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
18611 return (PARSER_OK
);
18614 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18616 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18618 u32
*digest
= (u32
*) hash_buf
->digest
;
18620 salt_t
*salt
= hash_buf
->salt
;
18622 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18623 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18624 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18625 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18626 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18627 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18628 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18629 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18631 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18633 uint salt_len
= input_len
- 64 - 1;
18635 char *salt_buf
= input_buf
+ 64 + 1;
18637 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18639 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18641 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18643 salt
->salt_len
= salt_len
;
18646 * we can precompute the first sha256 transform
18651 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18652 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18653 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18654 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18655 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18656 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18657 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18658 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18659 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18660 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18661 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18662 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18663 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18664 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18665 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18666 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18670 pc256
[0] = SHA256M_A
;
18671 pc256
[1] = SHA256M_B
;
18672 pc256
[2] = SHA256M_C
;
18673 pc256
[3] = SHA256M_D
;
18674 pc256
[4] = SHA256M_E
;
18675 pc256
[5] = SHA256M_F
;
18676 pc256
[6] = SHA256M_G
;
18677 pc256
[7] = SHA256M_H
;
18679 sha256_64 (w
, pc256
);
18681 salt
->salt_buf_pc
[0] = pc256
[0];
18682 salt
->salt_buf_pc
[1] = pc256
[1];
18683 salt
->salt_buf_pc
[2] = pc256
[2];
18684 salt
->salt_buf_pc
[3] = pc256
[3];
18685 salt
->salt_buf_pc
[4] = pc256
[4];
18686 salt
->salt_buf_pc
[5] = pc256
[5];
18687 salt
->salt_buf_pc
[6] = pc256
[6];
18688 salt
->salt_buf_pc
[7] = pc256
[7];
18690 digest
[0] -= pc256
[0];
18691 digest
[1] -= pc256
[1];
18692 digest
[2] -= pc256
[2];
18693 digest
[3] -= pc256
[3];
18694 digest
[4] -= pc256
[4];
18695 digest
[5] -= pc256
[5];
18696 digest
[6] -= pc256
[6];
18697 digest
[7] -= pc256
[7];
18699 return (PARSER_OK
);
18702 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18704 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18706 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18708 u32
*digest
= (u32
*) hash_buf
->digest
;
18710 salt_t
*salt
= hash_buf
->salt
;
18716 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18718 char *data_buf_pos
= strchr (data_len_pos
, '$');
18720 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18722 u32 data_len_len
= data_buf_pos
- data_len_pos
;
18724 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18725 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18729 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18731 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
18733 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
18735 u32 data_len
= atoi (data_len_pos
);
18737 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
18743 char *salt_pos
= data_buf_pos
;
18745 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18746 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18747 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
18748 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
18750 // this is actually the CT, which is also the hash later (if matched)
18752 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
18753 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
18754 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
18755 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
18757 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
18759 salt
->salt_iter
= 10 - 1;
18765 digest
[0] = salt
->salt_buf
[4];
18766 digest
[1] = salt
->salt_buf
[5];
18767 digest
[2] = salt
->salt_buf
[6];
18768 digest
[3] = salt
->salt_buf
[7];
18770 return (PARSER_OK
);
18773 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18775 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
18777 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18779 u32
*digest
= (u32
*) hash_buf
->digest
;
18781 salt_t
*salt
= hash_buf
->salt
;
18787 char *salt_pos
= input_buf
+ 11 + 1;
18789 char *iter_pos
= strchr (salt_pos
, ',');
18791 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18793 u32 salt_len
= iter_pos
- salt_pos
;
18795 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
18799 char *hash_pos
= strchr (iter_pos
, ',');
18801 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18803 u32 iter_len
= hash_pos
- iter_pos
;
18805 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
18809 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
18811 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
18817 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18818 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18819 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
18820 salt
->salt_buf
[3] = 0x00018000;
18822 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18823 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18824 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
18825 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
18827 salt
->salt_len
= salt_len
/ 2;
18829 salt
->salt_iter
= atoi (iter_pos
) - 1;
18835 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18836 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18837 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18838 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18839 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18840 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
18841 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
18842 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
18844 return (PARSER_OK
);
18847 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18849 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
18851 u32
*digest
= (u32
*) hash_buf
->digest
;
18853 salt_t
*salt
= hash_buf
->salt
;
18859 char *hash_pos
= input_buf
+ 64;
18860 char *salt1_pos
= input_buf
+ 128;
18861 char *salt2_pos
= input_buf
;
18867 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
18868 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
18869 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
18870 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
18872 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
18873 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
18874 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
18875 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
18877 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
18878 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
18879 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
18880 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
18882 salt
->salt_len
= 48;
18884 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
18890 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18891 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18892 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18893 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18894 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18895 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
18896 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
18897 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
18899 return (PARSER_OK
);
18903 * parallel running threads
18908 BOOL WINAPI
sigHandler_default (DWORD sig
)
18912 case CTRL_CLOSE_EVENT
:
18915 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
18916 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
18917 * function otherwise it is to late (e.g. after returning from this function)
18922 SetConsoleCtrlHandler (NULL
, TRUE
);
18929 case CTRL_LOGOFF_EVENT
:
18930 case CTRL_SHUTDOWN_EVENT
:
18934 SetConsoleCtrlHandler (NULL
, TRUE
);
18942 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
18946 case CTRL_CLOSE_EVENT
:
18950 SetConsoleCtrlHandler (NULL
, TRUE
);
18957 case CTRL_LOGOFF_EVENT
:
18958 case CTRL_SHUTDOWN_EVENT
:
18962 SetConsoleCtrlHandler (NULL
, TRUE
);
18970 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
18972 if (callback
== NULL
)
18974 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
18978 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
18984 void sigHandler_default (int sig
)
18988 signal (sig
, NULL
);
18991 void sigHandler_benchmark (int sig
)
18995 signal (sig
, NULL
);
18998 void hc_signal (void (callback
) (int))
19000 if (callback
== NULL
) callback
= SIG_DFL
;
19002 signal (SIGINT
, callback
);
19003 signal (SIGTERM
, callback
);
19004 signal (SIGABRT
, callback
);
19009 void status_display ();
19011 void *thread_keypress (void *p
)
19013 int benchmark
= *((int *) p
);
19015 uint quiet
= data
.quiet
;
19019 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19021 int ch
= tty_getchar();
19023 if (ch
== -1) break;
19025 if (ch
== 0) continue;
19031 hc_thread_mutex_lock (mux_display
);
19046 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19047 if (quiet
== 0) fflush (stdout
);
19059 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19060 if (quiet
== 0) fflush (stdout
);
19072 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19073 if (quiet
== 0) fflush (stdout
);
19085 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19086 if (quiet
== 0) fflush (stdout
);
19094 if (benchmark
== 1) break;
19096 stop_at_checkpoint ();
19100 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19101 if (quiet
== 0) fflush (stdout
);
19109 if (benchmark
== 1)
19121 hc_thread_mutex_unlock (mux_display
);
19133 bool class_num (const u8 c
)
19135 return ((c
>= '0') && (c
<= '9'));
19138 bool class_lower (const u8 c
)
19140 return ((c
>= 'a') && (c
<= 'z'));
19143 bool class_upper (const u8 c
)
19145 return ((c
>= 'A') && (c
<= 'Z'));
19148 bool class_alpha (const u8 c
)
19150 return (class_lower (c
) || class_upper (c
));
19153 int conv_ctoi (const u8 c
)
19159 else if (class_upper (c
))
19161 return c
- 'A' + 10;
19167 int conv_itoc (const u8 c
)
19175 return c
+ 'A' - 10;
19185 #define INCR_POS if (++rule_pos == rule_len) return (-1)
19186 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
19187 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
19188 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
19189 #define MAX_KERNEL_RULES 255
19190 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
19191 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19192 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19194 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
19195 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
19196 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19197 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19199 int cpu_rule_to_kernel_rule (char rule_buf
[BUFSIZ
], uint rule_len
, kernel_rule_t
*rule
)
19204 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19206 switch (rule_buf
[rule_pos
])
19212 case RULE_OP_MANGLE_NOOP
:
19213 SET_NAME (rule
, rule_buf
[rule_pos
]);
19216 case RULE_OP_MANGLE_LREST
:
19217 SET_NAME (rule
, rule_buf
[rule_pos
]);
19220 case RULE_OP_MANGLE_UREST
:
19221 SET_NAME (rule
, rule_buf
[rule_pos
]);
19224 case RULE_OP_MANGLE_LREST_UFIRST
:
19225 SET_NAME (rule
, rule_buf
[rule_pos
]);
19228 case RULE_OP_MANGLE_UREST_LFIRST
:
19229 SET_NAME (rule
, rule_buf
[rule_pos
]);
19232 case RULE_OP_MANGLE_TREST
:
19233 SET_NAME (rule
, rule_buf
[rule_pos
]);
19236 case RULE_OP_MANGLE_TOGGLE_AT
:
19237 SET_NAME (rule
, rule_buf
[rule_pos
]);
19238 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19241 case RULE_OP_MANGLE_REVERSE
:
19242 SET_NAME (rule
, rule_buf
[rule_pos
]);
19245 case RULE_OP_MANGLE_DUPEWORD
:
19246 SET_NAME (rule
, rule_buf
[rule_pos
]);
19249 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19250 SET_NAME (rule
, rule_buf
[rule_pos
]);
19251 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19254 case RULE_OP_MANGLE_REFLECT
:
19255 SET_NAME (rule
, rule_buf
[rule_pos
]);
19258 case RULE_OP_MANGLE_ROTATE_LEFT
:
19259 SET_NAME (rule
, rule_buf
[rule_pos
]);
19262 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19263 SET_NAME (rule
, rule_buf
[rule_pos
]);
19266 case RULE_OP_MANGLE_APPEND
:
19267 SET_NAME (rule
, rule_buf
[rule_pos
]);
19268 SET_P0 (rule
, rule_buf
[rule_pos
]);
19271 case RULE_OP_MANGLE_PREPEND
:
19272 SET_NAME (rule
, rule_buf
[rule_pos
]);
19273 SET_P0 (rule
, rule_buf
[rule_pos
]);
19276 case RULE_OP_MANGLE_DELETE_FIRST
:
19277 SET_NAME (rule
, rule_buf
[rule_pos
]);
19280 case RULE_OP_MANGLE_DELETE_LAST
:
19281 SET_NAME (rule
, rule_buf
[rule_pos
]);
19284 case RULE_OP_MANGLE_DELETE_AT
:
19285 SET_NAME (rule
, rule_buf
[rule_pos
]);
19286 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19289 case RULE_OP_MANGLE_EXTRACT
:
19290 SET_NAME (rule
, rule_buf
[rule_pos
]);
19291 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19292 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19295 case RULE_OP_MANGLE_OMIT
:
19296 SET_NAME (rule
, rule_buf
[rule_pos
]);
19297 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19298 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19301 case RULE_OP_MANGLE_INSERT
:
19302 SET_NAME (rule
, rule_buf
[rule_pos
]);
19303 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19304 SET_P1 (rule
, rule_buf
[rule_pos
]);
19307 case RULE_OP_MANGLE_OVERSTRIKE
:
19308 SET_NAME (rule
, rule_buf
[rule_pos
]);
19309 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19310 SET_P1 (rule
, rule_buf
[rule_pos
]);
19313 case RULE_OP_MANGLE_TRUNCATE_AT
:
19314 SET_NAME (rule
, rule_buf
[rule_pos
]);
19315 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19318 case RULE_OP_MANGLE_REPLACE
:
19319 SET_NAME (rule
, rule_buf
[rule_pos
]);
19320 SET_P0 (rule
, rule_buf
[rule_pos
]);
19321 SET_P1 (rule
, rule_buf
[rule_pos
]);
19324 case RULE_OP_MANGLE_PURGECHAR
:
19328 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19332 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19333 SET_NAME (rule
, rule_buf
[rule_pos
]);
19334 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19337 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19338 SET_NAME (rule
, rule_buf
[rule_pos
]);
19339 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19342 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19343 SET_NAME (rule
, rule_buf
[rule_pos
]);
19346 case RULE_OP_MANGLE_SWITCH_FIRST
:
19347 SET_NAME (rule
, rule_buf
[rule_pos
]);
19350 case RULE_OP_MANGLE_SWITCH_LAST
:
19351 SET_NAME (rule
, rule_buf
[rule_pos
]);
19354 case RULE_OP_MANGLE_SWITCH_AT
:
19355 SET_NAME (rule
, rule_buf
[rule_pos
]);
19356 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19357 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19360 case RULE_OP_MANGLE_CHR_SHIFTL
:
19361 SET_NAME (rule
, rule_buf
[rule_pos
]);
19362 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19365 case RULE_OP_MANGLE_CHR_SHIFTR
:
19366 SET_NAME (rule
, rule_buf
[rule_pos
]);
19367 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19370 case RULE_OP_MANGLE_CHR_INCR
:
19371 SET_NAME (rule
, rule_buf
[rule_pos
]);
19372 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19375 case RULE_OP_MANGLE_CHR_DECR
:
19376 SET_NAME (rule
, rule_buf
[rule_pos
]);
19377 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19380 case RULE_OP_MANGLE_REPLACE_NP1
:
19381 SET_NAME (rule
, rule_buf
[rule_pos
]);
19382 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19385 case RULE_OP_MANGLE_REPLACE_NM1
:
19386 SET_NAME (rule
, rule_buf
[rule_pos
]);
19387 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19390 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19391 SET_NAME (rule
, rule_buf
[rule_pos
]);
19392 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19395 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19396 SET_NAME (rule
, rule_buf
[rule_pos
]);
19397 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19400 case RULE_OP_MANGLE_TITLE
:
19401 SET_NAME (rule
, rule_buf
[rule_pos
]);
19410 if (rule_pos
< rule_len
) return (-1);
19415 int kernel_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], kernel_rule_t
*rule
)
19419 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19423 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19427 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19431 case RULE_OP_MANGLE_NOOP
:
19432 rule_buf
[rule_pos
] = rule_cmd
;
19435 case RULE_OP_MANGLE_LREST
:
19436 rule_buf
[rule_pos
] = rule_cmd
;
19439 case RULE_OP_MANGLE_UREST
:
19440 rule_buf
[rule_pos
] = rule_cmd
;
19443 case RULE_OP_MANGLE_LREST_UFIRST
:
19444 rule_buf
[rule_pos
] = rule_cmd
;
19447 case RULE_OP_MANGLE_UREST_LFIRST
:
19448 rule_buf
[rule_pos
] = rule_cmd
;
19451 case RULE_OP_MANGLE_TREST
:
19452 rule_buf
[rule_pos
] = rule_cmd
;
19455 case RULE_OP_MANGLE_TOGGLE_AT
:
19456 rule_buf
[rule_pos
] = rule_cmd
;
19457 GET_P0_CONV (rule
);
19460 case RULE_OP_MANGLE_REVERSE
:
19461 rule_buf
[rule_pos
] = rule_cmd
;
19464 case RULE_OP_MANGLE_DUPEWORD
:
19465 rule_buf
[rule_pos
] = rule_cmd
;
19468 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19469 rule_buf
[rule_pos
] = rule_cmd
;
19470 GET_P0_CONV (rule
);
19473 case RULE_OP_MANGLE_REFLECT
:
19474 rule_buf
[rule_pos
] = rule_cmd
;
19477 case RULE_OP_MANGLE_ROTATE_LEFT
:
19478 rule_buf
[rule_pos
] = rule_cmd
;
19481 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19482 rule_buf
[rule_pos
] = rule_cmd
;
19485 case RULE_OP_MANGLE_APPEND
:
19486 rule_buf
[rule_pos
] = rule_cmd
;
19490 case RULE_OP_MANGLE_PREPEND
:
19491 rule_buf
[rule_pos
] = rule_cmd
;
19495 case RULE_OP_MANGLE_DELETE_FIRST
:
19496 rule_buf
[rule_pos
] = rule_cmd
;
19499 case RULE_OP_MANGLE_DELETE_LAST
:
19500 rule_buf
[rule_pos
] = rule_cmd
;
19503 case RULE_OP_MANGLE_DELETE_AT
:
19504 rule_buf
[rule_pos
] = rule_cmd
;
19505 GET_P0_CONV (rule
);
19508 case RULE_OP_MANGLE_EXTRACT
:
19509 rule_buf
[rule_pos
] = rule_cmd
;
19510 GET_P0_CONV (rule
);
19511 GET_P1_CONV (rule
);
19514 case RULE_OP_MANGLE_OMIT
:
19515 rule_buf
[rule_pos
] = rule_cmd
;
19516 GET_P0_CONV (rule
);
19517 GET_P1_CONV (rule
);
19520 case RULE_OP_MANGLE_INSERT
:
19521 rule_buf
[rule_pos
] = rule_cmd
;
19522 GET_P0_CONV (rule
);
19526 case RULE_OP_MANGLE_OVERSTRIKE
:
19527 rule_buf
[rule_pos
] = rule_cmd
;
19528 GET_P0_CONV (rule
);
19532 case RULE_OP_MANGLE_TRUNCATE_AT
:
19533 rule_buf
[rule_pos
] = rule_cmd
;
19534 GET_P0_CONV (rule
);
19537 case RULE_OP_MANGLE_REPLACE
:
19538 rule_buf
[rule_pos
] = rule_cmd
;
19543 case RULE_OP_MANGLE_PURGECHAR
:
19547 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19551 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19552 rule_buf
[rule_pos
] = rule_cmd
;
19553 GET_P0_CONV (rule
);
19556 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19557 rule_buf
[rule_pos
] = rule_cmd
;
19558 GET_P0_CONV (rule
);
19561 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19562 rule_buf
[rule_pos
] = rule_cmd
;
19565 case RULE_OP_MANGLE_SWITCH_FIRST
:
19566 rule_buf
[rule_pos
] = rule_cmd
;
19569 case RULE_OP_MANGLE_SWITCH_LAST
:
19570 rule_buf
[rule_pos
] = rule_cmd
;
19573 case RULE_OP_MANGLE_SWITCH_AT
:
19574 rule_buf
[rule_pos
] = rule_cmd
;
19575 GET_P0_CONV (rule
);
19576 GET_P1_CONV (rule
);
19579 case RULE_OP_MANGLE_CHR_SHIFTL
:
19580 rule_buf
[rule_pos
] = rule_cmd
;
19581 GET_P0_CONV (rule
);
19584 case RULE_OP_MANGLE_CHR_SHIFTR
:
19585 rule_buf
[rule_pos
] = rule_cmd
;
19586 GET_P0_CONV (rule
);
19589 case RULE_OP_MANGLE_CHR_INCR
:
19590 rule_buf
[rule_pos
] = rule_cmd
;
19591 GET_P0_CONV (rule
);
19594 case RULE_OP_MANGLE_CHR_DECR
:
19595 rule_buf
[rule_pos
] = rule_cmd
;
19596 GET_P0_CONV (rule
);
19599 case RULE_OP_MANGLE_REPLACE_NP1
:
19600 rule_buf
[rule_pos
] = rule_cmd
;
19601 GET_P0_CONV (rule
);
19604 case RULE_OP_MANGLE_REPLACE_NM1
:
19605 rule_buf
[rule_pos
] = rule_cmd
;
19606 GET_P0_CONV (rule
);
19609 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19610 rule_buf
[rule_pos
] = rule_cmd
;
19611 GET_P0_CONV (rule
);
19614 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19615 rule_buf
[rule_pos
] = rule_cmd
;
19616 GET_P0_CONV (rule
);
19619 case RULE_OP_MANGLE_TITLE
:
19620 rule_buf
[rule_pos
] = rule_cmd
;
19624 return rule_pos
- 1;
19642 * CPU rules : this is from hashcat sources, cpu based rules
19645 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19646 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19648 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19649 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19650 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19652 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19653 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19654 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19656 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19660 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19665 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19669 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19674 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19678 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19683 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19688 for (l
= 0; l
< arr_len
; l
++)
19690 r
= arr_len
- 1 - l
;
19694 MANGLE_SWITCH (arr
, l
, r
);
19700 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19702 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19704 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19706 return (arr_len
* 2);
19709 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19711 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19713 int orig_len
= arr_len
;
19717 for (i
= 0; i
< times
; i
++)
19719 memcpy (&arr
[arr_len
], arr
, orig_len
);
19721 arr_len
+= orig_len
;
19727 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19729 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19731 mangle_double (arr
, arr_len
);
19733 mangle_reverse (arr
+ arr_len
, arr_len
);
19735 return (arr_len
* 2);
19738 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
19743 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
19745 MANGLE_SWITCH (arr
, l
, r
);
19751 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
19756 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
19758 MANGLE_SWITCH (arr
, l
, r
);
19764 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19766 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19770 return (arr_len
+ 1);
19773 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19775 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19779 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19781 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19786 return (arr_len
+ 1);
19789 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19791 if (upos
>= arr_len
) return (arr_len
);
19795 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
19797 arr
[arr_pos
] = arr
[arr_pos
+ 1];
19800 return (arr_len
- 1);
19803 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19805 if (upos
>= arr_len
) return (arr_len
);
19807 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
19811 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
19813 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
19819 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19821 if (upos
>= arr_len
) return (arr_len
);
19823 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
19827 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
19829 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
19832 return (arr_len
- ulen
);
19835 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19837 if (upos
>= arr_len
) return (arr_len
);
19839 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19843 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
19845 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19850 return (arr_len
+ 1);
19853 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
)
19855 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
19857 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
19859 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
19861 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
19863 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
19865 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
19867 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
19869 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
19871 return (arr_len
+ arr2_cpy
);
19874 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19876 if (upos
>= arr_len
) return (arr_len
);
19883 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19885 if (upos
>= arr_len
) return (arr_len
);
19887 memset (arr
+ upos
, 0, arr_len
- upos
);
19892 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
19896 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19898 if (arr
[arr_pos
] != oldc
) continue;
19900 arr
[arr_pos
] = newc
;
19906 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19912 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19914 if (arr
[arr_pos
] == c
) continue;
19916 arr
[ret_len
] = arr
[arr_pos
];
19924 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19926 if (ulen
> arr_len
) return (arr_len
);
19928 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19932 memcpy (cs
, arr
, ulen
);
19936 for (i
= 0; i
< ulen
; i
++)
19940 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
19946 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19948 if (ulen
> arr_len
) return (arr_len
);
19950 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19952 int upos
= arr_len
- ulen
;
19956 for (i
= 0; i
< ulen
; i
++)
19958 char c
= arr
[upos
+ i
];
19960 arr_len
= mangle_append (arr
, arr_len
, c
);
19966 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19968 if ( arr_len
== 0) return (arr_len
);
19969 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19971 char c
= arr
[upos
];
19975 for (i
= 0; i
< ulen
; i
++)
19977 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
19983 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
19985 if ( arr_len
== 0) return (arr_len
);
19986 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19990 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19992 int new_pos
= arr_pos
* 2;
19994 arr
[new_pos
] = arr
[arr_pos
];
19996 arr
[new_pos
+ 1] = arr
[arr_pos
];
19999 return (arr_len
* 2);
20002 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20004 if (upos
>= arr_len
) return (arr_len
);
20005 if (upos2
>= arr_len
) return (arr_len
);
20007 MANGLE_SWITCH (arr
, upos
, upos2
);
20012 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20014 MANGLE_SWITCH (arr
, upos
, upos2
);
20019 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20021 if (upos
>= arr_len
) return (arr_len
);
20028 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20030 if (upos
>= arr_len
) return (arr_len
);
20037 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20039 if (upos
>= arr_len
) return (arr_len
);
20046 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20048 if (upos
>= arr_len
) return (arr_len
);
20055 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20057 int upper_next
= 1;
20061 for (pos
= 0; pos
< arr_len
; pos
++)
20063 if (arr
[pos
] == ' ')
20074 MANGLE_UPPER_AT (arr
, pos
);
20078 MANGLE_LOWER_AT (arr
, pos
);
20085 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20087 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20093 for (j
= 0; j
< rp_gen_num
; j
++)
20100 switch ((char) get_random_num (0, 9))
20103 r
= get_random_num (0, sizeof (grp_op_nop
));
20104 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20108 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20109 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20110 p1
= get_random_num (0, sizeof (grp_pos
));
20111 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20115 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20116 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20117 p1
= get_random_num (1, 6);
20118 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20122 r
= get_random_num (0, sizeof (grp_op_chr
));
20123 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20124 p1
= get_random_num (0x20, 0x7e);
20125 rule_buf
[rule_pos
++] = (char) p1
;
20129 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20130 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20131 p1
= get_random_num (0x20, 0x7e);
20132 rule_buf
[rule_pos
++] = (char) p1
;
20133 p2
= get_random_num (0x20, 0x7e);
20135 p2
= get_random_num (0x20, 0x7e);
20136 rule_buf
[rule_pos
++] = (char) p2
;
20140 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20141 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20142 p1
= get_random_num (0, sizeof (grp_pos
));
20143 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20144 p2
= get_random_num (0x20, 0x7e);
20145 rule_buf
[rule_pos
++] = (char) p2
;
20149 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20150 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20151 p1
= get_random_num (0, sizeof (grp_pos
));
20152 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20153 p2
= get_random_num (0, sizeof (grp_pos
));
20155 p2
= get_random_num (0, sizeof (grp_pos
));
20156 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20160 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20161 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
20162 p1
= get_random_num (0, sizeof (grp_pos
));
20163 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20164 p2
= get_random_num (1, sizeof (grp_pos
));
20166 p2
= get_random_num (1, sizeof (grp_pos
));
20167 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20171 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
20172 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
20173 p1
= get_random_num (0, sizeof (grp_pos
));
20174 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20175 p2
= get_random_num (1, sizeof (grp_pos
));
20176 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20177 p3
= get_random_num (0, sizeof (grp_pos
));
20178 rule_buf
[rule_pos
++] = grp_pos
[p3
];
20186 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
20188 char mem
[BLOCK_SIZE
];
20190 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
20192 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
20194 if (in_len
< 1) return (RULE_RC_REJECT_ERROR
);
20196 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
20198 int out_len
= in_len
;
20199 int mem_len
= in_len
;
20201 memcpy (out
, in
, out_len
);
20205 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
20207 int upos
; int upos2
;
20210 switch (rule
[rule_pos
])
20215 case RULE_OP_MANGLE_NOOP
:
20218 case RULE_OP_MANGLE_LREST
:
20219 out_len
= mangle_lrest (out
, out_len
);
20222 case RULE_OP_MANGLE_UREST
:
20223 out_len
= mangle_urest (out
, out_len
);
20226 case RULE_OP_MANGLE_LREST_UFIRST
:
20227 out_len
= mangle_lrest (out
, out_len
);
20228 if (out_len
) MANGLE_UPPER_AT (out
, 0);
20231 case RULE_OP_MANGLE_UREST_LFIRST
:
20232 out_len
= mangle_urest (out
, out_len
);
20233 if (out_len
) MANGLE_LOWER_AT (out
, 0);
20236 case RULE_OP_MANGLE_TREST
:
20237 out_len
= mangle_trest (out
, out_len
);
20240 case RULE_OP_MANGLE_TOGGLE_AT
:
20241 NEXT_RULEPOS (rule_pos
);
20242 NEXT_RPTOI (rule
, rule_pos
, upos
);
20243 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
20246 case RULE_OP_MANGLE_REVERSE
:
20247 out_len
= mangle_reverse (out
, out_len
);
20250 case RULE_OP_MANGLE_DUPEWORD
:
20251 out_len
= mangle_double (out
, out_len
);
20254 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20255 NEXT_RULEPOS (rule_pos
);
20256 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20257 out_len
= mangle_double_times (out
, out_len
, ulen
);
20260 case RULE_OP_MANGLE_REFLECT
:
20261 out_len
= mangle_reflect (out
, out_len
);
20264 case RULE_OP_MANGLE_ROTATE_LEFT
:
20265 mangle_rotate_left (out
, out_len
);
20268 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20269 mangle_rotate_right (out
, out_len
);
20272 case RULE_OP_MANGLE_APPEND
:
20273 NEXT_RULEPOS (rule_pos
);
20274 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
20277 case RULE_OP_MANGLE_PREPEND
:
20278 NEXT_RULEPOS (rule_pos
);
20279 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
20282 case RULE_OP_MANGLE_DELETE_FIRST
:
20283 out_len
= mangle_delete_at (out
, out_len
, 0);
20286 case RULE_OP_MANGLE_DELETE_LAST
:
20287 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
20290 case RULE_OP_MANGLE_DELETE_AT
:
20291 NEXT_RULEPOS (rule_pos
);
20292 NEXT_RPTOI (rule
, rule_pos
, upos
);
20293 out_len
= mangle_delete_at (out
, out_len
, upos
);
20296 case RULE_OP_MANGLE_EXTRACT
:
20297 NEXT_RULEPOS (rule_pos
);
20298 NEXT_RPTOI (rule
, rule_pos
, upos
);
20299 NEXT_RULEPOS (rule_pos
);
20300 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20301 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
20304 case RULE_OP_MANGLE_OMIT
:
20305 NEXT_RULEPOS (rule_pos
);
20306 NEXT_RPTOI (rule
, rule_pos
, upos
);
20307 NEXT_RULEPOS (rule_pos
);
20308 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20309 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
20312 case RULE_OP_MANGLE_INSERT
:
20313 NEXT_RULEPOS (rule_pos
);
20314 NEXT_RPTOI (rule
, rule_pos
, upos
);
20315 NEXT_RULEPOS (rule_pos
);
20316 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
20319 case RULE_OP_MANGLE_OVERSTRIKE
:
20320 NEXT_RULEPOS (rule_pos
);
20321 NEXT_RPTOI (rule
, rule_pos
, upos
);
20322 NEXT_RULEPOS (rule_pos
);
20323 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20326 case RULE_OP_MANGLE_TRUNCATE_AT
:
20327 NEXT_RULEPOS (rule_pos
);
20328 NEXT_RPTOI (rule
, rule_pos
, upos
);
20329 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20332 case RULE_OP_MANGLE_REPLACE
:
20333 NEXT_RULEPOS (rule_pos
);
20334 NEXT_RULEPOS (rule_pos
);
20335 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20338 case RULE_OP_MANGLE_PURGECHAR
:
20339 NEXT_RULEPOS (rule_pos
);
20340 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20343 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20347 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20348 NEXT_RULEPOS (rule_pos
);
20349 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20350 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20353 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20354 NEXT_RULEPOS (rule_pos
);
20355 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20356 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20359 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20360 out_len
= mangle_dupechar (out
, out_len
);
20363 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20364 NEXT_RULEPOS (rule_pos
);
20365 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20366 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20369 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20370 NEXT_RULEPOS (rule_pos
);
20371 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20372 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20375 case RULE_OP_MANGLE_SWITCH_FIRST
:
20376 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20379 case RULE_OP_MANGLE_SWITCH_LAST
:
20380 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20383 case RULE_OP_MANGLE_SWITCH_AT
:
20384 NEXT_RULEPOS (rule_pos
);
20385 NEXT_RPTOI (rule
, rule_pos
, upos
);
20386 NEXT_RULEPOS (rule_pos
);
20387 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20388 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20391 case RULE_OP_MANGLE_CHR_SHIFTL
:
20392 NEXT_RULEPOS (rule_pos
);
20393 NEXT_RPTOI (rule
, rule_pos
, upos
);
20394 mangle_chr_shiftl (out
, out_len
, upos
);
20397 case RULE_OP_MANGLE_CHR_SHIFTR
:
20398 NEXT_RULEPOS (rule_pos
);
20399 NEXT_RPTOI (rule
, rule_pos
, upos
);
20400 mangle_chr_shiftr (out
, out_len
, upos
);
20403 case RULE_OP_MANGLE_CHR_INCR
:
20404 NEXT_RULEPOS (rule_pos
);
20405 NEXT_RPTOI (rule
, rule_pos
, upos
);
20406 mangle_chr_incr (out
, out_len
, upos
);
20409 case RULE_OP_MANGLE_CHR_DECR
:
20410 NEXT_RULEPOS (rule_pos
);
20411 NEXT_RPTOI (rule
, rule_pos
, upos
);
20412 mangle_chr_decr (out
, out_len
, upos
);
20415 case RULE_OP_MANGLE_REPLACE_NP1
:
20416 NEXT_RULEPOS (rule_pos
);
20417 NEXT_RPTOI (rule
, rule_pos
, upos
);
20418 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20421 case RULE_OP_MANGLE_REPLACE_NM1
:
20422 NEXT_RULEPOS (rule_pos
);
20423 NEXT_RPTOI (rule
, rule_pos
, upos
);
20424 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20427 case RULE_OP_MANGLE_TITLE
:
20428 out_len
= mangle_title (out
, out_len
);
20431 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20432 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20433 NEXT_RULEPOS (rule_pos
);
20434 NEXT_RPTOI (rule
, rule_pos
, upos
);
20435 NEXT_RULEPOS (rule_pos
);
20436 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20437 NEXT_RULEPOS (rule_pos
);
20438 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20439 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20442 case RULE_OP_MANGLE_APPEND_MEMORY
:
20443 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20444 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20445 memcpy (out
+ out_len
, mem
, mem_len
);
20446 out_len
+= mem_len
;
20449 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20450 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20451 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20452 memcpy (mem
+ mem_len
, out
, out_len
);
20453 out_len
+= mem_len
;
20454 memcpy (out
, mem
, out_len
);
20457 case RULE_OP_MEMORIZE_WORD
:
20458 memcpy (mem
, out
, out_len
);
20462 case RULE_OP_REJECT_LESS
:
20463 NEXT_RULEPOS (rule_pos
);
20464 NEXT_RPTOI (rule
, rule_pos
, upos
);
20465 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20468 case RULE_OP_REJECT_GREATER
:
20469 NEXT_RULEPOS (rule_pos
);
20470 NEXT_RPTOI (rule
, rule_pos
, upos
);
20471 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20474 case RULE_OP_REJECT_CONTAIN
:
20475 NEXT_RULEPOS (rule_pos
);
20476 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20479 case RULE_OP_REJECT_NOT_CONTAIN
:
20480 NEXT_RULEPOS (rule_pos
);
20481 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20484 case RULE_OP_REJECT_EQUAL_FIRST
:
20485 NEXT_RULEPOS (rule_pos
);
20486 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20489 case RULE_OP_REJECT_EQUAL_LAST
:
20490 NEXT_RULEPOS (rule_pos
);
20491 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20494 case RULE_OP_REJECT_EQUAL_AT
:
20495 NEXT_RULEPOS (rule_pos
);
20496 NEXT_RPTOI (rule
, rule_pos
, upos
);
20497 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20498 NEXT_RULEPOS (rule_pos
);
20499 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20502 case RULE_OP_REJECT_CONTAINS
:
20503 NEXT_RULEPOS (rule_pos
);
20504 NEXT_RPTOI (rule
, rule_pos
, upos
);
20505 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20506 NEXT_RULEPOS (rule_pos
);
20507 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20508 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20511 case RULE_OP_REJECT_MEMORY
:
20512 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20516 return (RULE_RC_SYNTAX_ERROR
);
20521 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);