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
> 31)
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 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5142 cl_device_type device_types_filter
= 0;
5144 if (opencl_device_types
)
5146 char *device_types
= strdup (opencl_device_types
);
5148 char *next
= strtok (device_types
, ",");
5152 int device_type
= atoi (next
);
5154 if (device_type
< 1 || device_type
> 3)
5156 log_error ("ERROR: invalid device_type %u specified", device_type
);
5161 device_types_filter
|= 1 << device_type
;
5163 } while ((next
= strtok (NULL
, ",")) != NULL
);
5165 free (device_types
);
5169 // Do not use CPU by default, this often reduces GPU performance because
5170 // the CPU is to busy to handle GPU synchronization
5172 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5175 return device_types_filter
;
5178 uint
devices_to_devicemask (char *opencl_devices
)
5180 uint opencl_devicemask
= 0;
5184 char *devices
= strdup (opencl_devices
);
5186 char *next
= strtok (devices
, ",");
5190 uint device_id
= atoi (next
);
5192 if (device_id
< 1 || device_id
> 8)
5194 log_error ("ERROR: invalid device_id %u specified", device_id
);
5199 opencl_devicemask
|= 1 << (device_id
- 1);
5201 } while ((next
= strtok (NULL
, ",")) != NULL
);
5206 return opencl_devicemask
;
5209 u32
get_random_num (const u32 min
, const u32 max
)
5211 if (min
== max
) return (min
);
5213 return ((rand () % (max
- min
)) + min
);
5216 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5218 u32 quotient
= dividend
/ divisor
;
5220 if (dividend
% divisor
) quotient
++;
5225 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5227 u64 quotient
= dividend
/ divisor
;
5229 if (dividend
% divisor
) quotient
++;
5234 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5236 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5237 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5239 if (tm
->tm_year
- 70)
5241 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5242 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5244 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5246 else if (tm
->tm_yday
)
5248 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5249 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5251 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5253 else if (tm
->tm_hour
)
5255 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5256 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5258 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5260 else if (tm
->tm_min
)
5262 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5263 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5265 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5269 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5271 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5275 void format_speed_display (float val
, char *buf
, size_t len
)
5286 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5297 /* generate output */
5301 snprintf (buf
, len
- 1, "%.0f ", val
);
5305 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5309 void lowercase (u8
*buf
, int len
)
5311 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5314 void uppercase (u8
*buf
, int len
)
5316 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5319 int fgetl (FILE *fp
, char *line_buf
)
5325 const int c
= fgetc (fp
);
5327 if (c
== EOF
) break;
5329 line_buf
[line_len
] = (char) c
;
5333 if (line_len
== BUFSIZ
) line_len
--;
5335 if (c
== '\n') break;
5338 if (line_len
== 0) return 0;
5340 if (line_buf
[line_len
- 1] == '\n')
5344 line_buf
[line_len
] = 0;
5347 if (line_len
== 0) return 0;
5349 if (line_buf
[line_len
- 1] == '\r')
5353 line_buf
[line_len
] = 0;
5359 int in_superchop (char *buf
)
5361 int len
= strlen (buf
);
5365 if (buf
[len
- 1] == '\n')
5372 if (buf
[len
- 1] == '\r')
5387 char **scan_directory (const char *path
)
5389 char *tmp_path
= mystrdup (path
);
5391 size_t tmp_path_len
= strlen (tmp_path
);
5393 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5395 tmp_path
[tmp_path_len
- 1] = 0;
5397 tmp_path_len
= strlen (tmp_path
);
5400 char **files
= NULL
;
5406 if ((d
= opendir (tmp_path
)) != NULL
)
5410 while ((de
= readdir (d
)) != NULL
)
5412 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5414 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5416 char *path_file
= (char *) mymalloc (path_size
+ 1);
5418 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5420 path_file
[path_size
] = 0;
5424 if ((d_test
= opendir (path_file
)) != NULL
)
5432 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5436 files
[num_files
- 1] = path_file
;
5442 else if (errno
== ENOTDIR
)
5444 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5448 files
[num_files
- 1] = mystrdup (path
);
5451 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5455 files
[num_files
- 1] = NULL
;
5462 int count_dictionaries (char **dictionary_files
)
5464 if (dictionary_files
== NULL
) return 0;
5468 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5476 char *stroptitype (const uint opti_type
)
5480 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5481 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5482 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5483 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5484 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5485 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5486 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5487 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5488 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5489 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5490 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5491 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5492 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5493 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5499 char *strparser (const uint parser_status
)
5501 switch (parser_status
)
5503 case PARSER_OK
: return ((char *) PA_000
); break;
5504 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5505 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5506 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5507 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5508 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5509 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5510 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5511 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5512 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5513 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5514 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5515 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5516 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5517 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5518 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5519 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5522 return ((char *) PA_255
);
5525 char *strhashtype (const uint hash_mode
)
5529 case 0: return ((char *) HT_00000
); break;
5530 case 10: return ((char *) HT_00010
); break;
5531 case 11: return ((char *) HT_00011
); break;
5532 case 12: return ((char *) HT_00012
); break;
5533 case 20: return ((char *) HT_00020
); break;
5534 case 21: return ((char *) HT_00021
); break;
5535 case 22: return ((char *) HT_00022
); break;
5536 case 23: return ((char *) HT_00023
); break;
5537 case 30: return ((char *) HT_00030
); break;
5538 case 40: return ((char *) HT_00040
); break;
5539 case 50: return ((char *) HT_00050
); break;
5540 case 60: return ((char *) HT_00060
); break;
5541 case 100: return ((char *) HT_00100
); break;
5542 case 101: return ((char *) HT_00101
); break;
5543 case 110: return ((char *) HT_00110
); break;
5544 case 111: return ((char *) HT_00111
); break;
5545 case 112: return ((char *) HT_00112
); break;
5546 case 120: return ((char *) HT_00120
); break;
5547 case 121: return ((char *) HT_00121
); break;
5548 case 122: return ((char *) HT_00122
); break;
5549 case 124: return ((char *) HT_00124
); break;
5550 case 130: return ((char *) HT_00130
); break;
5551 case 131: return ((char *) HT_00131
); break;
5552 case 132: return ((char *) HT_00132
); break;
5553 case 133: return ((char *) HT_00133
); break;
5554 case 140: return ((char *) HT_00140
); break;
5555 case 141: return ((char *) HT_00141
); break;
5556 case 150: return ((char *) HT_00150
); break;
5557 case 160: return ((char *) HT_00160
); break;
5558 case 190: return ((char *) HT_00190
); break;
5559 case 200: return ((char *) HT_00200
); break;
5560 case 300: return ((char *) HT_00300
); break;
5561 case 400: return ((char *) HT_00400
); break;
5562 case 500: return ((char *) HT_00500
); break;
5563 case 501: return ((char *) HT_00501
); break;
5564 case 900: return ((char *) HT_00900
); break;
5565 case 910: return ((char *) HT_00910
); break;
5566 case 1000: return ((char *) HT_01000
); break;
5567 case 1100: return ((char *) HT_01100
); break;
5568 case 1400: return ((char *) HT_01400
); break;
5569 case 1410: return ((char *) HT_01410
); break;
5570 case 1420: return ((char *) HT_01420
); break;
5571 case 1421: return ((char *) HT_01421
); break;
5572 case 1430: return ((char *) HT_01430
); break;
5573 case 1440: return ((char *) HT_01440
); break;
5574 case 1441: return ((char *) HT_01441
); break;
5575 case 1450: return ((char *) HT_01450
); break;
5576 case 1460: return ((char *) HT_01460
); break;
5577 case 1500: return ((char *) HT_01500
); break;
5578 case 1600: return ((char *) HT_01600
); break;
5579 case 1700: return ((char *) HT_01700
); break;
5580 case 1710: return ((char *) HT_01710
); break;
5581 case 1711: return ((char *) HT_01711
); break;
5582 case 1720: return ((char *) HT_01720
); break;
5583 case 1722: return ((char *) HT_01722
); break;
5584 case 1730: return ((char *) HT_01730
); break;
5585 case 1731: return ((char *) HT_01731
); break;
5586 case 1740: return ((char *) HT_01740
); break;
5587 case 1750: return ((char *) HT_01750
); break;
5588 case 1760: return ((char *) HT_01760
); break;
5589 case 1800: return ((char *) HT_01800
); break;
5590 case 2100: return ((char *) HT_02100
); break;
5591 case 2400: return ((char *) HT_02400
); break;
5592 case 2410: return ((char *) HT_02410
); break;
5593 case 2500: return ((char *) HT_02500
); break;
5594 case 2600: return ((char *) HT_02600
); break;
5595 case 2611: return ((char *) HT_02611
); break;
5596 case 2612: return ((char *) HT_02612
); break;
5597 case 2711: return ((char *) HT_02711
); break;
5598 case 2811: return ((char *) HT_02811
); break;
5599 case 3000: return ((char *) HT_03000
); break;
5600 case 3100: return ((char *) HT_03100
); break;
5601 case 3200: return ((char *) HT_03200
); break;
5602 case 3710: return ((char *) HT_03710
); break;
5603 case 3711: return ((char *) HT_03711
); break;
5604 case 3800: return ((char *) HT_03800
); break;
5605 case 4300: return ((char *) HT_04300
); break;
5606 case 4400: return ((char *) HT_04400
); break;
5607 case 4500: return ((char *) HT_04500
); break;
5608 case 4700: return ((char *) HT_04700
); break;
5609 case 4800: return ((char *) HT_04800
); break;
5610 case 4900: return ((char *) HT_04900
); break;
5611 case 5000: return ((char *) HT_05000
); break;
5612 case 5100: return ((char *) HT_05100
); break;
5613 case 5200: return ((char *) HT_05200
); break;
5614 case 5300: return ((char *) HT_05300
); break;
5615 case 5400: return ((char *) HT_05400
); break;
5616 case 5500: return ((char *) HT_05500
); break;
5617 case 5600: return ((char *) HT_05600
); break;
5618 case 5700: return ((char *) HT_05700
); break;
5619 case 5800: return ((char *) HT_05800
); break;
5620 case 6000: return ((char *) HT_06000
); break;
5621 case 6100: return ((char *) HT_06100
); break;
5622 case 6211: return ((char *) HT_06211
); break;
5623 case 6212: return ((char *) HT_06212
); break;
5624 case 6213: return ((char *) HT_06213
); break;
5625 case 6221: return ((char *) HT_06221
); break;
5626 case 6222: return ((char *) HT_06222
); break;
5627 case 6223: return ((char *) HT_06223
); break;
5628 case 6231: return ((char *) HT_06231
); break;
5629 case 6232: return ((char *) HT_06232
); break;
5630 case 6233: return ((char *) HT_06233
); break;
5631 case 6241: return ((char *) HT_06241
); break;
5632 case 6242: return ((char *) HT_06242
); break;
5633 case 6243: return ((char *) HT_06243
); break;
5634 case 6300: return ((char *) HT_06300
); break;
5635 case 6400: return ((char *) HT_06400
); break;
5636 case 6500: return ((char *) HT_06500
); break;
5637 case 6600: return ((char *) HT_06600
); break;
5638 case 6700: return ((char *) HT_06700
); break;
5639 case 6800: return ((char *) HT_06800
); break;
5640 case 6900: return ((char *) HT_06900
); break;
5641 case 7100: return ((char *) HT_07100
); break;
5642 case 7200: return ((char *) HT_07200
); break;
5643 case 7300: return ((char *) HT_07300
); break;
5644 case 7400: return ((char *) HT_07400
); break;
5645 case 7500: return ((char *) HT_07500
); break;
5646 case 7600: return ((char *) HT_07600
); break;
5647 case 7700: return ((char *) HT_07700
); break;
5648 case 7800: return ((char *) HT_07800
); break;
5649 case 7900: return ((char *) HT_07900
); break;
5650 case 8000: return ((char *) HT_08000
); break;
5651 case 8100: return ((char *) HT_08100
); break;
5652 case 8200: return ((char *) HT_08200
); break;
5653 case 8300: return ((char *) HT_08300
); break;
5654 case 8400: return ((char *) HT_08400
); break;
5655 case 8500: return ((char *) HT_08500
); break;
5656 case 8600: return ((char *) HT_08600
); break;
5657 case 8700: return ((char *) HT_08700
); break;
5658 case 8800: return ((char *) HT_08800
); break;
5659 case 8900: return ((char *) HT_08900
); break;
5660 case 9000: return ((char *) HT_09000
); break;
5661 case 9100: return ((char *) HT_09100
); break;
5662 case 9200: return ((char *) HT_09200
); break;
5663 case 9300: return ((char *) HT_09300
); break;
5664 case 9400: return ((char *) HT_09400
); break;
5665 case 9500: return ((char *) HT_09500
); break;
5666 case 9600: return ((char *) HT_09600
); break;
5667 case 9700: return ((char *) HT_09700
); break;
5668 case 9710: return ((char *) HT_09710
); break;
5669 case 9720: return ((char *) HT_09720
); break;
5670 case 9800: return ((char *) HT_09800
); break;
5671 case 9810: return ((char *) HT_09810
); break;
5672 case 9820: return ((char *) HT_09820
); break;
5673 case 9900: return ((char *) HT_09900
); break;
5674 case 10000: return ((char *) HT_10000
); break;
5675 case 10100: return ((char *) HT_10100
); break;
5676 case 10200: return ((char *) HT_10200
); break;
5677 case 10300: return ((char *) HT_10300
); break;
5678 case 10400: return ((char *) HT_10400
); break;
5679 case 10410: return ((char *) HT_10410
); break;
5680 case 10420: return ((char *) HT_10420
); break;
5681 case 10500: return ((char *) HT_10500
); break;
5682 case 10600: return ((char *) HT_10600
); break;
5683 case 10700: return ((char *) HT_10700
); break;
5684 case 10800: return ((char *) HT_10800
); break;
5685 case 10900: return ((char *) HT_10900
); break;
5686 case 11000: return ((char *) HT_11000
); break;
5687 case 11100: return ((char *) HT_11100
); break;
5688 case 11200: return ((char *) HT_11200
); break;
5689 case 11300: return ((char *) HT_11300
); break;
5690 case 11400: return ((char *) HT_11400
); break;
5691 case 11500: return ((char *) HT_11500
); break;
5692 case 11600: return ((char *) HT_11600
); break;
5693 case 11700: return ((char *) HT_11700
); break;
5694 case 11800: return ((char *) HT_11800
); break;
5695 case 11900: return ((char *) HT_11900
); break;
5696 case 12000: return ((char *) HT_12000
); break;
5697 case 12100: return ((char *) HT_12100
); break;
5698 case 12200: return ((char *) HT_12200
); break;
5699 case 12300: return ((char *) HT_12300
); break;
5700 case 12400: return ((char *) HT_12400
); break;
5701 case 12500: return ((char *) HT_12500
); break;
5702 case 12600: return ((char *) HT_12600
); break;
5703 case 12700: return ((char *) HT_12700
); break;
5704 case 12800: return ((char *) HT_12800
); break;
5705 case 12900: return ((char *) HT_12900
); break;
5706 case 13000: return ((char *) HT_13000
); break;
5709 return ((char *) "Unknown");
5712 char *strstatus (const uint devices_status
)
5714 switch (devices_status
)
5716 case STATUS_INIT
: return ((char *) ST_0000
); break;
5717 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5718 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5719 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5720 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5721 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5722 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5723 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5724 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5725 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5728 return ((char *) "Unknown");
5731 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5733 uint hash_type
= data
.hash_type
;
5734 uint hash_mode
= data
.hash_mode
;
5735 uint salt_type
= data
.salt_type
;
5736 uint opts_type
= data
.opts_type
;
5737 uint opti_type
= data
.opti_type
;
5738 uint dgst_size
= data
.dgst_size
;
5740 char *hashfile
= data
.hashfile
;
5744 uint digest_buf
[64];
5746 u64
*digest_buf64
= (u64
*) digest_buf
;
5748 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5750 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5752 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5758 case HASH_TYPE_DESCRYPT
:
5759 FP (digest_buf
[1], digest_buf
[0], tt
);
5762 case HASH_TYPE_DESRACF
:
5763 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5764 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5766 FP (digest_buf
[1], digest_buf
[0], tt
);
5770 FP (digest_buf
[1], digest_buf
[0], tt
);
5773 case HASH_TYPE_NETNTLM
:
5774 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5775 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5776 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5777 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5779 FP (digest_buf
[1], digest_buf
[0], tt
);
5780 FP (digest_buf
[3], digest_buf
[2], tt
);
5783 case HASH_TYPE_BSDICRYPT
:
5784 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5785 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5787 FP (digest_buf
[1], digest_buf
[0], tt
);
5792 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5797 digest_buf
[0] += MD4M_A
;
5798 digest_buf
[1] += MD4M_B
;
5799 digest_buf
[2] += MD4M_C
;
5800 digest_buf
[3] += MD4M_D
;
5804 digest_buf
[0] += MD5M_A
;
5805 digest_buf
[1] += MD5M_B
;
5806 digest_buf
[2] += MD5M_C
;
5807 digest_buf
[3] += MD5M_D
;
5810 case HASH_TYPE_SHA1
:
5811 digest_buf
[0] += SHA1M_A
;
5812 digest_buf
[1] += SHA1M_B
;
5813 digest_buf
[2] += SHA1M_C
;
5814 digest_buf
[3] += SHA1M_D
;
5815 digest_buf
[4] += SHA1M_E
;
5818 case HASH_TYPE_SHA256
:
5819 digest_buf
[0] += SHA256M_A
;
5820 digest_buf
[1] += SHA256M_B
;
5821 digest_buf
[2] += SHA256M_C
;
5822 digest_buf
[3] += SHA256M_D
;
5823 digest_buf
[4] += SHA256M_E
;
5824 digest_buf
[5] += SHA256M_F
;
5825 digest_buf
[6] += SHA256M_G
;
5826 digest_buf
[7] += SHA256M_H
;
5829 case HASH_TYPE_SHA384
:
5830 digest_buf64
[0] += SHA384M_A
;
5831 digest_buf64
[1] += SHA384M_B
;
5832 digest_buf64
[2] += SHA384M_C
;
5833 digest_buf64
[3] += SHA384M_D
;
5834 digest_buf64
[4] += SHA384M_E
;
5835 digest_buf64
[5] += SHA384M_F
;
5836 digest_buf64
[6] += 0;
5837 digest_buf64
[7] += 0;
5840 case HASH_TYPE_SHA512
:
5841 digest_buf64
[0] += SHA512M_A
;
5842 digest_buf64
[1] += SHA512M_B
;
5843 digest_buf64
[2] += SHA512M_C
;
5844 digest_buf64
[3] += SHA512M_D
;
5845 digest_buf64
[4] += SHA512M_E
;
5846 digest_buf64
[5] += SHA512M_F
;
5847 digest_buf64
[6] += SHA512M_G
;
5848 digest_buf64
[7] += SHA512M_H
;
5853 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
5855 if (dgst_size
== DGST_SIZE_4_2
)
5857 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5859 else if (dgst_size
== DGST_SIZE_4_4
)
5861 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5863 else if (dgst_size
== DGST_SIZE_4_5
)
5865 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5867 else if (dgst_size
== DGST_SIZE_4_6
)
5869 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5871 else if (dgst_size
== DGST_SIZE_4_8
)
5873 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5875 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
5877 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
5879 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5881 else if (hash_type
== HASH_TYPE_SHA384
)
5883 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5885 else if (hash_type
== HASH_TYPE_SHA512
)
5887 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5889 else if (hash_type
== HASH_TYPE_GOST
)
5891 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5894 else if (dgst_size
== DGST_SIZE_4_64
)
5896 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5898 else if (dgst_size
== DGST_SIZE_8_25
)
5900 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5904 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
5905 | (data
.salt_type
== SALT_TYPE_EXTERN
)
5906 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
5912 memset (&salt
, 0, sizeof (salt_t
));
5914 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
5916 char *ptr
= (char *) salt
.salt_buf
;
5918 uint len
= salt
.salt_len
;
5920 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5926 case HASH_TYPE_NETNTLM
:
5928 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
5929 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
5931 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
5937 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
5939 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
5947 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
5949 uint max
= salt
.salt_len
/ 4;
5953 for (uint i
= 0; i
< max
; i
++)
5955 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
5959 if (opts_type
& OPTS_TYPE_ST_HEX
)
5963 memset (tmp
, 0, sizeof (tmp
));
5965 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
5967 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
5972 memcpy (ptr
, tmp
, len
);
5975 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
5977 memset (ptr
+ len
, 0, memset_size
);
5979 salt
.salt_len
= len
;
5983 // some modes require special encoding
5986 uint out_buf_plain
[256];
5987 uint out_buf_salt
[256];
5991 memset (out_buf_plain
, 0, sizeof (out_buf_plain
));
5992 memset (out_buf_salt
, 0, sizeof (out_buf_salt
));
5994 memset (tmp_buf
, 0, sizeof (tmp_buf
));
5996 char *ptr_plain
= (char *) out_buf_plain
;
5997 char *ptr_salt
= (char *) out_buf_salt
;
5999 if (hash_mode
== 22)
6003 memset (username
, 0, sizeof (username
));
6005 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6007 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6009 u16
*ptr
= (u16
*) digest_buf
;
6011 tmp_buf
[ 0] = sig
[0];
6012 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6013 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6014 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6015 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6016 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6017 tmp_buf
[ 6] = sig
[1];
6018 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6019 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6020 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6021 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6022 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6023 tmp_buf
[12] = sig
[2];
6024 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6025 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6026 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6027 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6028 tmp_buf
[17] = sig
[3];
6029 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6030 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6031 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6032 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6033 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6034 tmp_buf
[23] = sig
[4];
6035 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6036 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6037 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6038 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6039 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6040 tmp_buf
[29] = sig
[5];
6042 snprintf (out_buf
, len
-1, "%s:%s",
6046 else if (hash_mode
== 23)
6048 // do not show the \nskyper\n part in output
6050 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6052 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6054 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6061 else if (hash_mode
== 101)
6063 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6065 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6066 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6067 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6068 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6069 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6071 memcpy (tmp_buf
, digest_buf
, 20);
6073 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6075 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6077 else if (hash_mode
== 111)
6079 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6081 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6082 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6083 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6084 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6085 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6087 memcpy (tmp_buf
, digest_buf
, 20);
6088 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6090 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6092 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6094 else if (hash_mode
== 122)
6096 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6097 (char *) salt
.salt_buf
,
6104 else if (hash_mode
== 124)
6106 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6107 (char *) salt
.salt_buf
,
6114 else if (hash_mode
== 131)
6116 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6117 (char *) salt
.salt_buf
,
6125 else if (hash_mode
== 132)
6127 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6128 (char *) salt
.salt_buf
,
6135 else if (hash_mode
== 133)
6137 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6139 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6140 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6141 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6142 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6143 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6145 memcpy (tmp_buf
, digest_buf
, 20);
6147 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6149 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6151 else if (hash_mode
== 141)
6153 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6155 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6157 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6159 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6161 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6162 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6163 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6164 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6165 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6167 memcpy (tmp_buf
, digest_buf
, 20);
6169 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6173 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6175 else if (hash_mode
== 400)
6177 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6179 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6180 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6181 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6182 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6184 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6186 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6188 else if (hash_mode
== 500)
6190 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6192 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6193 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6194 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6195 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6197 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6199 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6201 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6205 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6208 else if (hash_mode
== 501)
6210 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6212 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6213 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6215 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6217 else if (hash_mode
== 1421)
6219 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6221 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6237 else if (hash_mode
== 1441)
6239 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6241 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6243 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6245 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6247 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6248 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6249 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6250 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6251 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6252 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6253 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6254 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6256 memcpy (tmp_buf
, digest_buf
, 32);
6258 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6262 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6264 else if (hash_mode
== 1500)
6266 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6267 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6268 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6269 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6270 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6272 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6274 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6276 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6277 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6279 memcpy (tmp_buf
, digest_buf
, 8);
6281 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6283 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6287 else if (hash_mode
== 1600)
6289 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6291 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6292 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6293 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6294 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6296 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6298 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6300 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6304 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6307 else if (hash_mode
== 1711)
6309 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6311 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6312 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6313 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6314 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6315 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6316 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6317 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6318 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6320 memcpy (tmp_buf
, digest_buf
, 64);
6321 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6323 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6325 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6327 else if (hash_mode
== 1722)
6329 uint
*ptr
= digest_buf
;
6331 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6332 (unsigned char *) salt
.salt_buf
,
6342 else if (hash_mode
== 1731)
6344 uint
*ptr
= digest_buf
;
6346 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6347 (unsigned char *) salt
.salt_buf
,
6357 else if (hash_mode
== 1800)
6361 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6362 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6363 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6364 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6365 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6366 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6367 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6368 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6370 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6372 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6374 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6378 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6381 else if (hash_mode
== 2100)
6385 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6387 salt
.salt_iter
+ 1);
6389 uint signature_len
= strlen (out_buf
);
6391 pos
+= signature_len
;
6392 len
-= signature_len
;
6394 char *salt_ptr
= (char *) salt
.salt_buf
;
6396 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6398 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6399 byte_swap_32 (digest_buf
[0]),
6400 byte_swap_32 (digest_buf
[1]),
6401 byte_swap_32 (digest_buf
[2]),
6402 byte_swap_32 (digest_buf
[3]));
6404 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6406 memcpy (tmp_buf
, digest_buf
, 16);
6408 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6410 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6411 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6412 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6413 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6415 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6416 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6417 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6418 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6420 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6421 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6422 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6423 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6425 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6426 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6427 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6428 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6430 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6431 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6432 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6433 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6437 else if (hash_mode
== 2500)
6439 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6441 wpa_t
*wpa
= &wpas
[salt_pos
];
6445 char *pke_ptr
= (char *) pke
;
6447 for (uint i
= 0; i
< 25; i
++)
6449 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6452 unsigned char mac1
[6];
6453 unsigned char mac2
[6];
6455 memcpy (mac1
, pke_ptr
+ 23, 6);
6456 memcpy (mac2
, pke_ptr
+ 29, 6);
6458 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6459 (char *) salt
.salt_buf
,
6473 else if (hash_mode
== 4400)
6475 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6476 byte_swap_32 (digest_buf
[0]),
6477 byte_swap_32 (digest_buf
[1]),
6478 byte_swap_32 (digest_buf
[2]),
6479 byte_swap_32 (digest_buf
[3]));
6481 else if (hash_mode
== 4700)
6483 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6484 byte_swap_32 (digest_buf
[0]),
6485 byte_swap_32 (digest_buf
[1]),
6486 byte_swap_32 (digest_buf
[2]),
6487 byte_swap_32 (digest_buf
[3]),
6488 byte_swap_32 (digest_buf
[4]));
6490 else if (hash_mode
== 4800)
6492 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6494 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6499 byte_swap_32 (salt
.salt_buf
[0]),
6500 byte_swap_32 (salt
.salt_buf
[1]),
6501 byte_swap_32 (salt
.salt_buf
[2]),
6502 byte_swap_32 (salt
.salt_buf
[3]),
6505 else if (hash_mode
== 4900)
6507 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6508 byte_swap_32 (digest_buf
[0]),
6509 byte_swap_32 (digest_buf
[1]),
6510 byte_swap_32 (digest_buf
[2]),
6511 byte_swap_32 (digest_buf
[3]),
6512 byte_swap_32 (digest_buf
[4]));
6514 else if (hash_mode
== 5100)
6516 snprintf (out_buf
, len
-1, "%08x%08x",
6520 else if (hash_mode
== 5200)
6522 snprintf (out_buf
, len
-1, "%s", hashfile
);
6524 else if (hash_mode
== 5300)
6526 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6528 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6530 int buf_len
= len
-1;
6534 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6536 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6538 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6540 snprintf (out_buf
, buf_len
, ":");
6546 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6554 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6556 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6558 if ((i
== 0) || (i
== 5))
6560 snprintf (out_buf
, buf_len
, ":");
6566 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6574 for (uint i
= 0; i
< 4; i
++)
6578 snprintf (out_buf
, buf_len
, ":");
6584 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6590 else if (hash_mode
== 5400)
6592 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6594 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6596 int buf_len
= len
-1;
6600 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6602 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6604 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6606 snprintf (out_buf
, buf_len
, ":");
6612 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6620 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6622 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6624 if ((i
== 0) || (i
== 5))
6626 snprintf (out_buf
, buf_len
, ":");
6632 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6640 for (uint i
= 0; i
< 5; i
++)
6644 snprintf (out_buf
, buf_len
, ":");
6650 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6656 else if (hash_mode
== 5500)
6658 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6660 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6663 char domain_buf
[64];
6664 char srvchall_buf
[1024];
6665 char clichall_buf
[1024];
6667 memset (user_buf
, 0, sizeof (user_buf
));
6668 memset (domain_buf
, 0, sizeof (domain_buf
));
6669 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6670 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6672 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6674 char *ptr
= (char *) netntlm
->userdomain_buf
;
6676 user_buf
[i
] = ptr
[j
];
6679 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6681 char *ptr
= (char *) netntlm
->userdomain_buf
;
6683 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6686 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6688 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6690 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6693 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6695 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6697 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6700 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6708 byte_swap_32 (salt
.salt_buf_pc
[0]),
6709 byte_swap_32 (salt
.salt_buf_pc
[1]),
6712 else if (hash_mode
== 5600)
6714 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6716 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6719 char domain_buf
[64];
6720 char srvchall_buf
[1024];
6721 char clichall_buf
[1024];
6723 memset (user_buf
, 0, sizeof (user_buf
));
6724 memset (domain_buf
, 0, sizeof (domain_buf
));
6725 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6726 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6728 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6730 char *ptr
= (char *) netntlm
->userdomain_buf
;
6732 user_buf
[i
] = ptr
[j
];
6735 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6737 char *ptr
= (char *) netntlm
->userdomain_buf
;
6739 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6742 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6744 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6746 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6749 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6751 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6753 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6756 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6766 else if (hash_mode
== 5700)
6768 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6770 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6771 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6772 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6773 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6774 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6775 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6776 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6777 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6779 memcpy (tmp_buf
, digest_buf
, 32);
6781 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6785 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6787 else if (hash_mode
== 5800)
6789 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6790 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6791 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6792 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6793 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6795 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6802 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6804 snprintf (out_buf
, len
-1, "%s", hashfile
);
6806 else if (hash_mode
== 6300)
6808 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6810 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6811 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6812 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6813 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6815 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6817 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6819 else if (hash_mode
== 6400)
6821 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6823 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6825 else if (hash_mode
== 6500)
6827 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6829 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6831 else if (hash_mode
== 6600)
6833 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6835 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6837 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6838 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6840 uint buf_len
= len
- 1;
6842 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6845 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6847 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6852 else if (hash_mode
== 6700)
6854 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6856 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6858 else if (hash_mode
== 6800)
6860 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6862 else if (hash_mode
== 7100)
6864 uint
*ptr
= digest_buf
;
6866 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6868 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6872 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6873 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6874 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6875 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6876 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6877 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6878 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6879 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6881 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",
6882 SIGNATURE_SHA512OSX
,
6884 esalt
[ 0], esalt
[ 1],
6885 esalt
[ 2], esalt
[ 3],
6886 esalt
[ 4], esalt
[ 5],
6887 esalt
[ 6], esalt
[ 7],
6895 ptr
[15], ptr
[14]);
6897 else if (hash_mode
== 7200)
6899 uint
*ptr
= digest_buf
;
6901 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6903 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6907 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
6909 len_used
= strlen (out_buf
);
6911 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
6913 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
6915 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
6918 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",
6926 ptr
[15], ptr
[14]);
6928 else if (hash_mode
== 7300)
6930 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
6932 rakp_t
*rakp
= &rakps
[salt_pos
];
6934 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
6936 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
6939 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
6946 else if (hash_mode
== 7400)
6948 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6950 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6951 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6952 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6953 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6954 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6955 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6956 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6957 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6959 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6961 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
6963 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6967 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6970 else if (hash_mode
== 7500)
6972 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
6974 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
6976 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
6977 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
6981 char *ptr_data
= data
;
6983 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
6985 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
6988 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
6990 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
6995 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
6997 (char *) krb5pa
->user
,
6998 (char *) krb5pa
->realm
,
6999 (char *) krb5pa
->salt
,
7002 else if (hash_mode
== 7700)
7004 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7005 (char *) salt
.salt_buf
,
7009 else if (hash_mode
== 7800)
7011 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7012 (char *) salt
.salt_buf
,
7019 else if (hash_mode
== 7900)
7021 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7025 char *tmp
= (char *) salt
.salt_buf_pc
;
7027 ptr_plain
[42] = tmp
[0];
7033 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7035 else if (hash_mode
== 8000)
7037 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7038 (unsigned char *) salt
.salt_buf
,
7048 else if (hash_mode
== 8100)
7050 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7051 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7053 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7054 (unsigned char *) salt
.salt_buf
,
7061 else if (hash_mode
== 8200)
7063 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7065 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7067 char data_buf
[4096];
7069 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7071 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7074 data_buf
[cloudkey
->data_len
* 2] = 0;
7076 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7077 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7078 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7079 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7080 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7081 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7082 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7083 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7085 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7086 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7087 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7088 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7090 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7106 else if (hash_mode
== 8300)
7110 char digest_buf_c
[33];
7112 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 32, (u8
*) digest_buf_c
);
7114 digest_buf_c
[32] = 0;
7118 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7120 char domain_buf_c
[33];
7122 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7124 for (uint i
= 0; i
< salt_pc_len
; i
++)
7126 const char next
= domain_buf_c
[i
];
7128 domain_buf_c
[i
] = '.';
7133 domain_buf_c
[salt_pc_len
] = 0;
7137 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7139 else if (hash_mode
== 8500)
7141 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7143 else if (hash_mode
== 2612)
7145 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7147 (char *) salt
.salt_buf
,
7153 else if (hash_mode
== 3711)
7155 char *salt_ptr
= (char *) salt
.salt_buf
;
7157 salt_ptr
[salt
.salt_len
- 1] = 0;
7159 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7160 SIGNATURE_MEDIAWIKI_B
,
7167 else if (hash_mode
== 8800)
7169 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7171 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7175 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7177 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7182 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7183 SIGNATURE_ANDROIDFDE
,
7184 byte_swap_32 (salt
.salt_buf
[0]),
7185 byte_swap_32 (salt
.salt_buf
[1]),
7186 byte_swap_32 (salt
.salt_buf
[2]),
7187 byte_swap_32 (salt
.salt_buf
[3]),
7188 byte_swap_32 (digest_buf
[0]),
7189 byte_swap_32 (digest_buf
[1]),
7190 byte_swap_32 (digest_buf
[2]),
7191 byte_swap_32 (digest_buf
[3]),
7194 else if (hash_mode
== 8900)
7196 uint N
= salt
.scrypt_N
;
7197 uint r
= salt
.scrypt_r
;
7198 uint p
= salt
.scrypt_p
;
7200 char base64_salt
[32];
7202 memset (base64_salt
, 0, 32);
7204 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7206 memset (tmp_buf
, 0, 46);
7208 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7209 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7210 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7211 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7212 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7213 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7214 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7215 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7216 digest_buf
[8] = 0; // needed for base64_encode ()
7218 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7220 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7228 else if (hash_mode
== 9000)
7230 snprintf (out_buf
, len
-1, "%s", hashfile
);
7232 else if (hash_mode
== 9200)
7236 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7238 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7240 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7244 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7245 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7246 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7247 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7248 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7249 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7250 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7251 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7252 digest_buf
[8] = 0; // needed for base64_encode ()
7255 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7257 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7258 tmp_buf
[43] = 0; // cut it here
7262 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7264 else if (hash_mode
== 9300)
7266 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7267 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7268 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7269 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7270 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7271 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7272 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7273 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7274 digest_buf
[8] = 0; // needed for base64_encode ()
7277 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7279 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7280 tmp_buf
[43] = 0; // cut it here
7282 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7284 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7286 else if (hash_mode
== 9400)
7288 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7290 office2007_t
*office2007
= &office2007s
[salt_pos
];
7292 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7293 SIGNATURE_OFFICE2007
,
7296 office2007
->keySize
,
7302 office2007
->encryptedVerifier
[0],
7303 office2007
->encryptedVerifier
[1],
7304 office2007
->encryptedVerifier
[2],
7305 office2007
->encryptedVerifier
[3],
7306 office2007
->encryptedVerifierHash
[0],
7307 office2007
->encryptedVerifierHash
[1],
7308 office2007
->encryptedVerifierHash
[2],
7309 office2007
->encryptedVerifierHash
[3],
7310 office2007
->encryptedVerifierHash
[4]);
7312 else if (hash_mode
== 9500)
7314 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7316 office2010_t
*office2010
= &office2010s
[salt_pos
];
7318 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,
7324 office2010
->encryptedVerifier
[0],
7325 office2010
->encryptedVerifier
[1],
7326 office2010
->encryptedVerifier
[2],
7327 office2010
->encryptedVerifier
[3],
7328 office2010
->encryptedVerifierHash
[0],
7329 office2010
->encryptedVerifierHash
[1],
7330 office2010
->encryptedVerifierHash
[2],
7331 office2010
->encryptedVerifierHash
[3],
7332 office2010
->encryptedVerifierHash
[4],
7333 office2010
->encryptedVerifierHash
[5],
7334 office2010
->encryptedVerifierHash
[6],
7335 office2010
->encryptedVerifierHash
[7]);
7337 else if (hash_mode
== 9600)
7339 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7341 office2013_t
*office2013
= &office2013s
[salt_pos
];
7343 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,
7349 office2013
->encryptedVerifier
[0],
7350 office2013
->encryptedVerifier
[1],
7351 office2013
->encryptedVerifier
[2],
7352 office2013
->encryptedVerifier
[3],
7353 office2013
->encryptedVerifierHash
[0],
7354 office2013
->encryptedVerifierHash
[1],
7355 office2013
->encryptedVerifierHash
[2],
7356 office2013
->encryptedVerifierHash
[3],
7357 office2013
->encryptedVerifierHash
[4],
7358 office2013
->encryptedVerifierHash
[5],
7359 office2013
->encryptedVerifierHash
[6],
7360 office2013
->encryptedVerifierHash
[7]);
7362 else if (hash_mode
== 9700)
7364 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7366 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7368 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7369 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7370 byte_swap_32 (salt
.salt_buf
[0]),
7371 byte_swap_32 (salt
.salt_buf
[1]),
7372 byte_swap_32 (salt
.salt_buf
[2]),
7373 byte_swap_32 (salt
.salt_buf
[3]),
7374 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7375 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7376 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7377 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7378 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7379 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7380 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7381 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7383 else if (hash_mode
== 9710)
7385 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7387 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7389 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7390 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7391 byte_swap_32 (salt
.salt_buf
[0]),
7392 byte_swap_32 (salt
.salt_buf
[1]),
7393 byte_swap_32 (salt
.salt_buf
[2]),
7394 byte_swap_32 (salt
.salt_buf
[3]),
7395 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7396 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7397 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7398 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7399 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7400 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7401 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7402 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7404 else if (hash_mode
== 9720)
7406 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7408 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7410 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7412 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7413 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7414 byte_swap_32 (salt
.salt_buf
[0]),
7415 byte_swap_32 (salt
.salt_buf
[1]),
7416 byte_swap_32 (salt
.salt_buf
[2]),
7417 byte_swap_32 (salt
.salt_buf
[3]),
7418 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7419 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7420 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7421 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7422 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7423 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7424 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7425 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7432 else if (hash_mode
== 9800)
7434 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7436 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7438 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7439 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7444 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7445 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7446 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7447 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7448 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7449 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7450 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7451 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7452 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7454 else if (hash_mode
== 9810)
7456 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7458 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7460 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7461 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7466 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7467 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7468 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7469 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7470 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7471 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7472 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7473 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7474 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7476 else if (hash_mode
== 9820)
7478 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7480 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7482 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7484 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7485 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7490 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7491 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7492 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7493 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7494 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7495 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7496 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7497 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7498 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7505 else if (hash_mode
== 10000)
7509 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7511 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7513 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7517 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7518 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7519 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7520 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7521 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7522 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7523 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7524 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7525 digest_buf
[8] = 0; // needed for base64_encode ()
7528 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7530 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7534 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7536 else if (hash_mode
== 10100)
7538 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7543 byte_swap_32 (salt
.salt_buf
[0]),
7544 byte_swap_32 (salt
.salt_buf
[1]),
7545 byte_swap_32 (salt
.salt_buf
[2]),
7546 byte_swap_32 (salt
.salt_buf
[3]));
7548 else if (hash_mode
== 10200)
7550 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7552 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7556 char challenge
[100];
7558 memset (challenge
, 0, sizeof (challenge
));
7560 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7566 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7567 (char *) cram_md5
->user
,
7575 memset (response
, 0, sizeof (response
));
7577 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7579 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7581 else if (hash_mode
== 10300)
7585 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7587 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7588 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7590 uint tmp_len
= 20 + salt
.salt_len
;
7594 char base64_encoded
[100];
7596 memset (base64_encoded
, 0, sizeof (base64_encoded
));
7598 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7600 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7602 else if (hash_mode
== 10400)
7604 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7606 pdf_t
*pdf
= &pdfs
[salt_pos
];
7608 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",
7616 byte_swap_32 (pdf
->id_buf
[0]),
7617 byte_swap_32 (pdf
->id_buf
[1]),
7618 byte_swap_32 (pdf
->id_buf
[2]),
7619 byte_swap_32 (pdf
->id_buf
[3]),
7621 byte_swap_32 (pdf
->u_buf
[0]),
7622 byte_swap_32 (pdf
->u_buf
[1]),
7623 byte_swap_32 (pdf
->u_buf
[2]),
7624 byte_swap_32 (pdf
->u_buf
[3]),
7625 byte_swap_32 (pdf
->u_buf
[4]),
7626 byte_swap_32 (pdf
->u_buf
[5]),
7627 byte_swap_32 (pdf
->u_buf
[6]),
7628 byte_swap_32 (pdf
->u_buf
[7]),
7630 byte_swap_32 (pdf
->o_buf
[0]),
7631 byte_swap_32 (pdf
->o_buf
[1]),
7632 byte_swap_32 (pdf
->o_buf
[2]),
7633 byte_swap_32 (pdf
->o_buf
[3]),
7634 byte_swap_32 (pdf
->o_buf
[4]),
7635 byte_swap_32 (pdf
->o_buf
[5]),
7636 byte_swap_32 (pdf
->o_buf
[6]),
7637 byte_swap_32 (pdf
->o_buf
[7])
7640 else if (hash_mode
== 10410)
7642 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7644 pdf_t
*pdf
= &pdfs
[salt_pos
];
7646 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",
7654 byte_swap_32 (pdf
->id_buf
[0]),
7655 byte_swap_32 (pdf
->id_buf
[1]),
7656 byte_swap_32 (pdf
->id_buf
[2]),
7657 byte_swap_32 (pdf
->id_buf
[3]),
7659 byte_swap_32 (pdf
->u_buf
[0]),
7660 byte_swap_32 (pdf
->u_buf
[1]),
7661 byte_swap_32 (pdf
->u_buf
[2]),
7662 byte_swap_32 (pdf
->u_buf
[3]),
7663 byte_swap_32 (pdf
->u_buf
[4]),
7664 byte_swap_32 (pdf
->u_buf
[5]),
7665 byte_swap_32 (pdf
->u_buf
[6]),
7666 byte_swap_32 (pdf
->u_buf
[7]),
7668 byte_swap_32 (pdf
->o_buf
[0]),
7669 byte_swap_32 (pdf
->o_buf
[1]),
7670 byte_swap_32 (pdf
->o_buf
[2]),
7671 byte_swap_32 (pdf
->o_buf
[3]),
7672 byte_swap_32 (pdf
->o_buf
[4]),
7673 byte_swap_32 (pdf
->o_buf
[5]),
7674 byte_swap_32 (pdf
->o_buf
[6]),
7675 byte_swap_32 (pdf
->o_buf
[7])
7678 else if (hash_mode
== 10420)
7680 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7682 pdf_t
*pdf
= &pdfs
[salt_pos
];
7684 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7686 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",
7694 byte_swap_32 (pdf
->id_buf
[0]),
7695 byte_swap_32 (pdf
->id_buf
[1]),
7696 byte_swap_32 (pdf
->id_buf
[2]),
7697 byte_swap_32 (pdf
->id_buf
[3]),
7699 byte_swap_32 (pdf
->u_buf
[0]),
7700 byte_swap_32 (pdf
->u_buf
[1]),
7701 byte_swap_32 (pdf
->u_buf
[2]),
7702 byte_swap_32 (pdf
->u_buf
[3]),
7703 byte_swap_32 (pdf
->u_buf
[4]),
7704 byte_swap_32 (pdf
->u_buf
[5]),
7705 byte_swap_32 (pdf
->u_buf
[6]),
7706 byte_swap_32 (pdf
->u_buf
[7]),
7708 byte_swap_32 (pdf
->o_buf
[0]),
7709 byte_swap_32 (pdf
->o_buf
[1]),
7710 byte_swap_32 (pdf
->o_buf
[2]),
7711 byte_swap_32 (pdf
->o_buf
[3]),
7712 byte_swap_32 (pdf
->o_buf
[4]),
7713 byte_swap_32 (pdf
->o_buf
[5]),
7714 byte_swap_32 (pdf
->o_buf
[6]),
7715 byte_swap_32 (pdf
->o_buf
[7]),
7723 else if (hash_mode
== 10500)
7725 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7727 pdf_t
*pdf
= &pdfs
[salt_pos
];
7729 if (pdf
->id_len
== 32)
7731 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",
7739 byte_swap_32 (pdf
->id_buf
[0]),
7740 byte_swap_32 (pdf
->id_buf
[1]),
7741 byte_swap_32 (pdf
->id_buf
[2]),
7742 byte_swap_32 (pdf
->id_buf
[3]),
7743 byte_swap_32 (pdf
->id_buf
[4]),
7744 byte_swap_32 (pdf
->id_buf
[5]),
7745 byte_swap_32 (pdf
->id_buf
[6]),
7746 byte_swap_32 (pdf
->id_buf
[7]),
7748 byte_swap_32 (pdf
->u_buf
[0]),
7749 byte_swap_32 (pdf
->u_buf
[1]),
7750 byte_swap_32 (pdf
->u_buf
[2]),
7751 byte_swap_32 (pdf
->u_buf
[3]),
7752 byte_swap_32 (pdf
->u_buf
[4]),
7753 byte_swap_32 (pdf
->u_buf
[5]),
7754 byte_swap_32 (pdf
->u_buf
[6]),
7755 byte_swap_32 (pdf
->u_buf
[7]),
7757 byte_swap_32 (pdf
->o_buf
[0]),
7758 byte_swap_32 (pdf
->o_buf
[1]),
7759 byte_swap_32 (pdf
->o_buf
[2]),
7760 byte_swap_32 (pdf
->o_buf
[3]),
7761 byte_swap_32 (pdf
->o_buf
[4]),
7762 byte_swap_32 (pdf
->o_buf
[5]),
7763 byte_swap_32 (pdf
->o_buf
[6]),
7764 byte_swap_32 (pdf
->o_buf
[7])
7769 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",
7777 byte_swap_32 (pdf
->id_buf
[0]),
7778 byte_swap_32 (pdf
->id_buf
[1]),
7779 byte_swap_32 (pdf
->id_buf
[2]),
7780 byte_swap_32 (pdf
->id_buf
[3]),
7782 byte_swap_32 (pdf
->u_buf
[0]),
7783 byte_swap_32 (pdf
->u_buf
[1]),
7784 byte_swap_32 (pdf
->u_buf
[2]),
7785 byte_swap_32 (pdf
->u_buf
[3]),
7786 byte_swap_32 (pdf
->u_buf
[4]),
7787 byte_swap_32 (pdf
->u_buf
[5]),
7788 byte_swap_32 (pdf
->u_buf
[6]),
7789 byte_swap_32 (pdf
->u_buf
[7]),
7791 byte_swap_32 (pdf
->o_buf
[0]),
7792 byte_swap_32 (pdf
->o_buf
[1]),
7793 byte_swap_32 (pdf
->o_buf
[2]),
7794 byte_swap_32 (pdf
->o_buf
[3]),
7795 byte_swap_32 (pdf
->o_buf
[4]),
7796 byte_swap_32 (pdf
->o_buf
[5]),
7797 byte_swap_32 (pdf
->o_buf
[6]),
7798 byte_swap_32 (pdf
->o_buf
[7])
7802 else if (hash_mode
== 10600)
7804 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7806 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7807 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7809 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7811 else if (hash_mode
== 10700)
7813 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7815 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7816 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7818 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7820 else if (hash_mode
== 10900)
7822 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7824 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7825 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7827 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7829 else if (hash_mode
== 11100)
7831 u32 salt_challenge
= salt
.salt_buf
[0];
7833 salt_challenge
= byte_swap_32 (salt_challenge
);
7835 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7837 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7838 SIGNATURE_POSTGRESQL_AUTH
,
7846 else if (hash_mode
== 11200)
7848 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7849 SIGNATURE_MYSQL_AUTH
,
7850 (unsigned char *) salt
.salt_buf
,
7857 else if (hash_mode
== 11300)
7859 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7861 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7863 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7864 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7865 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7867 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7868 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7869 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7871 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7873 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7875 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7878 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7880 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7882 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7885 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7887 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
7889 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7892 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
7893 SIGNATURE_BITCOIN_WALLET
,
7897 (unsigned char *) salt
.salt_buf
,
7905 free (cry_master_buf
);
7907 free (public_key_buf
);
7909 else if (hash_mode
== 11400)
7911 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7913 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7914 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7916 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7918 else if (hash_mode
== 11600)
7920 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
7922 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
7924 const uint data_len
= seven_zip
->data_len
;
7926 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
7928 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
7930 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
7932 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
7935 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
7936 SIGNATURE_SEVEN_ZIP
,
7940 (char *) seven_zip
->salt_buf
,
7942 seven_zip
->iv_buf
[0],
7943 seven_zip
->iv_buf
[1],
7944 seven_zip
->iv_buf
[2],
7945 seven_zip
->iv_buf
[3],
7947 seven_zip
->data_len
,
7948 seven_zip
->unpack_size
,
7953 else if (hash_mode
== 11700)
7955 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
7965 else if (hash_mode
== 11800)
7967 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
7985 else if (hash_mode
== 11900)
7987 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7989 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7990 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7992 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7994 else if (hash_mode
== 12000)
7996 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7998 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7999 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8001 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8003 else if (hash_mode
== 12100)
8005 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8007 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8008 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8010 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8012 else if (hash_mode
== 12200)
8014 uint
*ptr_digest
= digest_buf
;
8015 uint
*ptr_salt
= salt
.salt_buf
;
8017 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8024 else if (hash_mode
== 12300)
8026 uint
*ptr_digest
= digest_buf
;
8027 uint
*ptr_salt
= salt
.salt_buf
;
8029 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",
8030 ptr_digest
[ 0], ptr_digest
[ 1],
8031 ptr_digest
[ 2], ptr_digest
[ 3],
8032 ptr_digest
[ 4], ptr_digest
[ 5],
8033 ptr_digest
[ 6], ptr_digest
[ 7],
8034 ptr_digest
[ 8], ptr_digest
[ 9],
8035 ptr_digest
[10], ptr_digest
[11],
8036 ptr_digest
[12], ptr_digest
[13],
8037 ptr_digest
[14], ptr_digest
[15],
8043 else if (hash_mode
== 12400)
8045 // encode iteration count
8049 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8050 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8051 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8052 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8057 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8058 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8059 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8060 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8065 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8067 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8068 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8070 memcpy (tmp_buf
, digest_buf
, 8);
8072 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8076 // fill the resulting buffer
8078 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8080 else if (hash_mode
== 12500)
8082 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8084 byte_swap_32 (salt
.salt_buf
[0]),
8085 byte_swap_32 (salt
.salt_buf
[1]),
8091 else if (hash_mode
== 12600)
8093 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8094 digest_buf
[0] + salt
.salt_buf_pc
[0],
8095 digest_buf
[1] + salt
.salt_buf_pc
[1],
8096 digest_buf
[2] + salt
.salt_buf_pc
[2],
8097 digest_buf
[3] + salt
.salt_buf_pc
[3],
8098 digest_buf
[4] + salt
.salt_buf_pc
[4],
8099 digest_buf
[5] + salt
.salt_buf_pc
[5],
8100 digest_buf
[6] + salt
.salt_buf_pc
[6],
8101 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8103 else if (hash_mode
== 12700)
8105 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8107 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8108 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8110 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8112 else if (hash_mode
== 12800)
8114 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8116 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",
8129 byte_swap_32 (digest_buf
[0]),
8130 byte_swap_32 (digest_buf
[1]),
8131 byte_swap_32 (digest_buf
[2]),
8132 byte_swap_32 (digest_buf
[3]),
8133 byte_swap_32 (digest_buf
[4]),
8134 byte_swap_32 (digest_buf
[5]),
8135 byte_swap_32 (digest_buf
[6]),
8136 byte_swap_32 (digest_buf
[7])
8139 else if (hash_mode
== 12900)
8141 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",
8150 byte_swap_32 (digest_buf
[0]),
8151 byte_swap_32 (digest_buf
[1]),
8152 byte_swap_32 (digest_buf
[2]),
8153 byte_swap_32 (digest_buf
[3]),
8154 byte_swap_32 (digest_buf
[4]),
8155 byte_swap_32 (digest_buf
[5]),
8156 byte_swap_32 (digest_buf
[6]),
8157 byte_swap_32 (digest_buf
[7]),
8164 else if (hash_mode
== 13000)
8166 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8168 rar5_t
*rar5
= &rar5s
[salt_pos
];
8170 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8180 byte_swap_32 (digest_buf
[0]),
8181 byte_swap_32 (digest_buf
[1])
8186 if (hash_type
== HASH_TYPE_MD4
)
8188 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8194 else if (hash_type
== HASH_TYPE_MD5
)
8196 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8202 else if (hash_type
== HASH_TYPE_SHA1
)
8204 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8211 else if (hash_type
== HASH_TYPE_SHA256
)
8213 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8223 else if (hash_type
== HASH_TYPE_SHA384
)
8225 uint
*ptr
= digest_buf
;
8227 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8235 else if (hash_type
== HASH_TYPE_SHA512
)
8237 uint
*ptr
= digest_buf
;
8239 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8249 else if (hash_type
== HASH_TYPE_LM
)
8251 snprintf (out_buf
, len
-1, "%08x%08x",
8255 else if (hash_type
== HASH_TYPE_ORACLEH
)
8257 snprintf (out_buf
, len
-1, "%08X%08X",
8261 else if (hash_type
== HASH_TYPE_BCRYPT
)
8263 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8264 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8266 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8268 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8270 else if (hash_type
== HASH_TYPE_KECCAK
)
8272 uint
*ptr
= digest_buf
;
8274 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",
8302 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8304 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8306 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8313 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8315 digest_buf
[ 0] = digest_buf
[ 0];
8316 digest_buf
[ 1] = digest_buf
[ 1];
8317 digest_buf
[ 2] = digest_buf
[ 2];
8318 digest_buf
[ 3] = digest_buf
[ 3];
8319 digest_buf
[ 4] = digest_buf
[ 4];
8320 digest_buf
[ 5] = digest_buf
[ 5];
8321 digest_buf
[ 6] = digest_buf
[ 6];
8322 digest_buf
[ 7] = digest_buf
[ 7];
8323 digest_buf
[ 8] = digest_buf
[ 8];
8324 digest_buf
[ 9] = digest_buf
[ 9];
8325 digest_buf
[10] = digest_buf
[10];
8326 digest_buf
[11] = digest_buf
[11];
8327 digest_buf
[12] = digest_buf
[12];
8328 digest_buf
[13] = digest_buf
[13];
8329 digest_buf
[14] = digest_buf
[14];
8330 digest_buf
[15] = digest_buf
[15];
8332 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8350 else if (hash_type
== HASH_TYPE_GOST
)
8352 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8362 else if (hash_type
== HASH_TYPE_MYSQL
)
8364 snprintf (out_buf
, len
-1, "%08x%08x",
8368 else if (hash_type
== HASH_TYPE_LOTUS5
)
8370 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8376 else if (hash_type
== HASH_TYPE_LOTUS6
)
8378 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8379 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8380 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8381 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8385 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8386 memcpy (buf
+ 5, digest_buf
, 9);
8390 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8392 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8395 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8397 else if (hash_type
== HASH_TYPE_LOTUS8
)
8401 memset (buf
, 0, sizeof (buf
));
8405 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8411 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8415 buf
[26] = salt
.salt_buf_pc
[0];
8416 buf
[27] = salt
.salt_buf_pc
[1];
8420 memcpy (buf
+ 28, digest_buf
, 8);
8422 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8426 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8428 else if (hash_type
== HASH_TYPE_CRC32
)
8430 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8434 if (salt_type
== SALT_TYPE_INTERN
)
8436 size_t pos
= strlen (out_buf
);
8438 out_buf
[pos
] = data
.separator
;
8440 char *ptr
= (char *) salt
.salt_buf
;
8442 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8444 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8448 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8450 memset (hccap
, 0, sizeof (hccap_t
));
8452 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8454 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8456 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8457 wpa_t
*wpa
= &wpas
[salt_pos
];
8459 hccap
->keyver
= wpa
->keyver
;
8461 hccap
->eapol_size
= wpa
->eapol_size
;
8463 if (wpa
->keyver
!= 1)
8467 for (uint i
= 0; i
< 64; i
++)
8469 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8472 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8476 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8481 for (int i
= 5; i
< 25; i
++)
8483 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8486 char *pke_ptr
= (char *) pke_tmp
;
8488 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8489 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8490 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8491 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8493 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8495 uint dgst_size
= data
.dgst_size
;
8497 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8499 if (wpa
->keyver
!= 1)
8503 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8504 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8505 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8506 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8508 memcpy (hccap
->keymic
, digest_tmp
, 16);
8512 memcpy (hccap
->keymic
, digest_ptr
, 16);
8516 void SuspendThreads ()
8518 if (data
.devices_status
== STATUS_RUNNING
)
8520 hc_timer_set (&data
.timer_paused
);
8522 data
.devices_status
= STATUS_PAUSED
;
8524 log_info ("Paused");
8528 void ResumeThreads ()
8530 if (data
.devices_status
== STATUS_PAUSED
)
8534 hc_timer_get (data
.timer_paused
, ms_paused
);
8536 data
.ms_paused
+= ms_paused
;
8538 data
.devices_status
= STATUS_RUNNING
;
8540 log_info ("Resumed");
8546 if (data
.devices_status
!= STATUS_RUNNING
) return;
8548 data
.devices_status
= STATUS_BYPASS
;
8550 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8553 void stop_at_checkpoint ()
8555 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8557 if (data
.devices_status
!= STATUS_RUNNING
) return;
8560 // this feature only makes sense if --restore-disable was not specified
8562 if (data
.restore_disable
== 1)
8564 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8569 // check if monitoring of Restore Point updates should be enabled or disabled
8571 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8573 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8575 // save the current restore point value
8577 data
.checkpoint_cur_words
= get_lowest_words_done ();
8579 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8583 data
.devices_status
= STATUS_RUNNING
;
8585 // reset the global value for checkpoint checks
8587 data
.checkpoint_cur_words
= 0;
8589 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8595 if (data
.devices_status
== STATUS_INIT
) return;
8596 if (data
.devices_status
== STATUS_STARTING
) return;
8598 data
.devices_status
= STATUS_ABORTED
;
8603 if (data
.devices_status
== STATUS_INIT
) return;
8604 if (data
.devices_status
== STATUS_STARTING
) return;
8606 data
.devices_status
= STATUS_QUIT
;
8609 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8613 if ((fp
= fopen (kernel_file
, "rb")) != NULL
)
8617 memset (&st
, 0, sizeof (st
));
8619 stat (kernel_file
, &st
);
8621 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8623 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8625 if (num_read
!= (size_t) st
.st_size
)
8627 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8634 buf
[st
.st_size
] = 0;
8636 for (int i
= 0; i
< num_devices
; i
++)
8638 kernel_lengths
[i
] = (size_t) st
.st_size
;
8640 kernel_sources
[i
] = buf
;
8645 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8653 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8655 FILE *fp
= fopen (dst
, "wb");
8657 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8667 restore_data_t
*init_restore (int argc
, char **argv
)
8669 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8671 if (data
.restore_disable
== 0)
8673 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8677 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8681 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8690 char pidbin
[BUFSIZ
];
8695 memset (pidbin
, 0, sizeof (pidbin
));
8697 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8699 FILE *fd
= fopen (pidbin
, "rb");
8703 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8705 pidbin
[pidbin_len
] = 0;
8709 char *argv0_r
= strrchr (argv
[0], '/');
8711 char *pidbin_r
= strrchr (pidbin
, '/');
8713 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8715 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8717 if (strcmp (argv0_r
, pidbin_r
) == 0)
8719 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8726 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8728 char pidbin2
[BUFSIZ
];
8732 memset (pidbin2
, 0, sizeof (pidbin2
));
8734 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8735 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8737 pidbin
[pidbin_len
] = 0;
8738 pidbin2
[pidbin2_len
] = 0;
8742 if (strcmp (pidbin
, pidbin2
) == 0)
8744 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8752 if (rd
->version_bin
< RESTORE_MIN
)
8754 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8761 memset (rd
, 0, sizeof (restore_data_t
));
8763 rd
->version_bin
= VERSION_BIN
;
8766 rd
->pid
= getpid ();
8768 rd
->pid
= GetCurrentProcessId ();
8771 if (getcwd (rd
->cwd
, 255) == NULL
)
8784 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8786 FILE *fp
= fopen (eff_restore_file
, "rb");
8790 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8795 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8797 log_error ("ERROR: cannot read %s", eff_restore_file
);
8802 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8804 for (uint i
= 0; i
< rd
->argc
; i
++)
8808 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8810 log_error ("ERROR: cannot read %s", eff_restore_file
);
8815 size_t len
= strlen (buf
);
8817 if (len
) buf
[len
- 1] = 0;
8819 rd
->argv
[i
] = mystrdup (buf
);
8826 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8830 log_error ("Restore file is corrupted");
8833 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8835 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8837 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8842 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8846 if (chdir (rd
->cwd
))
8848 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8854 u64
get_lowest_words_done ()
8858 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8860 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8862 const u64 words_done
= device_param
->words_done
;
8864 if (words_done
< words_cur
) words_cur
= words_done
;
8867 // It's possible that a device's workload isn't finished right after a restore-case.
8868 // In that case, this function would return 0 and overwrite the real restore point
8869 // There's also data.words_cur which is set to rd->words_cur but it changes while
8870 // the attack is running therefore we should stick to rd->words_cur.
8871 // Note that -s influences rd->words_cur we should keep a close look on that.
8873 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
8878 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
8880 u64 words_cur
= get_lowest_words_done ();
8882 rd
->words_cur
= words_cur
;
8884 FILE *fp
= fopen (new_restore_file
, "wb");
8888 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
8893 if (setvbuf (fp
, NULL
, _IONBF
, 0))
8895 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
8900 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
8902 for (uint i
= 0; i
< rd
->argc
; i
++)
8904 fprintf (fp
, "%s", rd
->argv
[i
]);
8910 fsync (fileno (fp
));
8915 void cycle_restore ()
8917 const char *eff_restore_file
= data
.eff_restore_file
;
8918 const char *new_restore_file
= data
.new_restore_file
;
8920 restore_data_t
*rd
= data
.rd
;
8922 write_restore (new_restore_file
, rd
);
8926 memset (&st
, 0, sizeof(st
));
8928 if (stat (eff_restore_file
, &st
) == 0)
8930 if (unlink (eff_restore_file
))
8932 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
8936 if (rename (new_restore_file
, eff_restore_file
))
8938 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
8942 void check_checkpoint ()
8944 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
8946 u64 words_cur
= get_lowest_words_done ();
8948 if (words_cur
!= data
.checkpoint_cur_words
)
8958 uint
set_kernel_accel (uint hash_mode
)
8962 case 0: return GET_ACCEL (0);
8963 case 10: return GET_ACCEL (10);
8964 case 11: return GET_ACCEL (11);
8965 case 12: return GET_ACCEL (12);
8966 case 20: return GET_ACCEL (20);
8967 case 21: return GET_ACCEL (21);
8968 case 22: return GET_ACCEL (22);
8969 case 23: return GET_ACCEL (23);
8970 case 30: return GET_ACCEL (30);
8971 case 40: return GET_ACCEL (40);
8972 case 50: return GET_ACCEL (50);
8973 case 60: return GET_ACCEL (60);
8974 case 100: return GET_ACCEL (100);
8975 case 101: return GET_ACCEL (101);
8976 case 110: return GET_ACCEL (110);
8977 case 111: return GET_ACCEL (111);
8978 case 112: return GET_ACCEL (112);
8979 case 120: return GET_ACCEL (120);
8980 case 121: return GET_ACCEL (121);
8981 case 122: return GET_ACCEL (122);
8982 case 124: return GET_ACCEL (124);
8983 case 130: return GET_ACCEL (130);
8984 case 131: return GET_ACCEL (131);
8985 case 132: return GET_ACCEL (132);
8986 case 133: return GET_ACCEL (133);
8987 case 140: return GET_ACCEL (140);
8988 case 141: return GET_ACCEL (141);
8989 case 150: return GET_ACCEL (150);
8990 case 160: return GET_ACCEL (160);
8991 case 190: return GET_ACCEL (190);
8992 case 200: return GET_ACCEL (200);
8993 case 300: return GET_ACCEL (300);
8994 case 400: return GET_ACCEL (400);
8995 case 500: return GET_ACCEL (500);
8996 case 501: return GET_ACCEL (501);
8997 case 900: return GET_ACCEL (900);
8998 case 910: return GET_ACCEL (910);
8999 case 1000: return GET_ACCEL (1000);
9000 case 1100: return GET_ACCEL (1100);
9001 case 1400: return GET_ACCEL (1400);
9002 case 1410: return GET_ACCEL (1410);
9003 case 1420: return GET_ACCEL (1420);
9004 case 1421: return GET_ACCEL (1421);
9005 case 1430: return GET_ACCEL (1430);
9006 case 1440: return GET_ACCEL (1440);
9007 case 1441: return GET_ACCEL (1441);
9008 case 1450: return GET_ACCEL (1450);
9009 case 1460: return GET_ACCEL (1460);
9010 case 1500: return GET_ACCEL (1500);
9011 case 1600: return GET_ACCEL (1600);
9012 case 1700: return GET_ACCEL (1700);
9013 case 1710: return GET_ACCEL (1710);
9014 case 1711: return GET_ACCEL (1711);
9015 case 1720: return GET_ACCEL (1720);
9016 case 1722: return GET_ACCEL (1722);
9017 case 1730: return GET_ACCEL (1730);
9018 case 1731: return GET_ACCEL (1731);
9019 case 1740: return GET_ACCEL (1740);
9020 case 1750: return GET_ACCEL (1750);
9021 case 1760: return GET_ACCEL (1760);
9022 case 1800: return GET_ACCEL (1800);
9023 case 2100: return GET_ACCEL (2100);
9024 case 2400: return GET_ACCEL (2400);
9025 case 2410: return GET_ACCEL (2410);
9026 case 2500: return GET_ACCEL (2500);
9027 case 2600: return GET_ACCEL (2600);
9028 case 2611: return GET_ACCEL (2611);
9029 case 2612: return GET_ACCEL (2612);
9030 case 2711: return GET_ACCEL (2711);
9031 case 2811: return GET_ACCEL (2811);
9032 case 3000: return GET_ACCEL (3000);
9033 case 3100: return GET_ACCEL (3100);
9034 case 3200: return GET_ACCEL (3200);
9035 case 3710: return GET_ACCEL (3710);
9036 case 3711: return GET_ACCEL (3711);
9037 case 3800: return GET_ACCEL (3800);
9038 case 4300: return GET_ACCEL (4300);
9039 case 4400: return GET_ACCEL (4400);
9040 case 4500: return GET_ACCEL (4500);
9041 case 4700: return GET_ACCEL (4700);
9042 case 4800: return GET_ACCEL (4800);
9043 case 4900: return GET_ACCEL (4900);
9044 case 5000: return GET_ACCEL (5000);
9045 case 5100: return GET_ACCEL (5100);
9046 case 5200: return GET_ACCEL (5200);
9047 case 5300: return GET_ACCEL (5300);
9048 case 5400: return GET_ACCEL (5400);
9049 case 5500: return GET_ACCEL (5500);
9050 case 5600: return GET_ACCEL (5600);
9051 case 5700: return GET_ACCEL (5700);
9052 case 5800: return GET_ACCEL (5800);
9053 case 6000: return GET_ACCEL (6000);
9054 case 6100: return GET_ACCEL (6100);
9055 case 6211: return GET_ACCEL (6211);
9056 case 6212: return GET_ACCEL (6212);
9057 case 6213: return GET_ACCEL (6213);
9058 case 6221: return GET_ACCEL (6221);
9059 case 6222: return GET_ACCEL (6222);
9060 case 6223: return GET_ACCEL (6223);
9061 case 6231: return GET_ACCEL (6231);
9062 case 6232: return GET_ACCEL (6232);
9063 case 6233: return GET_ACCEL (6233);
9064 case 6241: return GET_ACCEL (6241);
9065 case 6242: return GET_ACCEL (6242);
9066 case 6243: return GET_ACCEL (6243);
9067 case 6300: return GET_ACCEL (6300);
9068 case 6400: return GET_ACCEL (6400);
9069 case 6500: return GET_ACCEL (6500);
9070 case 6600: return GET_ACCEL (6600);
9071 case 6700: return GET_ACCEL (6700);
9072 case 6800: return GET_ACCEL (6800);
9073 case 6900: return GET_ACCEL (6900);
9074 case 7100: return GET_ACCEL (7100);
9075 case 7200: return GET_ACCEL (7200);
9076 case 7300: return GET_ACCEL (7300);
9077 case 7400: return GET_ACCEL (7400);
9078 case 7500: return GET_ACCEL (7500);
9079 case 7600: return GET_ACCEL (7600);
9080 case 7700: return GET_ACCEL (7700);
9081 case 7800: return GET_ACCEL (7800);
9082 case 7900: return GET_ACCEL (7900);
9083 case 8000: return GET_ACCEL (8000);
9084 case 8100: return GET_ACCEL (8100);
9085 case 8200: return GET_ACCEL (8200);
9086 case 8300: return GET_ACCEL (8300);
9087 case 8400: return GET_ACCEL (8400);
9088 case 8500: return GET_ACCEL (8500);
9089 case 8600: return GET_ACCEL (8600);
9090 case 8700: return GET_ACCEL (8700);
9091 case 8800: return GET_ACCEL (8800);
9092 case 8900: return GET_ACCEL (8900);
9093 case 9000: return GET_ACCEL (9000);
9094 case 9100: return GET_ACCEL (9100);
9095 case 9200: return GET_ACCEL (9200);
9096 case 9300: return GET_ACCEL (9300);
9097 case 9400: return GET_ACCEL (9400);
9098 case 9500: return GET_ACCEL (9500);
9099 case 9600: return GET_ACCEL (9600);
9100 case 9700: return GET_ACCEL (9700);
9101 case 9710: return GET_ACCEL (9710);
9102 case 9720: return GET_ACCEL (9720);
9103 case 9800: return GET_ACCEL (9800);
9104 case 9810: return GET_ACCEL (9810);
9105 case 9820: return GET_ACCEL (9820);
9106 case 9900: return GET_ACCEL (9900);
9107 case 10000: return GET_ACCEL (10000);
9108 case 10100: return GET_ACCEL (10100);
9109 case 10200: return GET_ACCEL (10200);
9110 case 10300: return GET_ACCEL (10300);
9111 case 10400: return GET_ACCEL (10400);
9112 case 10410: return GET_ACCEL (10410);
9113 case 10420: return GET_ACCEL (10420);
9114 case 10500: return GET_ACCEL (10500);
9115 case 10600: return GET_ACCEL (10600);
9116 case 10700: return GET_ACCEL (10700);
9117 case 10800: return GET_ACCEL (10800);
9118 case 10900: return GET_ACCEL (10900);
9119 case 11000: return GET_ACCEL (11000);
9120 case 11100: return GET_ACCEL (11100);
9121 case 11200: return GET_ACCEL (11200);
9122 case 11300: return GET_ACCEL (11300);
9123 case 11400: return GET_ACCEL (11400);
9124 case 11500: return GET_ACCEL (11500);
9125 case 11600: return GET_ACCEL (11600);
9126 case 11700: return GET_ACCEL (11700);
9127 case 11800: return GET_ACCEL (11800);
9128 case 11900: return GET_ACCEL (11900);
9129 case 12000: return GET_ACCEL (12000);
9130 case 12100: return GET_ACCEL (12100);
9131 case 12200: return GET_ACCEL (12200);
9132 case 12300: return GET_ACCEL (12300);
9133 case 12400: return GET_ACCEL (12400);
9134 case 12500: return GET_ACCEL (12500);
9135 case 12600: return GET_ACCEL (12600);
9136 case 12700: return GET_ACCEL (12700);
9137 case 12800: return GET_ACCEL (12800);
9138 case 12900: return GET_ACCEL (12900);
9139 case 13000: return GET_ACCEL (13000);
9145 uint
set_kernel_loops (uint hash_mode
)
9149 case 0: return GET_LOOPS (0);
9150 case 10: return GET_LOOPS (10);
9151 case 11: return GET_LOOPS (11);
9152 case 12: return GET_LOOPS (12);
9153 case 20: return GET_LOOPS (20);
9154 case 21: return GET_LOOPS (21);
9155 case 22: return GET_LOOPS (22);
9156 case 23: return GET_LOOPS (23);
9157 case 30: return GET_LOOPS (30);
9158 case 40: return GET_LOOPS (40);
9159 case 50: return GET_LOOPS (50);
9160 case 60: return GET_LOOPS (60);
9161 case 100: return GET_LOOPS (100);
9162 case 101: return GET_LOOPS (101);
9163 case 110: return GET_LOOPS (110);
9164 case 111: return GET_LOOPS (111);
9165 case 112: return GET_LOOPS (112);
9166 case 120: return GET_LOOPS (120);
9167 case 121: return GET_LOOPS (121);
9168 case 122: return GET_LOOPS (122);
9169 case 124: return GET_LOOPS (124);
9170 case 130: return GET_LOOPS (130);
9171 case 131: return GET_LOOPS (131);
9172 case 132: return GET_LOOPS (132);
9173 case 133: return GET_LOOPS (133);
9174 case 140: return GET_LOOPS (140);
9175 case 141: return GET_LOOPS (141);
9176 case 150: return GET_LOOPS (150);
9177 case 160: return GET_LOOPS (160);
9178 case 190: return GET_LOOPS (190);
9179 case 200: return GET_LOOPS (200);
9180 case 300: return GET_LOOPS (300);
9181 case 400: return GET_LOOPS (400);
9182 case 500: return GET_LOOPS (500);
9183 case 501: return GET_LOOPS (501);
9184 case 900: return GET_LOOPS (900);
9185 case 910: return GET_LOOPS (910);
9186 case 1000: return GET_LOOPS (1000);
9187 case 1100: return GET_LOOPS (1100);
9188 case 1400: return GET_LOOPS (1400);
9189 case 1410: return GET_LOOPS (1410);
9190 case 1420: return GET_LOOPS (1420);
9191 case 1421: return GET_LOOPS (1421);
9192 case 1430: return GET_LOOPS (1430);
9193 case 1440: return GET_LOOPS (1440);
9194 case 1441: return GET_LOOPS (1441);
9195 case 1450: return GET_LOOPS (1450);
9196 case 1460: return GET_LOOPS (1460);
9197 case 1500: return GET_LOOPS (1500);
9198 case 1600: return GET_LOOPS (1600);
9199 case 1700: return GET_LOOPS (1700);
9200 case 1710: return GET_LOOPS (1710);
9201 case 1711: return GET_LOOPS (1711);
9202 case 1720: return GET_LOOPS (1720);
9203 case 1722: return GET_LOOPS (1722);
9204 case 1730: return GET_LOOPS (1730);
9205 case 1731: return GET_LOOPS (1731);
9206 case 1740: return GET_LOOPS (1740);
9207 case 1750: return GET_LOOPS (1750);
9208 case 1760: return GET_LOOPS (1760);
9209 case 1800: return GET_LOOPS (1800);
9210 case 2100: return GET_LOOPS (2100);
9211 case 2400: return GET_LOOPS (2400);
9212 case 2410: return GET_LOOPS (2410);
9213 case 2500: return GET_LOOPS (2500);
9214 case 2600: return GET_LOOPS (2600);
9215 case 2611: return GET_LOOPS (2611);
9216 case 2612: return GET_LOOPS (2612);
9217 case 2711: return GET_LOOPS (2711);
9218 case 2811: return GET_LOOPS (2811);
9219 case 3000: return GET_LOOPS (3000);
9220 case 3100: return GET_LOOPS (3100);
9221 case 3200: return GET_LOOPS (3200);
9222 case 3710: return GET_LOOPS (3710);
9223 case 3711: return GET_LOOPS (3711);
9224 case 3800: return GET_LOOPS (3800);
9225 case 4300: return GET_LOOPS (4300);
9226 case 4400: return GET_LOOPS (4400);
9227 case 4500: return GET_LOOPS (4500);
9228 case 4700: return GET_LOOPS (4700);
9229 case 4800: return GET_LOOPS (4800);
9230 case 4900: return GET_LOOPS (4900);
9231 case 5000: return GET_LOOPS (5000);
9232 case 5100: return GET_LOOPS (5100);
9233 case 5200: return GET_LOOPS (5200);
9234 case 5300: return GET_LOOPS (5300);
9235 case 5400: return GET_LOOPS (5400);
9236 case 5500: return GET_LOOPS (5500);
9237 case 5600: return GET_LOOPS (5600);
9238 case 5700: return GET_LOOPS (5700);
9239 case 5800: return GET_LOOPS (5800);
9240 case 6000: return GET_LOOPS (6000);
9241 case 6100: return GET_LOOPS (6100);
9242 case 6211: return GET_LOOPS (6211);
9243 case 6212: return GET_LOOPS (6212);
9244 case 6213: return GET_LOOPS (6213);
9245 case 6221: return GET_LOOPS (6221);
9246 case 6222: return GET_LOOPS (6222);
9247 case 6223: return GET_LOOPS (6223);
9248 case 6231: return GET_LOOPS (6231);
9249 case 6232: return GET_LOOPS (6232);
9250 case 6233: return GET_LOOPS (6233);
9251 case 6241: return GET_LOOPS (6241);
9252 case 6242: return GET_LOOPS (6242);
9253 case 6243: return GET_LOOPS (6243);
9254 case 6300: return GET_LOOPS (6300);
9255 case 6400: return GET_LOOPS (6400);
9256 case 6500: return GET_LOOPS (6500);
9257 case 6600: return GET_LOOPS (6600);
9258 case 6700: return GET_LOOPS (6700);
9259 case 6800: return GET_LOOPS (6800);
9260 case 6900: return GET_LOOPS (6900);
9261 case 7100: return GET_LOOPS (7100);
9262 case 7200: return GET_LOOPS (7200);
9263 case 7300: return GET_LOOPS (7300);
9264 case 7400: return GET_LOOPS (7400);
9265 case 7500: return GET_LOOPS (7500);
9266 case 7600: return GET_LOOPS (7600);
9267 case 7700: return GET_LOOPS (7700);
9268 case 7800: return GET_LOOPS (7800);
9269 case 7900: return GET_LOOPS (7900);
9270 case 8000: return GET_LOOPS (8000);
9271 case 8100: return GET_LOOPS (8100);
9272 case 8200: return GET_LOOPS (8200);
9273 case 8300: return GET_LOOPS (8300);
9274 case 8400: return GET_LOOPS (8400);
9275 case 8500: return GET_LOOPS (8500);
9276 case 8600: return GET_LOOPS (8600);
9277 case 8700: return GET_LOOPS (8700);
9278 case 8800: return GET_LOOPS (8800);
9279 case 8900: return GET_LOOPS (8900);
9280 case 9000: return GET_LOOPS (9000);
9281 case 9100: return GET_LOOPS (9100);
9282 case 9200: return GET_LOOPS (9200);
9283 case 9300: return GET_LOOPS (9300);
9284 case 9400: return GET_LOOPS (9400);
9285 case 9500: return GET_LOOPS (9500);
9286 case 9600: return GET_LOOPS (9600);
9287 case 9700: return GET_LOOPS (9700);
9288 case 9710: return GET_LOOPS (9710);
9289 case 9720: return GET_LOOPS (9720);
9290 case 9800: return GET_LOOPS (9800);
9291 case 9810: return GET_LOOPS (9810);
9292 case 9820: return GET_LOOPS (9820);
9293 case 9900: return GET_LOOPS (9900);
9294 case 10000: return GET_LOOPS (10000);
9295 case 10100: return GET_LOOPS (10100);
9296 case 10200: return GET_LOOPS (10200);
9297 case 10300: return GET_LOOPS (10300);
9298 case 10400: return GET_LOOPS (10400);
9299 case 10410: return GET_LOOPS (10410);
9300 case 10420: return GET_LOOPS (10420);
9301 case 10500: return GET_LOOPS (10500);
9302 case 10600: return GET_LOOPS (10600);
9303 case 10700: return GET_LOOPS (10700);
9304 case 10800: return GET_LOOPS (10800);
9305 case 10900: return GET_LOOPS (10900);
9306 case 11000: return GET_LOOPS (11000);
9307 case 11100: return GET_LOOPS (11100);
9308 case 11200: return GET_LOOPS (11200);
9309 case 11300: return GET_LOOPS (11300);
9310 case 11400: return GET_LOOPS (11400);
9311 case 11500: return GET_LOOPS (11500);
9312 case 11600: return GET_LOOPS (11600);
9313 case 11700: return GET_LOOPS (11700);
9314 case 11800: return GET_LOOPS (11800);
9315 case 11900: return GET_LOOPS (11900);
9316 case 12000: return GET_LOOPS (12000);
9317 case 12100: return GET_LOOPS (12100);
9318 case 12200: return GET_LOOPS (12200);
9319 case 12300: return GET_LOOPS (12300);
9320 case 12400: return GET_LOOPS (12400);
9321 case 12500: return GET_LOOPS (12500);
9322 case 12600: return GET_LOOPS (12600);
9323 case 12700: return GET_LOOPS (12700);
9324 case 12800: return GET_LOOPS (12800);
9325 case 12900: return GET_LOOPS (12900);
9326 case 13000: return GET_LOOPS (13000);
9336 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9340 if (salt_len
> sizeof (tmp
))
9345 memset (tmp
, 0, sizeof (tmp
));
9346 memcpy (tmp
, in
, salt_len
);
9348 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9350 if ((salt_len
% 2) == 0)
9352 u32 new_salt_len
= salt_len
/ 2;
9354 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9359 tmp
[i
] = hex_convert (p1
) << 0;
9360 tmp
[i
] |= hex_convert (p0
) << 4;
9363 salt_len
= new_salt_len
;
9370 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9372 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9375 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9377 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9381 u32
*tmp_uint
= (u32
*) tmp
;
9383 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9384 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9385 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9386 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9387 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9388 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9389 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9390 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9391 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9392 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9394 salt_len
= salt_len
* 2;
9402 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9404 lowercase (tmp
, salt_len
);
9407 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9409 uppercase (tmp
, salt_len
);
9414 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9419 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9424 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9426 u32
*tmp_uint
= (uint
*) tmp
;
9432 for (u32 i
= 0; i
< max
; i
++)
9434 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9437 // Important: we may need to increase the length of memcpy since
9438 // we don't want to "loose" some swapped bytes (could happen if
9439 // they do not perfectly fit in the 4-byte blocks)
9440 // Memcpy does always copy the bytes in the BE order, but since
9441 // we swapped them, some important bytes could be in positions
9442 // we normally skip with the original len
9444 if (len
% 4) len
+= 4 - (len
% 4);
9447 memcpy (out
, tmp
, len
);
9452 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9454 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9456 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9458 u32
*digest
= (u32
*) hash_buf
->digest
;
9460 salt_t
*salt
= hash_buf
->salt
;
9462 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9464 char *iter_pos
= input_buf
+ 4;
9466 salt
->salt_iter
= 1 << atoi (iter_pos
);
9468 char *salt_pos
= strchr (iter_pos
, '$');
9470 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9476 salt
->salt_len
= salt_len
;
9480 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9482 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9484 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9486 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9488 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9489 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9490 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9491 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9493 char *hash_pos
= salt_pos
+ 22;
9495 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9497 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9499 memcpy (digest
, tmp_buf
, 24);
9501 digest
[0] = byte_swap_32 (digest
[0]);
9502 digest
[1] = byte_swap_32 (digest
[1]);
9503 digest
[2] = byte_swap_32 (digest
[2]);
9504 digest
[3] = byte_swap_32 (digest
[3]);
9505 digest
[4] = byte_swap_32 (digest
[4]);
9506 digest
[5] = byte_swap_32 (digest
[5]);
9508 digest
[5] &= ~0xff; // its just 23 not 24 !
9513 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9515 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9517 u32
*digest
= (u32
*) hash_buf
->digest
;
9521 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9523 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9525 memcpy (digest
, tmp_buf
, 32);
9527 digest
[0] = byte_swap_32 (digest
[0]);
9528 digest
[1] = byte_swap_32 (digest
[1]);
9529 digest
[2] = byte_swap_32 (digest
[2]);
9530 digest
[3] = byte_swap_32 (digest
[3]);
9531 digest
[4] = byte_swap_32 (digest
[4]);
9532 digest
[5] = byte_swap_32 (digest
[5]);
9533 digest
[6] = byte_swap_32 (digest
[6]);
9534 digest
[7] = byte_swap_32 (digest
[7]);
9536 digest
[0] -= SHA256M_A
;
9537 digest
[1] -= SHA256M_B
;
9538 digest
[2] -= SHA256M_C
;
9539 digest
[3] -= SHA256M_D
;
9540 digest
[4] -= SHA256M_E
;
9541 digest
[5] -= SHA256M_F
;
9542 digest
[6] -= SHA256M_G
;
9543 digest
[7] -= SHA256M_H
;
9548 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9550 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9552 u32
*digest
= (u32
*) hash_buf
->digest
;
9554 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9555 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9557 digest
[0] = byte_swap_32 (digest
[0]);
9558 digest
[1] = byte_swap_32 (digest
[1]);
9562 IP (digest
[0], digest
[1], tt
);
9564 digest
[0] = digest
[0];
9565 digest
[1] = digest
[1];
9572 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9574 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9576 u32
*digest
= (u32
*) hash_buf
->digest
;
9578 salt_t
*salt
= hash_buf
->salt
;
9580 char *hash_pos
= input_buf
+ 8;
9582 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9583 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9584 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9585 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9586 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9588 digest
[0] -= SHA1M_A
;
9589 digest
[1] -= SHA1M_B
;
9590 digest
[2] -= SHA1M_C
;
9591 digest
[3] -= SHA1M_D
;
9592 digest
[4] -= SHA1M_E
;
9596 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9598 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9600 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9602 salt
->salt_len
= salt_len
;
9607 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9609 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9611 u64
*digest
= (u64
*) hash_buf
->digest
;
9613 salt_t
*salt
= hash_buf
->salt
;
9615 char *hash_pos
= input_buf
+ 8;
9617 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9618 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9619 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9620 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9621 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9622 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9623 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9624 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9626 digest
[0] -= SHA512M_A
;
9627 digest
[1] -= SHA512M_B
;
9628 digest
[2] -= SHA512M_C
;
9629 digest
[3] -= SHA512M_D
;
9630 digest
[4] -= SHA512M_E
;
9631 digest
[5] -= SHA512M_F
;
9632 digest
[6] -= SHA512M_G
;
9633 digest
[7] -= SHA512M_H
;
9637 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9639 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9641 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9643 salt
->salt_len
= salt_len
;
9648 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9650 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9652 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9656 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9659 u32
*digest
= (u32
*) hash_buf
->digest
;
9661 salt_t
*salt
= hash_buf
->salt
;
9663 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9664 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9665 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9666 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9668 digest
[0] = byte_swap_32 (digest
[0]);
9669 digest
[1] = byte_swap_32 (digest
[1]);
9670 digest
[2] = byte_swap_32 (digest
[2]);
9671 digest
[3] = byte_swap_32 (digest
[3]);
9673 digest
[0] -= MD5M_A
;
9674 digest
[1] -= MD5M_B
;
9675 digest
[2] -= MD5M_C
;
9676 digest
[3] -= MD5M_D
;
9678 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9680 uint salt_len
= input_len
- 32 - 1;
9682 char *salt_buf
= input_buf
+ 32 + 1;
9684 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9686 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9688 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9690 salt
->salt_len
= salt_len
;
9695 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9697 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9699 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9703 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9708 char clean_input_buf
[32];
9710 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9711 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9713 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9717 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9723 clean_input_buf
[k
] = input_buf
[i
];
9731 u32
*digest
= (u32
*) hash_buf
->digest
;
9733 salt_t
*salt
= hash_buf
->salt
;
9735 u32 a
, b
, c
, d
, e
, f
;
9737 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9738 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9739 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9740 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9741 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9742 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9744 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9745 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9747 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9748 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9749 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9750 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9751 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9752 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9754 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9755 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9757 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9758 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9759 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9760 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9761 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9762 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9764 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9765 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9767 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9768 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9769 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9770 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9771 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9772 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9774 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9775 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9777 digest
[0] = byte_swap_32 (digest
[0]);
9778 digest
[1] = byte_swap_32 (digest
[1]);
9779 digest
[2] = byte_swap_32 (digest
[2]);
9780 digest
[3] = byte_swap_32 (digest
[3]);
9782 digest
[0] -= MD5M_A
;
9783 digest
[1] -= MD5M_B
;
9784 digest
[2] -= MD5M_C
;
9785 digest
[3] -= MD5M_D
;
9787 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9789 uint salt_len
= input_len
- 30 - 1;
9791 char *salt_buf
= input_buf
+ 30 + 1;
9793 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9795 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9797 // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
9798 if (salt_len
> 10) return (PARSER_SALT_LENGTH
);
9800 salt
->salt_len
= salt_len
;
9802 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9804 salt
->salt_len
+= 22;
9809 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9811 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9813 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9817 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9820 u32
*digest
= (u32
*) hash_buf
->digest
;
9822 salt_t
*salt
= hash_buf
->salt
;
9824 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9825 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9826 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9827 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9828 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
9830 digest
[0] -= SHA1M_A
;
9831 digest
[1] -= SHA1M_B
;
9832 digest
[2] -= SHA1M_C
;
9833 digest
[3] -= SHA1M_D
;
9834 digest
[4] -= SHA1M_E
;
9836 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9838 uint salt_len
= input_len
- 40 - 1;
9840 char *salt_buf
= input_buf
+ 40 + 1;
9842 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9844 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9846 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9848 salt
->salt_len
= salt_len
;
9853 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9855 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9857 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9861 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9864 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9866 char *iter_pos
= input_buf
+ 6;
9868 salt_t
*salt
= hash_buf
->salt
;
9870 uint iter
= atoi (iter_pos
);
9877 salt
->salt_iter
= iter
- 1;
9879 char *salt_pos
= strchr (iter_pos
, '#');
9881 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9885 char *digest_pos
= strchr (salt_pos
, '#');
9887 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9891 uint salt_len
= digest_pos
- salt_pos
- 1;
9893 u32
*digest
= (u32
*) hash_buf
->digest
;
9895 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
9896 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
9897 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
9898 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
9900 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9902 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9904 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9906 salt
->salt_len
= salt_len
;
9911 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9913 u32
*digest
= (u32
*) hash_buf
->digest
;
9915 salt_t
*salt
= hash_buf
->salt
;
9917 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
9921 memcpy (&in
, input_buf
, input_len
);
9923 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
9925 memcpy (digest
, in
.keymic
, 16);
9928 http://www.one-net.eu/jsw/j_sec/m_ptype.html
9929 The phrase "Pairwise key expansion"
9930 Access Point Address (Referred to as Authenticator Address AA)
9931 Supplicant Address (referred to as Supplicant Address SA)
9932 Access Point Nonce (referred to as Authenticator Anonce)
9933 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
9936 uint salt_len
= strlen (in
.essid
);
9938 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
9940 salt
->salt_len
= salt_len
;
9942 salt
->salt_iter
= ROUNDS_WPA2
- 1;
9944 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
9946 memcpy (pke_ptr
, "Pairwise key expansion", 23);
9948 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
9950 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
9951 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
9955 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
9956 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
9959 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
9961 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
9962 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
9966 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
9967 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
9970 for (int i
= 0; i
< 25; i
++)
9972 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
9975 wpa
->keyver
= in
.keyver
;
9977 if (wpa
->keyver
> 255)
9979 log_info ("ATTENTION!");
9980 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
9981 log_info (" This could be due to a recent aircrack-ng bug.");
9982 log_info (" The key version was automatically reset to a reasonable value.");
9985 wpa
->keyver
&= 0xff;
9988 wpa
->eapol_size
= in
.eapol_size
;
9990 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
9992 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
9994 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
9996 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
9998 if (wpa
->keyver
== 1)
10004 digest
[0] = byte_swap_32 (digest
[0]);
10005 digest
[1] = byte_swap_32 (digest
[1]);
10006 digest
[2] = byte_swap_32 (digest
[2]);
10007 digest
[3] = byte_swap_32 (digest
[3]);
10009 for (int i
= 0; i
< 64; i
++)
10011 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10015 salt
->salt_buf
[10] = digest
[1];
10016 salt
->salt_buf
[11] = digest
[2];
10018 return (PARSER_OK
);
10021 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10023 u32
*digest
= (u32
*) hash_buf
->digest
;
10025 salt_t
*salt
= hash_buf
->salt
;
10027 if (input_len
== 0)
10029 log_error ("Password Safe v2 container not specified");
10034 FILE *fp
= fopen (input_buf
, "rb");
10038 log_error ("%s: %s", input_buf
, strerror (errno
));
10047 u32 salt
[5]; // unused, but makes better valid check
10048 u32 iv
[2]; // unused, but makes better valid check
10054 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10058 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10060 salt
->salt_buf
[0] = buf
.random
[0];
10061 salt
->salt_buf
[1] = buf
.random
[1];
10063 salt
->salt_len
= 8;
10064 salt
->salt_iter
= 1000;
10066 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10067 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10068 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10069 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10070 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10072 return (PARSER_OK
);
10075 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10077 u32
*digest
= (u32
*) hash_buf
->digest
;
10079 salt_t
*salt
= hash_buf
->salt
;
10081 if (input_len
== 0)
10083 log_error (".psafe3 not specified");
10088 FILE *fp
= fopen (input_buf
, "rb");
10092 log_error ("%s: %s", input_buf
, strerror (errno
));
10099 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10103 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10105 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10107 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10109 salt
->salt_iter
= in
.iterations
+ 1;
10111 salt
->salt_buf
[0] = in
.salt_buf
[0];
10112 salt
->salt_buf
[1] = in
.salt_buf
[1];
10113 salt
->salt_buf
[2] = in
.salt_buf
[2];
10114 salt
->salt_buf
[3] = in
.salt_buf
[3];
10115 salt
->salt_buf
[4] = in
.salt_buf
[4];
10116 salt
->salt_buf
[5] = in
.salt_buf
[5];
10117 salt
->salt_buf
[6] = in
.salt_buf
[6];
10118 salt
->salt_buf
[7] = in
.salt_buf
[7];
10120 salt
->salt_len
= 32;
10122 digest
[0] = in
.hash_buf
[0];
10123 digest
[1] = in
.hash_buf
[1];
10124 digest
[2] = in
.hash_buf
[2];
10125 digest
[3] = in
.hash_buf
[3];
10126 digest
[4] = in
.hash_buf
[4];
10127 digest
[5] = in
.hash_buf
[5];
10128 digest
[6] = in
.hash_buf
[6];
10129 digest
[7] = in
.hash_buf
[7];
10131 digest
[0] = byte_swap_32 (digest
[0]);
10132 digest
[1] = byte_swap_32 (digest
[1]);
10133 digest
[2] = byte_swap_32 (digest
[2]);
10134 digest
[3] = byte_swap_32 (digest
[3]);
10135 digest
[4] = byte_swap_32 (digest
[4]);
10136 digest
[5] = byte_swap_32 (digest
[5]);
10137 digest
[6] = byte_swap_32 (digest
[6]);
10138 digest
[7] = byte_swap_32 (digest
[7]);
10140 return (PARSER_OK
);
10143 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10145 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10147 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10149 u32
*digest
= (u32
*) hash_buf
->digest
;
10151 salt_t
*salt
= hash_buf
->salt
;
10153 char *iter_pos
= input_buf
+ 3;
10155 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10157 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10159 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10161 salt
->salt_iter
= salt_iter
;
10163 char *salt_pos
= iter_pos
+ 1;
10167 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10169 salt
->salt_len
= salt_len
;
10171 char *hash_pos
= salt_pos
+ salt_len
;
10173 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10175 return (PARSER_OK
);
10178 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10180 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10182 u32
*digest
= (u32
*) hash_buf
->digest
;
10184 salt_t
*salt
= hash_buf
->salt
;
10186 char *salt_pos
= input_buf
+ 3;
10188 uint iterations_len
= 0;
10190 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10194 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10196 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10197 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10201 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10205 iterations_len
+= 8;
10209 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10212 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10214 char *hash_pos
= strchr (salt_pos
, '$');
10216 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10218 uint salt_len
= hash_pos
- salt_pos
;
10220 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10222 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10224 salt
->salt_len
= salt_len
;
10228 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10230 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10232 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10234 return (PARSER_OK
);
10237 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10239 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10241 u32
*digest
= (u32
*) hash_buf
->digest
;
10243 salt_t
*salt
= hash_buf
->salt
;
10245 char *salt_pos
= input_buf
+ 6;
10247 uint iterations_len
= 0;
10249 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10253 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10255 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10256 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10260 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10264 iterations_len
+= 8;
10268 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10271 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10273 char *hash_pos
= strchr (salt_pos
, '$');
10275 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10277 uint salt_len
= hash_pos
- salt_pos
;
10279 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10281 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10283 salt
->salt_len
= salt_len
;
10287 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10289 return (PARSER_OK
);
10292 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10294 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10296 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10298 u32
*digest
= (u32
*) hash_buf
->digest
;
10300 salt_t
*salt
= hash_buf
->salt
;
10302 char *salt_pos
= input_buf
+ 14;
10304 char *hash_pos
= strchr (salt_pos
, '*');
10306 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10310 uint salt_len
= hash_pos
- salt_pos
- 1;
10312 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10314 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10316 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10318 salt
->salt_len
= salt_len
;
10322 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10324 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10326 memcpy (digest
, tmp_buf
, 20);
10328 digest
[0] = byte_swap_32 (digest
[0]);
10329 digest
[1] = byte_swap_32 (digest
[1]);
10330 digest
[2] = byte_swap_32 (digest
[2]);
10331 digest
[3] = byte_swap_32 (digest
[3]);
10332 digest
[4] = byte_swap_32 (digest
[4]);
10334 digest
[0] -= SHA1M_A
;
10335 digest
[1] -= SHA1M_B
;
10336 digest
[2] -= SHA1M_C
;
10337 digest
[3] -= SHA1M_D
;
10338 digest
[4] -= SHA1M_E
;
10340 return (PARSER_OK
);
10343 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10345 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10347 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10349 if (c12
& 3) return (PARSER_HASH_VALUE
);
10351 u32
*digest
= (u32
*) hash_buf
->digest
;
10353 salt_t
*salt
= hash_buf
->salt
;
10355 // for ascii_digest
10356 salt
->salt_sign
[0] = input_buf
[0];
10357 salt
->salt_sign
[1] = input_buf
[1];
10359 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10360 | itoa64_to_int (input_buf
[1]) << 6;
10362 salt
->salt_len
= 2;
10366 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10368 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10370 memcpy (digest
, tmp_buf
, 8);
10374 IP (digest
[0], digest
[1], tt
);
10379 return (PARSER_OK
);
10382 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10384 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10386 u32
*digest
= (u32
*) hash_buf
->digest
;
10388 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10389 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10390 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10391 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10393 digest
[0] = byte_swap_32 (digest
[0]);
10394 digest
[1] = byte_swap_32 (digest
[1]);
10395 digest
[2] = byte_swap_32 (digest
[2]);
10396 digest
[3] = byte_swap_32 (digest
[3]);
10398 digest
[0] -= MD4M_A
;
10399 digest
[1] -= MD4M_B
;
10400 digest
[2] -= MD4M_C
;
10401 digest
[3] -= MD4M_D
;
10403 return (PARSER_OK
);
10406 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10408 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10410 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10414 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10417 u32
*digest
= (u32
*) hash_buf
->digest
;
10419 salt_t
*salt
= hash_buf
->salt
;
10421 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10422 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10423 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10424 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10426 digest
[0] = byte_swap_32 (digest
[0]);
10427 digest
[1] = byte_swap_32 (digest
[1]);
10428 digest
[2] = byte_swap_32 (digest
[2]);
10429 digest
[3] = byte_swap_32 (digest
[3]);
10431 digest
[0] -= MD4M_A
;
10432 digest
[1] -= MD4M_B
;
10433 digest
[2] -= MD4M_C
;
10434 digest
[3] -= MD4M_D
;
10436 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10438 uint salt_len
= input_len
- 32 - 1;
10440 char *salt_buf
= input_buf
+ 32 + 1;
10442 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10444 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10446 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10448 salt
->salt_len
= salt_len
;
10450 return (PARSER_OK
);
10453 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10455 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10457 u32
*digest
= (u32
*) hash_buf
->digest
;
10459 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10460 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10461 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10462 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10464 digest
[0] = byte_swap_32 (digest
[0]);
10465 digest
[1] = byte_swap_32 (digest
[1]);
10466 digest
[2] = byte_swap_32 (digest
[2]);
10467 digest
[3] = byte_swap_32 (digest
[3]);
10469 digest
[0] -= MD5M_A
;
10470 digest
[1] -= MD5M_B
;
10471 digest
[2] -= MD5M_C
;
10472 digest
[3] -= MD5M_D
;
10474 return (PARSER_OK
);
10477 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10479 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10481 u32
*digest
= (u32
*) hash_buf
->digest
;
10483 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10484 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10488 digest
[0] = byte_swap_32 (digest
[0]);
10489 digest
[1] = byte_swap_32 (digest
[1]);
10491 return (PARSER_OK
);
10494 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10496 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10498 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10502 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10505 u32
*digest
= (u32
*) hash_buf
->digest
;
10507 salt_t
*salt
= hash_buf
->salt
;
10509 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10510 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10511 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10512 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10514 digest
[0] = byte_swap_32 (digest
[0]);
10515 digest
[1] = byte_swap_32 (digest
[1]);
10516 digest
[2] = byte_swap_32 (digest
[2]);
10517 digest
[3] = byte_swap_32 (digest
[3]);
10519 digest
[0] -= MD5M_A
;
10520 digest
[1] -= MD5M_B
;
10521 digest
[2] -= MD5M_C
;
10522 digest
[3] -= MD5M_D
;
10524 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10526 uint salt_len
= input_len
- 32 - 1;
10528 char *salt_buf
= input_buf
+ 32 + 1;
10530 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10532 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10534 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10536 salt
->salt_len
= salt_len
;
10538 return (PARSER_OK
);
10541 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10543 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10545 u32
*digest
= (u32
*) hash_buf
->digest
;
10547 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10548 | itoa64_to_int (input_buf
[ 1]) << 6
10549 | itoa64_to_int (input_buf
[ 2]) << 12
10550 | itoa64_to_int (input_buf
[ 3]) << 18;
10551 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10552 | itoa64_to_int (input_buf
[ 5]) << 6
10553 | itoa64_to_int (input_buf
[ 6]) << 12
10554 | itoa64_to_int (input_buf
[ 7]) << 18;
10555 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10556 | itoa64_to_int (input_buf
[ 9]) << 6
10557 | itoa64_to_int (input_buf
[10]) << 12
10558 | itoa64_to_int (input_buf
[11]) << 18;
10559 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10560 | itoa64_to_int (input_buf
[13]) << 6
10561 | itoa64_to_int (input_buf
[14]) << 12
10562 | itoa64_to_int (input_buf
[15]) << 18;
10564 digest
[0] -= MD5M_A
;
10565 digest
[1] -= MD5M_B
;
10566 digest
[2] -= MD5M_C
;
10567 digest
[3] -= MD5M_D
;
10569 digest
[0] &= 0x00ffffff;
10570 digest
[1] &= 0x00ffffff;
10571 digest
[2] &= 0x00ffffff;
10572 digest
[3] &= 0x00ffffff;
10574 return (PARSER_OK
);
10577 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10579 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10581 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10585 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10588 u32
*digest
= (u32
*) hash_buf
->digest
;
10590 salt_t
*salt
= hash_buf
->salt
;
10592 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10593 | itoa64_to_int (input_buf
[ 1]) << 6
10594 | itoa64_to_int (input_buf
[ 2]) << 12
10595 | itoa64_to_int (input_buf
[ 3]) << 18;
10596 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10597 | itoa64_to_int (input_buf
[ 5]) << 6
10598 | itoa64_to_int (input_buf
[ 6]) << 12
10599 | itoa64_to_int (input_buf
[ 7]) << 18;
10600 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10601 | itoa64_to_int (input_buf
[ 9]) << 6
10602 | itoa64_to_int (input_buf
[10]) << 12
10603 | itoa64_to_int (input_buf
[11]) << 18;
10604 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10605 | itoa64_to_int (input_buf
[13]) << 6
10606 | itoa64_to_int (input_buf
[14]) << 12
10607 | itoa64_to_int (input_buf
[15]) << 18;
10609 digest
[0] -= MD5M_A
;
10610 digest
[1] -= MD5M_B
;
10611 digest
[2] -= MD5M_C
;
10612 digest
[3] -= MD5M_D
;
10614 digest
[0] &= 0x00ffffff;
10615 digest
[1] &= 0x00ffffff;
10616 digest
[2] &= 0x00ffffff;
10617 digest
[3] &= 0x00ffffff;
10619 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10621 uint salt_len
= input_len
- 16 - 1;
10623 char *salt_buf
= input_buf
+ 16 + 1;
10625 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10627 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10629 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10631 salt
->salt_len
= salt_len
;
10633 return (PARSER_OK
);
10636 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10638 key
[0] = (nthash
[0] >> 0);
10639 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10640 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10641 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10642 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10643 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10644 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10645 key
[7] = (nthash
[6] << 1);
10657 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10659 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10661 u32
*digest
= (u32
*) hash_buf
->digest
;
10663 salt_t
*salt
= hash_buf
->salt
;
10665 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10671 char *user_pos
= input_buf
;
10673 char *unused_pos
= strchr (user_pos
, ':');
10675 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10677 uint user_len
= unused_pos
- user_pos
;
10679 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10683 char *domain_pos
= strchr (unused_pos
, ':');
10685 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10687 uint unused_len
= domain_pos
- unused_pos
;
10689 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10693 char *srvchall_pos
= strchr (domain_pos
, ':');
10695 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10697 uint domain_len
= srvchall_pos
- domain_pos
;
10699 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10703 char *hash_pos
= strchr (srvchall_pos
, ':');
10705 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10707 uint srvchall_len
= hash_pos
- srvchall_pos
;
10709 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10713 char *clichall_pos
= strchr (hash_pos
, ':');
10715 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10717 uint hash_len
= clichall_pos
- hash_pos
;
10719 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10723 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10725 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10728 * store some data for later use
10731 netntlm
->user_len
= user_len
* 2;
10732 netntlm
->domain_len
= domain_len
* 2;
10733 netntlm
->srvchall_len
= srvchall_len
/ 2;
10734 netntlm
->clichall_len
= clichall_len
/ 2;
10736 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10737 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10740 * handle username and domainname
10743 for (uint i
= 0; i
< user_len
; i
++)
10745 *userdomain_ptr
++ = user_pos
[i
];
10746 *userdomain_ptr
++ = 0;
10749 for (uint i
= 0; i
< domain_len
; i
++)
10751 *userdomain_ptr
++ = domain_pos
[i
];
10752 *userdomain_ptr
++ = 0;
10756 * handle server challenge encoding
10759 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10761 const char p0
= srvchall_pos
[i
+ 0];
10762 const char p1
= srvchall_pos
[i
+ 1];
10764 *chall_ptr
++ = hex_convert (p1
) << 0
10765 | hex_convert (p0
) << 4;
10769 * handle client challenge encoding
10772 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10774 const char p0
= clichall_pos
[i
+ 0];
10775 const char p1
= clichall_pos
[i
+ 1];
10777 *chall_ptr
++ = hex_convert (p1
) << 0
10778 | hex_convert (p0
) << 4;
10785 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10787 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10789 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10791 salt
->salt_len
= salt_len
;
10793 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10794 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10795 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10796 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10798 digest
[0] = byte_swap_32 (digest
[0]);
10799 digest
[1] = byte_swap_32 (digest
[1]);
10800 digest
[2] = byte_swap_32 (digest
[2]);
10801 digest
[3] = byte_swap_32 (digest
[3]);
10803 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10805 uint digest_tmp
[2];
10807 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10808 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
10810 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10811 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10813 /* special case 2: ESS */
10815 if (srvchall_len
== 48)
10817 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10821 w
[ 0] = netntlm
->chall_buf
[6];
10822 w
[ 1] = netntlm
->chall_buf
[7];
10823 w
[ 2] = netntlm
->chall_buf
[0];
10824 w
[ 3] = netntlm
->chall_buf
[1];
10847 salt
->salt_buf
[0] = dgst
[0];
10848 salt
->salt_buf
[1] = dgst
[1];
10852 /* precompute netntlmv1 exploit start */
10854 for (uint i
= 0; i
< 0x10000; i
++)
10856 uint key_md4
[2] = { i
, 0 };
10857 uint key_des
[2] = { 0, 0 };
10859 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
10864 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10866 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10868 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10870 if (data3
[0] != digest_tmp
[0]) continue;
10871 if (data3
[1] != digest_tmp
[1]) continue;
10873 salt
->salt_buf
[2] = i
;
10875 salt
->salt_len
= 24;
10880 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10881 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10883 /* precompute netntlmv1 exploit stop */
10887 IP (digest
[0], digest
[1], tt
);
10888 IP (digest
[2], digest
[3], tt
);
10890 digest
[0] = rotr32 (digest
[0], 29);
10891 digest
[1] = rotr32 (digest
[1], 29);
10892 digest
[2] = rotr32 (digest
[2], 29);
10893 digest
[3] = rotr32 (digest
[3], 29);
10895 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10897 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
10898 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
10900 return (PARSER_OK
);
10903 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10905 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10907 u32
*digest
= (u32
*) hash_buf
->digest
;
10909 salt_t
*salt
= hash_buf
->salt
;
10911 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10917 char *user_pos
= input_buf
;
10919 char *unused_pos
= strchr (user_pos
, ':');
10921 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10923 uint user_len
= unused_pos
- user_pos
;
10925 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10929 char *domain_pos
= strchr (unused_pos
, ':');
10931 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10933 uint unused_len
= domain_pos
- unused_pos
;
10935 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10939 char *srvchall_pos
= strchr (domain_pos
, ':');
10941 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10943 uint domain_len
= srvchall_pos
- domain_pos
;
10945 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10949 char *hash_pos
= strchr (srvchall_pos
, ':');
10951 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10953 uint srvchall_len
= hash_pos
- srvchall_pos
;
10955 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
10959 char *clichall_pos
= strchr (hash_pos
, ':');
10961 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10963 uint hash_len
= clichall_pos
- hash_pos
;
10965 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
10969 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10971 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
10973 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
10976 * store some data for later use
10979 netntlm
->user_len
= user_len
* 2;
10980 netntlm
->domain_len
= domain_len
* 2;
10981 netntlm
->srvchall_len
= srvchall_len
/ 2;
10982 netntlm
->clichall_len
= clichall_len
/ 2;
10984 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10985 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10988 * handle username and domainname
10991 for (uint i
= 0; i
< user_len
; i
++)
10993 *userdomain_ptr
++ = toupper (user_pos
[i
]);
10994 *userdomain_ptr
++ = 0;
10997 for (uint i
= 0; i
< domain_len
; i
++)
10999 *userdomain_ptr
++ = domain_pos
[i
];
11000 *userdomain_ptr
++ = 0;
11003 *userdomain_ptr
++ = 0x80;
11006 * handle server challenge encoding
11009 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11011 const char p0
= srvchall_pos
[i
+ 0];
11012 const char p1
= srvchall_pos
[i
+ 1];
11014 *chall_ptr
++ = hex_convert (p1
) << 0
11015 | hex_convert (p0
) << 4;
11019 * handle client challenge encoding
11022 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11024 const char p0
= clichall_pos
[i
+ 0];
11025 const char p1
= clichall_pos
[i
+ 1];
11027 *chall_ptr
++ = hex_convert (p1
) << 0
11028 | hex_convert (p0
) << 4;
11031 *chall_ptr
++ = 0x80;
11034 * handle hash itself
11037 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11038 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11039 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11040 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11042 digest
[0] = byte_swap_32 (digest
[0]);
11043 digest
[1] = byte_swap_32 (digest
[1]);
11044 digest
[2] = byte_swap_32 (digest
[2]);
11045 digest
[3] = byte_swap_32 (digest
[3]);
11048 * reuse challange data as salt_buf, its the buffer that is most likely unique
11051 salt
->salt_buf
[0] = 0;
11052 salt
->salt_buf
[1] = 0;
11053 salt
->salt_buf
[2] = 0;
11054 salt
->salt_buf
[3] = 0;
11055 salt
->salt_buf
[4] = 0;
11056 salt
->salt_buf
[5] = 0;
11057 salt
->salt_buf
[6] = 0;
11058 salt
->salt_buf
[7] = 0;
11062 uptr
= (uint
*) netntlm
->userdomain_buf
;
11064 for (uint i
= 0; i
< 16; i
+= 16)
11066 md5_64 (uptr
, salt
->salt_buf
);
11069 uptr
= (uint
*) netntlm
->chall_buf
;
11071 for (uint i
= 0; i
< 256; i
+= 16)
11073 md5_64 (uptr
, salt
->salt_buf
);
11076 salt
->salt_len
= 16;
11078 return (PARSER_OK
);
11081 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11083 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11085 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11089 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11092 u32
*digest
= (u32
*) hash_buf
->digest
;
11094 salt_t
*salt
= hash_buf
->salt
;
11096 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11097 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11098 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11099 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11101 digest
[0] = byte_swap_32 (digest
[0]);
11102 digest
[1] = byte_swap_32 (digest
[1]);
11103 digest
[2] = byte_swap_32 (digest
[2]);
11104 digest
[3] = byte_swap_32 (digest
[3]);
11106 digest
[0] -= MD5M_A
;
11107 digest
[1] -= MD5M_B
;
11108 digest
[2] -= MD5M_C
;
11109 digest
[3] -= MD5M_D
;
11111 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11113 uint salt_len
= input_len
- 32 - 1;
11115 char *salt_buf
= input_buf
+ 32 + 1;
11117 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11119 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11121 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11123 salt
->salt_len
= salt_len
;
11125 return (PARSER_OK
);
11128 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11130 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11132 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11136 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11139 u32
*digest
= (u32
*) hash_buf
->digest
;
11141 salt_t
*salt
= hash_buf
->salt
;
11143 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11144 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11145 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11146 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11148 digest
[0] = byte_swap_32 (digest
[0]);
11149 digest
[1] = byte_swap_32 (digest
[1]);
11150 digest
[2] = byte_swap_32 (digest
[2]);
11151 digest
[3] = byte_swap_32 (digest
[3]);
11153 digest
[0] -= MD5M_A
;
11154 digest
[1] -= MD5M_B
;
11155 digest
[2] -= MD5M_C
;
11156 digest
[3] -= MD5M_D
;
11158 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11160 uint salt_len
= input_len
- 32 - 1;
11162 char *salt_buf
= input_buf
+ 32 + 1;
11164 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11166 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11168 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11170 salt
->salt_len
= salt_len
;
11172 return (PARSER_OK
);
11175 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11177 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11179 u32
*digest
= (u32
*) hash_buf
->digest
;
11181 salt_t
*salt
= hash_buf
->salt
;
11183 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11184 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11185 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11186 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11188 digest
[0] = byte_swap_32 (digest
[0]);
11189 digest
[1] = byte_swap_32 (digest
[1]);
11190 digest
[2] = byte_swap_32 (digest
[2]);
11191 digest
[3] = byte_swap_32 (digest
[3]);
11193 digest
[0] -= MD5M_A
;
11194 digest
[1] -= MD5M_B
;
11195 digest
[2] -= MD5M_C
;
11196 digest
[3] -= MD5M_D
;
11199 * This is a virtual salt. While the algorithm is basically not salted
11200 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11201 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11204 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11206 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11208 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11210 salt
->salt_len
= salt_len
;
11212 return (PARSER_OK
);
11215 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11217 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11219 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11223 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11226 u32
*digest
= (u32
*) hash_buf
->digest
;
11228 salt_t
*salt
= hash_buf
->salt
;
11230 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11231 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11232 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11233 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11235 digest
[0] = byte_swap_32 (digest
[0]);
11236 digest
[1] = byte_swap_32 (digest
[1]);
11237 digest
[2] = byte_swap_32 (digest
[2]);
11238 digest
[3] = byte_swap_32 (digest
[3]);
11240 digest
[0] -= MD5M_A
;
11241 digest
[1] -= MD5M_B
;
11242 digest
[2] -= MD5M_C
;
11243 digest
[3] -= MD5M_D
;
11245 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11247 uint salt_len
= input_len
- 32 - 1;
11249 char *salt_buf
= input_buf
+ 32 + 1;
11251 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11253 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11255 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11257 salt
->salt_len
= salt_len
;
11259 return (PARSER_OK
);
11262 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11264 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11266 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11270 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11273 u32
*digest
= (u32
*) hash_buf
->digest
;
11275 salt_t
*salt
= hash_buf
->salt
;
11277 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11278 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11279 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11280 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11282 digest
[0] = byte_swap_32 (digest
[0]);
11283 digest
[1] = byte_swap_32 (digest
[1]);
11284 digest
[2] = byte_swap_32 (digest
[2]);
11285 digest
[3] = byte_swap_32 (digest
[3]);
11287 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11289 uint salt_len
= input_len
- 32 - 1;
11291 char *salt_buf
= input_buf
+ 32 + 1;
11293 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11295 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11297 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11299 salt
->salt_len
= salt_len
;
11301 return (PARSER_OK
);
11304 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11306 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11308 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11312 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11315 u32
*digest
= (u32
*) hash_buf
->digest
;
11317 salt_t
*salt
= hash_buf
->salt
;
11319 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11320 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11321 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11322 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11324 digest
[0] = byte_swap_32 (digest
[0]);
11325 digest
[1] = byte_swap_32 (digest
[1]);
11326 digest
[2] = byte_swap_32 (digest
[2]);
11327 digest
[3] = byte_swap_32 (digest
[3]);
11329 digest
[0] -= MD4M_A
;
11330 digest
[1] -= MD4M_B
;
11331 digest
[2] -= MD4M_C
;
11332 digest
[3] -= MD4M_D
;
11334 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11336 uint salt_len
= input_len
- 32 - 1;
11338 char *salt_buf
= input_buf
+ 32 + 1;
11340 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11342 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11344 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11346 salt
->salt_len
= salt_len
;
11348 return (PARSER_OK
);
11351 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11353 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11355 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11359 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11362 u32
*digest
= (u32
*) hash_buf
->digest
;
11364 salt_t
*salt
= hash_buf
->salt
;
11366 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11367 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11368 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11369 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11371 digest
[0] = byte_swap_32 (digest
[0]);
11372 digest
[1] = byte_swap_32 (digest
[1]);
11373 digest
[2] = byte_swap_32 (digest
[2]);
11374 digest
[3] = byte_swap_32 (digest
[3]);
11376 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11378 uint salt_len
= input_len
- 32 - 1;
11380 char *salt_buf
= input_buf
+ 32 + 1;
11382 uint salt_pc_block
[16];
11384 memset (salt_pc_block
, 0, sizeof (salt_pc_block
));
11386 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11388 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11390 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11392 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11394 salt_pc_block
[14] = salt_len
* 8;
11396 uint salt_pc_digest
[4];
11398 salt_pc_digest
[0] = MAGIC_A
;
11399 salt_pc_digest
[1] = MAGIC_B
;
11400 salt_pc_digest
[2] = MAGIC_C
;
11401 salt_pc_digest
[3] = MAGIC_D
;
11403 md5_64 (salt_pc_block
, salt_pc_digest
);
11405 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11406 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11407 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11408 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11410 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11412 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11414 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11416 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11417 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11418 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11419 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11421 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11423 return (PARSER_OK
);
11426 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11428 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11430 u32
*digest
= (u32
*) hash_buf
->digest
;
11432 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11433 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11434 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11435 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11436 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11438 digest
[0] -= SHA1M_A
;
11439 digest
[1] -= SHA1M_B
;
11440 digest
[2] -= SHA1M_C
;
11441 digest
[3] -= SHA1M_D
;
11442 digest
[4] -= SHA1M_E
;
11444 return (PARSER_OK
);
11447 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11449 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11451 u32
*digest
= (u32
*) hash_buf
->digest
;
11453 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11454 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11455 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11456 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11457 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11459 return (PARSER_OK
);
11462 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11464 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11466 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11470 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11473 u32
*digest
= (u32
*) hash_buf
->digest
;
11475 salt_t
*salt
= hash_buf
->salt
;
11477 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11478 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11479 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11480 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11481 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11483 digest
[0] -= SHA1M_A
;
11484 digest
[1] -= SHA1M_B
;
11485 digest
[2] -= SHA1M_C
;
11486 digest
[3] -= SHA1M_D
;
11487 digest
[4] -= SHA1M_E
;
11489 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11491 uint salt_len
= input_len
- 40 - 1;
11493 char *salt_buf
= input_buf
+ 40 + 1;
11495 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11497 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11499 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11501 salt
->salt_len
= salt_len
;
11503 return (PARSER_OK
);
11506 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11508 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11510 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11512 u32
*digest
= (u32
*) hash_buf
->digest
;
11516 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11518 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11520 memcpy (digest
, tmp_buf
, 20);
11522 digest
[0] = byte_swap_32 (digest
[0]);
11523 digest
[1] = byte_swap_32 (digest
[1]);
11524 digest
[2] = byte_swap_32 (digest
[2]);
11525 digest
[3] = byte_swap_32 (digest
[3]);
11526 digest
[4] = byte_swap_32 (digest
[4]);
11528 digest
[0] -= SHA1M_A
;
11529 digest
[1] -= SHA1M_B
;
11530 digest
[2] -= SHA1M_C
;
11531 digest
[3] -= SHA1M_D
;
11532 digest
[4] -= SHA1M_E
;
11534 return (PARSER_OK
);
11537 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11539 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11541 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11543 u32
*digest
= (u32
*) hash_buf
->digest
;
11545 salt_t
*salt
= hash_buf
->salt
;
11549 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11551 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11553 memcpy (digest
, tmp_buf
, 20);
11555 salt
->salt_len
= tmp_len
- 20;
11557 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11559 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11561 char *ptr
= (char *) salt
->salt_buf
;
11563 ptr
[salt
->salt_len
] = 0x80;
11566 digest
[0] = byte_swap_32 (digest
[0]);
11567 digest
[1] = byte_swap_32 (digest
[1]);
11568 digest
[2] = byte_swap_32 (digest
[2]);
11569 digest
[3] = byte_swap_32 (digest
[3]);
11570 digest
[4] = byte_swap_32 (digest
[4]);
11572 digest
[0] -= SHA1M_A
;
11573 digest
[1] -= SHA1M_B
;
11574 digest
[2] -= SHA1M_C
;
11575 digest
[3] -= SHA1M_D
;
11576 digest
[4] -= SHA1M_E
;
11578 return (PARSER_OK
);
11581 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11583 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11585 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11587 u32
*digest
= (u32
*) hash_buf
->digest
;
11589 salt_t
*salt
= hash_buf
->salt
;
11591 char *salt_buf
= input_buf
+ 6;
11595 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11597 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11599 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11601 salt
->salt_len
= salt_len
;
11603 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11605 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11606 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11607 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11608 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11609 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11611 digest
[0] -= SHA1M_A
;
11612 digest
[1] -= SHA1M_B
;
11613 digest
[2] -= SHA1M_C
;
11614 digest
[3] -= SHA1M_D
;
11615 digest
[4] -= SHA1M_E
;
11617 return (PARSER_OK
);
11620 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11622 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11624 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11626 u32
*digest
= (u32
*) hash_buf
->digest
;
11628 salt_t
*salt
= hash_buf
->salt
;
11630 char *salt_buf
= input_buf
+ 6;
11634 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11636 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11638 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11640 salt
->salt_len
= salt_len
;
11642 char *hash_pos
= input_buf
+ 6 + 8;
11644 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11645 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11646 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11647 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11648 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11650 digest
[0] -= SHA1M_A
;
11651 digest
[1] -= SHA1M_B
;
11652 digest
[2] -= SHA1M_C
;
11653 digest
[3] -= SHA1M_D
;
11654 digest
[4] -= SHA1M_E
;
11656 return (PARSER_OK
);
11659 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11661 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11663 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11665 u64
*digest
= (u64
*) hash_buf
->digest
;
11667 salt_t
*salt
= hash_buf
->salt
;
11669 char *salt_buf
= input_buf
+ 6;
11673 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11675 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11677 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11679 salt
->salt_len
= salt_len
;
11681 char *hash_pos
= input_buf
+ 6 + 8;
11683 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11684 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11685 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11686 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11687 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11688 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11689 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11690 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11692 digest
[0] -= SHA512M_A
;
11693 digest
[1] -= SHA512M_B
;
11694 digest
[2] -= SHA512M_C
;
11695 digest
[3] -= SHA512M_D
;
11696 digest
[4] -= SHA512M_E
;
11697 digest
[5] -= SHA512M_F
;
11698 digest
[6] -= SHA512M_G
;
11699 digest
[7] -= SHA512M_H
;
11701 return (PARSER_OK
);
11704 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11706 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11708 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11712 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11715 u32
*digest
= (u32
*) hash_buf
->digest
;
11717 salt_t
*salt
= hash_buf
->salt
;
11719 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11720 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11724 digest
[0] = byte_swap_32 (digest
[0]);
11725 digest
[1] = byte_swap_32 (digest
[1]);
11727 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11729 uint salt_len
= input_len
- 16 - 1;
11731 char *salt_buf
= input_buf
+ 16 + 1;
11733 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11735 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11737 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11739 salt
->salt_len
= salt_len
;
11741 return (PARSER_OK
);
11744 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11746 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11748 u32
*digest
= (u32
*) hash_buf
->digest
;
11750 salt_t
*salt
= hash_buf
->salt
;
11752 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11753 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11754 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11755 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11756 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11758 digest
[0] -= SHA1M_A
;
11759 digest
[1] -= SHA1M_B
;
11760 digest
[2] -= SHA1M_C
;
11761 digest
[3] -= SHA1M_D
;
11762 digest
[4] -= SHA1M_E
;
11764 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11766 uint salt_len
= input_len
- 40 - 1;
11768 char *salt_buf
= input_buf
+ 40 + 1;
11770 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11772 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11774 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11776 salt
->salt_len
= salt_len
;
11778 return (PARSER_OK
);
11781 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11783 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11785 u32
*digest
= (u32
*) hash_buf
->digest
;
11787 salt_t
*salt
= hash_buf
->salt
;
11789 char *hash_pos
= input_buf
;
11791 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11792 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11793 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
11794 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
11795 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
11796 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
11797 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
11798 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
11799 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
11800 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
11801 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
11802 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
11803 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
11804 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
11805 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
11806 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
11808 char *salt_pos
= input_buf
+ 128;
11810 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
11811 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
11812 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
11813 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
11815 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11816 salt
->salt_len
= 16;
11818 return (PARSER_OK
);
11821 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11823 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11825 u32
*digest
= (u32
*) hash_buf
->digest
;
11827 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11828 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11829 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11830 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11831 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11832 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11833 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11834 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11836 digest
[0] -= SHA256M_A
;
11837 digest
[1] -= SHA256M_B
;
11838 digest
[2] -= SHA256M_C
;
11839 digest
[3] -= SHA256M_D
;
11840 digest
[4] -= SHA256M_E
;
11841 digest
[5] -= SHA256M_F
;
11842 digest
[6] -= SHA256M_G
;
11843 digest
[7] -= SHA256M_H
;
11845 return (PARSER_OK
);
11848 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11850 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11852 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11856 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11859 u32
*digest
= (u32
*) hash_buf
->digest
;
11861 salt_t
*salt
= hash_buf
->salt
;
11863 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11864 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11865 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11866 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11867 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11868 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11869 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11870 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11872 digest
[0] -= SHA256M_A
;
11873 digest
[1] -= SHA256M_B
;
11874 digest
[2] -= SHA256M_C
;
11875 digest
[3] -= SHA256M_D
;
11876 digest
[4] -= SHA256M_E
;
11877 digest
[5] -= SHA256M_F
;
11878 digest
[6] -= SHA256M_G
;
11879 digest
[7] -= SHA256M_H
;
11881 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11883 uint salt_len
= input_len
- 64 - 1;
11885 char *salt_buf
= input_buf
+ 64 + 1;
11887 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11889 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11891 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11893 salt
->salt_len
= salt_len
;
11895 return (PARSER_OK
);
11898 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11900 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11902 u64
*digest
= (u64
*) hash_buf
->digest
;
11904 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11905 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11906 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11907 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11908 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11909 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11913 digest
[0] -= SHA384M_A
;
11914 digest
[1] -= SHA384M_B
;
11915 digest
[2] -= SHA384M_C
;
11916 digest
[3] -= SHA384M_D
;
11917 digest
[4] -= SHA384M_E
;
11918 digest
[5] -= SHA384M_F
;
11922 return (PARSER_OK
);
11925 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11927 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
11929 u64
*digest
= (u64
*) hash_buf
->digest
;
11931 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11932 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11933 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11934 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11935 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11936 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11937 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11938 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11940 digest
[0] -= SHA512M_A
;
11941 digest
[1] -= SHA512M_B
;
11942 digest
[2] -= SHA512M_C
;
11943 digest
[3] -= SHA512M_D
;
11944 digest
[4] -= SHA512M_E
;
11945 digest
[5] -= SHA512M_F
;
11946 digest
[6] -= SHA512M_G
;
11947 digest
[7] -= SHA512M_H
;
11949 return (PARSER_OK
);
11952 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11954 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11956 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
11960 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
11963 u64
*digest
= (u64
*) hash_buf
->digest
;
11965 salt_t
*salt
= hash_buf
->salt
;
11967 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11968 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11969 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11970 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11971 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11972 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11973 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11974 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11976 digest
[0] -= SHA512M_A
;
11977 digest
[1] -= SHA512M_B
;
11978 digest
[2] -= SHA512M_C
;
11979 digest
[3] -= SHA512M_D
;
11980 digest
[4] -= SHA512M_E
;
11981 digest
[5] -= SHA512M_F
;
11982 digest
[6] -= SHA512M_G
;
11983 digest
[7] -= SHA512M_H
;
11985 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11987 uint salt_len
= input_len
- 128 - 1;
11989 char *salt_buf
= input_buf
+ 128 + 1;
11991 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11993 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11995 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11997 salt
->salt_len
= salt_len
;
11999 return (PARSER_OK
);
12002 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12004 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12006 u64
*digest
= (u64
*) hash_buf
->digest
;
12008 salt_t
*salt
= hash_buf
->salt
;
12010 char *salt_pos
= input_buf
+ 3;
12012 uint iterations_len
= 0;
12014 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12018 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12020 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12021 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12025 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12029 iterations_len
+= 8;
12033 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12036 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12038 char *hash_pos
= strchr (salt_pos
, '$');
12040 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12042 uint salt_len
= hash_pos
- salt_pos
;
12044 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12046 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12048 salt
->salt_len
= salt_len
;
12052 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12054 return (PARSER_OK
);
12057 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12059 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12061 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12063 u64
*digest
= (u64
*) hash_buf
->digest
;
12065 salt_t
*salt
= hash_buf
->salt
;
12067 uint keccak_mdlen
= input_len
/ 2;
12069 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12071 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12073 digest
[i
] = byte_swap_64 (digest
[i
]);
12076 salt
->keccak_mdlen
= keccak_mdlen
;
12078 return (PARSER_OK
);
12081 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12083 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12085 u32
*digest
= (u32
*) hash_buf
->digest
;
12087 salt_t
*salt
= hash_buf
->salt
;
12089 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12092 * Parse that strange long line
12099 in_off
[0] = strtok (input_buf
, ":");
12101 in_len
[0] = strlen (in_off
[0]);
12105 for (i
= 1; i
< 9; i
++)
12107 in_off
[i
] = strtok (NULL
, ":");
12109 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12111 in_len
[i
] = strlen (in_off
[i
]);
12116 ptr
= (char *) ikepsk
->msg_buf
;
12118 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12119 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12120 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12121 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12122 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12123 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12127 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12129 ptr
= (char *) ikepsk
->nr_buf
;
12131 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12132 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12136 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12139 * Store to database
12144 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12145 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12146 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12147 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12149 digest
[0] = byte_swap_32 (digest
[0]);
12150 digest
[1] = byte_swap_32 (digest
[1]);
12151 digest
[2] = byte_swap_32 (digest
[2]);
12152 digest
[3] = byte_swap_32 (digest
[3]);
12154 salt
->salt_len
= 32;
12156 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12157 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12158 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12159 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12160 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12161 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12162 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12163 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12165 return (PARSER_OK
);
12168 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12170 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12172 u32
*digest
= (u32
*) hash_buf
->digest
;
12174 salt_t
*salt
= hash_buf
->salt
;
12176 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12179 * Parse that strange long line
12186 in_off
[0] = strtok (input_buf
, ":");
12188 in_len
[0] = strlen (in_off
[0]);
12192 for (i
= 1; i
< 9; i
++)
12194 in_off
[i
] = strtok (NULL
, ":");
12196 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12198 in_len
[i
] = strlen (in_off
[i
]);
12203 ptr
= (char *) ikepsk
->msg_buf
;
12205 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12206 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12207 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12208 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12209 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12210 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12214 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12216 ptr
= (char *) ikepsk
->nr_buf
;
12218 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12219 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12223 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12226 * Store to database
12231 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12232 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12233 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12234 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12235 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12237 salt
->salt_len
= 32;
12239 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12240 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12241 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12242 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12243 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12244 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12245 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12246 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12248 return (PARSER_OK
);
12251 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12253 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12255 u32
*digest
= (u32
*) hash_buf
->digest
;
12257 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12258 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12259 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12260 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12261 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12263 digest
[0] = byte_swap_32 (digest
[0]);
12264 digest
[1] = byte_swap_32 (digest
[1]);
12265 digest
[2] = byte_swap_32 (digest
[2]);
12266 digest
[3] = byte_swap_32 (digest
[3]);
12267 digest
[4] = byte_swap_32 (digest
[4]);
12269 return (PARSER_OK
);
12272 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12274 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12276 u32
*digest
= (u32
*) hash_buf
->digest
;
12278 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12279 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12280 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12281 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12282 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12283 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12284 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12285 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12286 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12287 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12288 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12289 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12290 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12291 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12292 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12293 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12295 return (PARSER_OK
);
12298 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12300 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12302 u32
*digest
= (u32
*) hash_buf
->digest
;
12304 salt_t
*salt
= hash_buf
->salt
;
12306 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12307 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12308 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12309 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12310 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12312 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12314 uint salt_len
= input_len
- 40 - 1;
12316 char *salt_buf
= input_buf
+ 40 + 1;
12318 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12320 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12322 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12324 salt
->salt_len
= salt_len
;
12326 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12328 return (PARSER_OK
);
12331 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12333 u32
*digest
= (u32
*) hash_buf
->digest
;
12335 salt_t
*salt
= hash_buf
->salt
;
12337 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12339 if (input_len
== 0)
12341 log_error ("TrueCrypt container not specified");
12346 FILE *fp
= fopen (input_buf
, "rb");
12350 log_error ("%s: %s", input_buf
, strerror (errno
));
12357 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12361 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12363 memcpy (tc
->salt_buf
, buf
, 64);
12365 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12367 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12369 salt
->salt_len
= 4;
12371 salt
->salt_iter
= 1000 - 1;
12373 digest
[0] = tc
->data_buf
[0];
12375 return (PARSER_OK
);
12378 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12380 u32
*digest
= (u32
*) hash_buf
->digest
;
12382 salt_t
*salt
= hash_buf
->salt
;
12384 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12386 if (input_len
== 0)
12388 log_error ("TrueCrypt container not specified");
12393 FILE *fp
= fopen (input_buf
, "rb");
12397 log_error ("%s: %s", input_buf
, strerror (errno
));
12404 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12408 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12410 memcpy (tc
->salt_buf
, buf
, 64);
12412 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12414 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12416 salt
->salt_len
= 4;
12418 salt
->salt_iter
= 2000 - 1;
12420 digest
[0] = tc
->data_buf
[0];
12422 return (PARSER_OK
);
12425 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12427 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12429 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12431 u32
*digest
= (u32
*) hash_buf
->digest
;
12433 salt_t
*salt
= hash_buf
->salt
;
12435 char *salt_pos
= input_buf
+ 6;
12437 char *hash_pos
= strchr (salt_pos
, '$');
12439 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12441 uint salt_len
= hash_pos
- salt_pos
;
12443 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12445 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12447 salt
->salt_len
= salt_len
;
12449 salt
->salt_iter
= 1000;
12453 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12455 return (PARSER_OK
);
12458 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12460 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12462 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12464 u32
*digest
= (u32
*) hash_buf
->digest
;
12466 salt_t
*salt
= hash_buf
->salt
;
12468 char *iter_pos
= input_buf
+ 7;
12470 char *salt_pos
= strchr (iter_pos
, '$');
12472 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12476 char *hash_pos
= strchr (salt_pos
, '$');
12478 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12480 uint salt_len
= hash_pos
- salt_pos
;
12482 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12484 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12486 salt
->salt_len
= salt_len
;
12488 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12490 salt
->salt_sign
[0] = atoi (salt_iter
);
12492 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12496 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12498 digest
[0] = byte_swap_32 (digest
[0]);
12499 digest
[1] = byte_swap_32 (digest
[1]);
12500 digest
[2] = byte_swap_32 (digest
[2]);
12501 digest
[3] = byte_swap_32 (digest
[3]);
12502 digest
[4] = byte_swap_32 (digest
[4]);
12504 return (PARSER_OK
);
12507 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12509 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12511 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12513 u32
*digest
= (u32
*) hash_buf
->digest
;
12515 salt_t
*salt
= hash_buf
->salt
;
12517 char *iter_pos
= input_buf
+ 9;
12519 char *salt_pos
= strchr (iter_pos
, '$');
12521 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12525 char *hash_pos
= strchr (salt_pos
, '$');
12527 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12529 uint salt_len
= hash_pos
- salt_pos
;
12531 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12533 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12535 salt
->salt_len
= salt_len
;
12537 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12539 salt
->salt_sign
[0] = atoi (salt_iter
);
12541 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12545 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12547 digest
[0] = byte_swap_32 (digest
[0]);
12548 digest
[1] = byte_swap_32 (digest
[1]);
12549 digest
[2] = byte_swap_32 (digest
[2]);
12550 digest
[3] = byte_swap_32 (digest
[3]);
12551 digest
[4] = byte_swap_32 (digest
[4]);
12552 digest
[5] = byte_swap_32 (digest
[5]);
12553 digest
[6] = byte_swap_32 (digest
[6]);
12554 digest
[7] = byte_swap_32 (digest
[7]);
12556 return (PARSER_OK
);
12559 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12561 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12563 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12565 u64
*digest
= (u64
*) hash_buf
->digest
;
12567 salt_t
*salt
= hash_buf
->salt
;
12569 char *iter_pos
= input_buf
+ 9;
12571 char *salt_pos
= strchr (iter_pos
, '$');
12573 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12577 char *hash_pos
= strchr (salt_pos
, '$');
12579 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12581 uint salt_len
= hash_pos
- salt_pos
;
12583 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12585 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12587 salt
->salt_len
= salt_len
;
12589 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12591 salt
->salt_sign
[0] = atoi (salt_iter
);
12593 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12597 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12599 digest
[0] = byte_swap_64 (digest
[0]);
12600 digest
[1] = byte_swap_64 (digest
[1]);
12601 digest
[2] = byte_swap_64 (digest
[2]);
12602 digest
[3] = byte_swap_64 (digest
[3]);
12603 digest
[4] = byte_swap_64 (digest
[4]);
12604 digest
[5] = byte_swap_64 (digest
[5]);
12605 digest
[6] = byte_swap_64 (digest
[6]);
12606 digest
[7] = byte_swap_64 (digest
[7]);
12608 return (PARSER_OK
);
12611 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12613 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12615 u32
*digest
= (u32
*) hash_buf
->digest
;
12617 salt_t
*salt
= hash_buf
->salt
;
12619 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12625 char *iterations_pos
= input_buf
;
12627 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12629 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12631 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12633 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12637 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12639 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12641 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12643 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12645 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12647 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12652 * pbkdf2 iterations
12655 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12658 * handle salt encoding
12661 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12663 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12665 const char p0
= saltbuf_pos
[i
+ 0];
12666 const char p1
= saltbuf_pos
[i
+ 1];
12668 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12669 | hex_convert (p0
) << 4;
12672 salt
->salt_len
= saltbuf_len
/ 2;
12675 * handle cipher encoding
12678 uint
*tmp
= (uint
*) mymalloc (32);
12680 char *cipherbuf_ptr
= (char *) tmp
;
12682 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12684 const char p0
= cipherbuf_pos
[i
+ 0];
12685 const char p1
= cipherbuf_pos
[i
+ 1];
12687 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12688 | hex_convert (p0
) << 4;
12691 // iv is stored at salt_buf 4 (length 16)
12692 // data is stored at salt_buf 8 (length 16)
12694 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12695 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12696 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12697 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12699 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12700 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12701 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12702 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12706 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12708 const char p0
= cipherbuf_pos
[j
+ 0];
12709 const char p1
= cipherbuf_pos
[j
+ 1];
12711 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12712 | hex_convert (p0
) << 4;
12719 digest
[0] = 0x10101010;
12720 digest
[1] = 0x10101010;
12721 digest
[2] = 0x10101010;
12722 digest
[3] = 0x10101010;
12724 return (PARSER_OK
);
12727 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12729 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12731 u32
*digest
= (u32
*) hash_buf
->digest
;
12733 salt_t
*salt
= hash_buf
->salt
;
12735 char *hashbuf_pos
= input_buf
;
12737 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12739 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12741 uint hash_len
= iterations_pos
- hashbuf_pos
;
12743 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12747 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12749 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12751 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12755 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12757 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12759 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12761 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12763 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12765 salt
->salt_len
= salt_len
;
12767 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12769 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
12770 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
12771 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
12772 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
12774 return (PARSER_OK
);
12777 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12779 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12781 u32
*digest
= (u32
*) hash_buf
->digest
;
12783 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12784 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12785 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12786 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12787 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12788 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12789 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12790 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12792 digest
[0] = byte_swap_32 (digest
[0]);
12793 digest
[1] = byte_swap_32 (digest
[1]);
12794 digest
[2] = byte_swap_32 (digest
[2]);
12795 digest
[3] = byte_swap_32 (digest
[3]);
12796 digest
[4] = byte_swap_32 (digest
[4]);
12797 digest
[5] = byte_swap_32 (digest
[5]);
12798 digest
[6] = byte_swap_32 (digest
[6]);
12799 digest
[7] = byte_swap_32 (digest
[7]);
12801 return (PARSER_OK
);
12804 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12806 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12808 u32
*digest
= (u32
*) hash_buf
->digest
;
12810 salt_t
*salt
= hash_buf
->salt
;
12812 char *salt_pos
= input_buf
+ 3;
12814 uint iterations_len
= 0;
12816 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12820 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12822 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12823 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12827 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12831 iterations_len
+= 8;
12835 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12838 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12840 char *hash_pos
= strchr (salt_pos
, '$');
12842 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12844 uint salt_len
= hash_pos
- salt_pos
;
12846 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12848 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12850 salt
->salt_len
= salt_len
;
12854 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12856 return (PARSER_OK
);
12859 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12861 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12863 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12865 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12867 u64
*digest
= (u64
*) hash_buf
->digest
;
12869 salt_t
*salt
= hash_buf
->salt
;
12871 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12873 char *iter_pos
= input_buf
+ 4;
12875 char *salt_pos
= strchr (iter_pos
, '$');
12877 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12881 char *hash_pos
= strchr (salt_pos
, '$');
12883 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12885 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12889 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12890 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12891 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12892 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12893 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12894 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12895 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12896 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12898 uint salt_len
= hash_pos
- salt_pos
- 1;
12900 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12902 salt
->salt_len
= salt_len
/ 2;
12904 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12905 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12906 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12907 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12908 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
12909 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
12910 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
12911 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
12913 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12914 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12915 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12916 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12917 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12918 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12919 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12920 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12921 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12922 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12924 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12926 salt
->salt_iter
= atoi (iter_pos
) - 1;
12928 return (PARSER_OK
);
12931 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12933 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12935 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12937 u32
*digest
= (u32
*) hash_buf
->digest
;
12939 salt_t
*salt
= hash_buf
->salt
;
12941 char *salt_pos
= input_buf
+ 14;
12943 char *hash_pos
= strchr (salt_pos
, '*');
12945 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12949 uint salt_len
= hash_pos
- salt_pos
- 1;
12951 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12953 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
12955 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12957 salt
->salt_len
= salt_len
;
12961 memset (tmp_buf
, 0, sizeof (tmp_buf
));
12963 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
12965 memcpy (digest
, tmp_buf
, 32);
12967 digest
[0] = byte_swap_32 (digest
[0]);
12968 digest
[1] = byte_swap_32 (digest
[1]);
12969 digest
[2] = byte_swap_32 (digest
[2]);
12970 digest
[3] = byte_swap_32 (digest
[3]);
12971 digest
[4] = byte_swap_32 (digest
[4]);
12972 digest
[5] = byte_swap_32 (digest
[5]);
12973 digest
[6] = byte_swap_32 (digest
[6]);
12974 digest
[7] = byte_swap_32 (digest
[7]);
12976 digest
[0] -= SHA256M_A
;
12977 digest
[1] -= SHA256M_B
;
12978 digest
[2] -= SHA256M_C
;
12979 digest
[3] -= SHA256M_D
;
12980 digest
[4] -= SHA256M_E
;
12981 digest
[5] -= SHA256M_F
;
12982 digest
[6] -= SHA256M_G
;
12983 digest
[7] -= SHA256M_H
;
12985 return (PARSER_OK
);
12988 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12990 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
12992 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12994 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
12996 u64
*digest
= (u64
*) hash_buf
->digest
;
12998 salt_t
*salt
= hash_buf
->salt
;
13000 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13002 char *iter_pos
= input_buf
+ 19;
13004 char *salt_pos
= strchr (iter_pos
, '.');
13006 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13010 char *hash_pos
= strchr (salt_pos
, '.');
13012 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13014 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13018 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13019 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13020 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13021 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13022 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13023 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13024 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13025 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13027 uint salt_len
= hash_pos
- salt_pos
- 1;
13031 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13035 for (i
= 0; i
< salt_len
; i
++)
13037 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13040 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13041 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13043 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13045 salt
->salt_len
= salt_len
;
13047 salt
->salt_iter
= atoi (iter_pos
) - 1;
13049 return (PARSER_OK
);
13052 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13054 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13056 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13058 u64
*digest
= (u64
*) hash_buf
->digest
;
13060 salt_t
*salt
= hash_buf
->salt
;
13064 memset (tmp_buf
, 0, sizeof (tmp_buf
));
13066 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13068 memcpy (digest
, tmp_buf
, 64);
13070 digest
[0] = byte_swap_64 (digest
[0]);
13071 digest
[1] = byte_swap_64 (digest
[1]);
13072 digest
[2] = byte_swap_64 (digest
[2]);
13073 digest
[3] = byte_swap_64 (digest
[3]);
13074 digest
[4] = byte_swap_64 (digest
[4]);
13075 digest
[5] = byte_swap_64 (digest
[5]);
13076 digest
[6] = byte_swap_64 (digest
[6]);
13077 digest
[7] = byte_swap_64 (digest
[7]);
13079 digest
[0] -= SHA512M_A
;
13080 digest
[1] -= SHA512M_B
;
13081 digest
[2] -= SHA512M_C
;
13082 digest
[3] -= SHA512M_D
;
13083 digest
[4] -= SHA512M_E
;
13084 digest
[5] -= SHA512M_F
;
13085 digest
[6] -= SHA512M_G
;
13086 digest
[7] -= SHA512M_H
;
13088 salt
->salt_len
= tmp_len
- 64;
13090 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13092 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13094 char *ptr
= (char *) salt
->salt_buf
;
13096 ptr
[salt
->salt_len
] = 0x80;
13099 return (PARSER_OK
);
13102 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13104 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13106 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13110 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13113 u32
*digest
= (u32
*) hash_buf
->digest
;
13115 salt_t
*salt
= hash_buf
->salt
;
13117 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13118 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13119 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13120 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13122 digest
[0] = byte_swap_32 (digest
[0]);
13123 digest
[1] = byte_swap_32 (digest
[1]);
13124 digest
[2] = byte_swap_32 (digest
[2]);
13125 digest
[3] = byte_swap_32 (digest
[3]);
13127 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13129 uint salt_len
= input_len
- 32 - 1;
13131 char *salt_buf
= input_buf
+ 32 + 1;
13133 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13135 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13137 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13139 salt
->salt_len
= salt_len
;
13141 return (PARSER_OK
);
13144 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13146 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13148 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13152 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13155 u32
*digest
= (u32
*) hash_buf
->digest
;
13157 salt_t
*salt
= hash_buf
->salt
;
13159 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13160 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13161 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13162 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13163 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13165 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13167 uint salt_len
= input_len
- 40 - 1;
13169 char *salt_buf
= input_buf
+ 40 + 1;
13171 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13173 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13175 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13177 salt
->salt_len
= salt_len
;
13179 return (PARSER_OK
);
13182 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13184 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13186 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13190 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13193 u32
*digest
= (u32
*) hash_buf
->digest
;
13195 salt_t
*salt
= hash_buf
->salt
;
13197 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13198 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13199 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13200 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13201 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13202 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13203 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13204 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13206 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13208 uint salt_len
= input_len
- 64 - 1;
13210 char *salt_buf
= input_buf
+ 64 + 1;
13212 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13214 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13216 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13218 salt
->salt_len
= salt_len
;
13220 return (PARSER_OK
);
13223 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13225 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13227 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13231 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13234 u64
*digest
= (u64
*) hash_buf
->digest
;
13236 salt_t
*salt
= hash_buf
->salt
;
13238 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13239 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13240 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13241 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13242 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13243 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13244 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13245 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13247 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13249 uint salt_len
= input_len
- 128 - 1;
13251 char *salt_buf
= input_buf
+ 128 + 1;
13253 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13255 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13257 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13259 salt
->salt_len
= salt_len
;
13261 return (PARSER_OK
);
13264 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13266 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13268 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13270 u32
*digest
= (u32
*) hash_buf
->digest
;
13272 salt_t
*salt
= hash_buf
->salt
;
13274 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13280 char *user_pos
= input_buf
+ 10 + 1;
13282 char *realm_pos
= strchr (user_pos
, '$');
13284 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13286 uint user_len
= realm_pos
- user_pos
;
13288 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13292 char *salt_pos
= strchr (realm_pos
, '$');
13294 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13296 uint realm_len
= salt_pos
- realm_pos
;
13298 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13302 char *data_pos
= strchr (salt_pos
, '$');
13304 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13306 uint salt_len
= data_pos
- salt_pos
;
13308 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13312 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13314 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13320 memcpy (krb5pa
->user
, user_pos
, user_len
);
13321 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13322 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13324 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13326 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13328 const char p0
= data_pos
[i
+ 0];
13329 const char p1
= data_pos
[i
+ 1];
13331 *timestamp_ptr
++ = hex_convert (p1
) << 0
13332 | hex_convert (p0
) << 4;
13335 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13337 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13339 const char p0
= data_pos
[i
+ 0];
13340 const char p1
= data_pos
[i
+ 1];
13342 *checksum_ptr
++ = hex_convert (p1
) << 0
13343 | hex_convert (p0
) << 4;
13347 * copy some data to generic buffers to make sorting happy
13350 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13351 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13352 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13353 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13354 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13355 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13356 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13357 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13358 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13360 salt
->salt_len
= 36;
13362 digest
[0] = krb5pa
->checksum
[0];
13363 digest
[1] = krb5pa
->checksum
[1];
13364 digest
[2] = krb5pa
->checksum
[2];
13365 digest
[3] = krb5pa
->checksum
[3];
13367 return (PARSER_OK
);
13370 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13372 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13374 u32
*digest
= (u32
*) hash_buf
->digest
;
13376 salt_t
*salt
= hash_buf
->salt
;
13382 char *salt_pos
= input_buf
;
13384 char *hash_pos
= strchr (salt_pos
, '$');
13386 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13388 uint salt_len
= hash_pos
- salt_pos
;
13390 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13394 uint hash_len
= input_len
- 1 - salt_len
;
13396 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13404 for (uint i
= 0; i
< salt_len
; i
++)
13406 if (salt_pos
[i
] == ' ') continue;
13411 // SAP user names cannot be longer than 12 characters
13412 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13414 // SAP user name cannot start with ! or ?
13415 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13421 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13423 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13425 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13427 salt
->salt_len
= salt_len
;
13429 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13430 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13434 digest
[0] = byte_swap_32 (digest
[0]);
13435 digest
[1] = byte_swap_32 (digest
[1]);
13437 return (PARSER_OK
);
13440 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13442 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13444 u32
*digest
= (u32
*) hash_buf
->digest
;
13446 salt_t
*salt
= hash_buf
->salt
;
13452 char *salt_pos
= input_buf
;
13454 char *hash_pos
= strchr (salt_pos
, '$');
13456 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13458 uint salt_len
= hash_pos
- salt_pos
;
13460 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13464 uint hash_len
= input_len
- 1 - salt_len
;
13466 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13474 for (uint i
= 0; i
< salt_len
; i
++)
13476 if (salt_pos
[i
] == ' ') continue;
13481 // SAP user names cannot be longer than 12 characters
13482 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13483 // so far nobody complained so we stay with this because it helps in optimization
13484 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13486 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13488 // SAP user name cannot start with ! or ?
13489 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13495 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13497 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13499 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13501 salt
->salt_len
= salt_len
;
13503 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13504 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13505 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13506 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13507 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13509 return (PARSER_OK
);
13512 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13514 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13516 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13518 u64
*digest
= (u64
*) hash_buf
->digest
;
13520 salt_t
*salt
= hash_buf
->salt
;
13522 char *iter_pos
= input_buf
+ 3;
13524 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13526 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13528 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13530 salt
->salt_iter
= salt_iter
;
13532 char *salt_pos
= iter_pos
+ 1;
13536 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13538 salt
->salt_len
= salt_len
;
13540 char *hash_pos
= salt_pos
+ salt_len
;
13542 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13546 char *tmp
= (char *) salt
->salt_buf_pc
;
13548 tmp
[0] = hash_pos
[42];
13552 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13553 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13554 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13555 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13561 return (PARSER_OK
);
13564 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13566 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13568 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13570 u32
*digest
= (u32
*) hash_buf
->digest
;
13572 salt_t
*salt
= hash_buf
->salt
;
13574 char *salt_buf
= input_buf
+ 6;
13576 uint salt_len
= 16;
13578 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13580 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13582 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13584 salt
->salt_len
= salt_len
;
13586 char *hash_pos
= input_buf
+ 6 + 16;
13588 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13589 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13590 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13591 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13592 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13593 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13594 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13595 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13597 return (PARSER_OK
);
13600 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13602 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13604 u32
*digest
= (u32
*) hash_buf
->digest
;
13606 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13607 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13611 return (PARSER_OK
);
13614 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13616 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13618 u32
*digest
= (u32
*) hash_buf
->digest
;
13620 salt_t
*salt
= hash_buf
->salt
;
13622 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13624 char *saltbuf_pos
= input_buf
;
13626 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13628 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13630 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13632 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13633 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13635 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13639 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13641 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13643 char *salt_ptr
= (char *) saltbuf_pos
;
13644 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13649 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13651 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13654 rakp_ptr
[j
] = 0x80;
13656 rakp
->salt_len
= j
;
13658 for (i
= 0; i
< 64; i
++)
13660 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13663 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13664 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13665 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13666 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13667 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13668 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13669 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13670 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13672 salt
->salt_len
= 32; // muss min. 32 haben
13674 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13675 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13676 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13677 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13678 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13680 return (PARSER_OK
);
13683 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13685 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13687 u32
*digest
= (u32
*) hash_buf
->digest
;
13689 salt_t
*salt
= hash_buf
->salt
;
13691 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13693 char *salt_pos
= input_buf
+ 1;
13695 memcpy (salt
->salt_buf
, salt_pos
, 8);
13697 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13698 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13700 salt
->salt_len
= 8;
13702 char *hash_pos
= salt_pos
+ 8;
13704 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13705 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13706 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13707 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13708 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13710 digest
[0] -= SHA1M_A
;
13711 digest
[1] -= SHA1M_B
;
13712 digest
[2] -= SHA1M_C
;
13713 digest
[3] -= SHA1M_D
;
13714 digest
[4] -= SHA1M_E
;
13716 return (PARSER_OK
);
13719 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13721 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13723 u32
*digest
= (u32
*) hash_buf
->digest
;
13725 salt_t
*salt
= hash_buf
->salt
;
13727 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13728 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13729 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13730 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13732 digest
[0] = byte_swap_32 (digest
[0]);
13733 digest
[1] = byte_swap_32 (digest
[1]);
13734 digest
[2] = byte_swap_32 (digest
[2]);
13735 digest
[3] = byte_swap_32 (digest
[3]);
13737 digest
[0] -= MD5M_A
;
13738 digest
[1] -= MD5M_B
;
13739 digest
[2] -= MD5M_C
;
13740 digest
[3] -= MD5M_D
;
13742 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13744 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13746 u32
*salt_buf
= salt
->salt_buf
;
13748 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
13749 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
13750 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
13751 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
13753 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13754 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13755 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13756 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13758 salt
->salt_len
= 16 + 1;
13760 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13762 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13764 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
13766 return (PARSER_OK
);
13769 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13771 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13773 u32
*digest
= (u32
*) hash_buf
->digest
;
13775 salt_t
*salt
= hash_buf
->salt
;
13777 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13783 char *hashbuf_pos
= input_buf
;
13785 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13787 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13789 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13791 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13795 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13797 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13799 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13801 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13805 char *databuf_pos
= strchr (iteration_pos
, ':');
13807 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13809 const uint iteration_len
= databuf_pos
- iteration_pos
;
13811 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13812 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13814 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13816 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13817 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13823 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13824 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13825 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13826 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13827 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13828 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
13829 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
13830 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
13834 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13836 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13838 const char p0
= saltbuf_pos
[i
+ 0];
13839 const char p1
= saltbuf_pos
[i
+ 1];
13841 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13842 | hex_convert (p0
) << 4;
13845 salt
->salt_buf
[4] = 0x01000000;
13846 salt
->salt_buf
[5] = 0x80;
13848 salt
->salt_len
= saltbuf_len
/ 2;
13852 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13856 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13858 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13860 const char p0
= databuf_pos
[i
+ 0];
13861 const char p1
= databuf_pos
[i
+ 1];
13863 *databuf_ptr
++ = hex_convert (p1
) << 0
13864 | hex_convert (p0
) << 4;
13867 *databuf_ptr
++ = 0x80;
13869 for (uint i
= 0; i
< 512; i
++)
13871 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13874 cloudkey
->data_len
= databuf_len
/ 2;
13876 return (PARSER_OK
);
13879 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13881 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13883 u32
*digest
= (u32
*) hash_buf
->digest
;
13885 salt_t
*salt
= hash_buf
->salt
;
13891 char *hashbuf_pos
= input_buf
;
13893 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13895 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13897 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13899 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13903 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13905 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13907 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13909 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13911 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13915 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13917 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13919 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13921 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13923 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13927 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13929 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13930 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13932 // ok, the plan for this algorithm is the following:
13933 // we have 2 salts here, the domain-name and a random salt
13934 // while both are used in the initial transformation,
13935 // only the random salt is used in the following iterations
13936 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13937 // and one that includes only the real salt (stored into salt_buf[]).
13938 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13942 memset (tmp_buf
, 0, sizeof (tmp_buf
));
13944 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
13946 memcpy (digest
, tmp_buf
, 20);
13948 digest
[0] = byte_swap_32 (digest
[0]);
13949 digest
[1] = byte_swap_32 (digest
[1]);
13950 digest
[2] = byte_swap_32 (digest
[2]);
13951 digest
[3] = byte_swap_32 (digest
[3]);
13952 digest
[4] = byte_swap_32 (digest
[4]);
13956 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13958 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
13960 char *len_ptr
= NULL
;
13962 for (uint i
= 0; i
< domainbuf_len
; i
++)
13964 if (salt_buf_pc_ptr
[i
] == '.')
13966 len_ptr
= &salt_buf_pc_ptr
[i
];
13976 salt
->salt_buf_pc
[7] = domainbuf_len
;
13980 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13982 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
13984 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13986 salt
->salt_len
= salt_len
;
13990 salt
->salt_iter
= atoi (iteration_pos
);
13992 return (PARSER_OK
);
13995 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13997 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
13999 u32
*digest
= (u32
*) hash_buf
->digest
;
14001 salt_t
*salt
= hash_buf
->salt
;
14003 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14004 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14005 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14006 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14007 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14009 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14011 uint salt_len
= input_len
- 40 - 1;
14013 char *salt_buf
= input_buf
+ 40 + 1;
14015 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14017 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14019 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14021 salt
->salt_len
= salt_len
;
14023 return (PARSER_OK
);
14026 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14028 const u8 ascii_to_ebcdic
[] =
14030 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14031 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14032 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14033 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14034 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14035 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14036 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14037 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14038 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14039 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14040 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14041 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14042 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14043 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14044 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14045 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14048 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14050 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14052 u32
*digest
= (u32
*) hash_buf
->digest
;
14054 salt_t
*salt
= hash_buf
->salt
;
14056 char *salt_pos
= input_buf
+ 6 + 1;
14058 char *digest_pos
= strchr (salt_pos
, '*');
14060 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14062 uint salt_len
= digest_pos
- salt_pos
;
14064 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14066 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14068 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14072 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14073 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14075 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14077 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14079 salt
->salt_len
= salt_len
;
14081 for (uint i
= 0; i
< salt_len
; i
++)
14083 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14085 for (uint i
= salt_len
; i
< 8; i
++)
14087 salt_buf_pc_ptr
[i
] = 0x40;
14092 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14094 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14095 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14097 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14098 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14100 digest
[0] = byte_swap_32 (digest
[0]);
14101 digest
[1] = byte_swap_32 (digest
[1]);
14103 IP (digest
[0], digest
[1], tt
);
14105 digest
[0] = rotr32 (digest
[0], 29);
14106 digest
[1] = rotr32 (digest
[1], 29);
14110 return (PARSER_OK
);
14113 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14115 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14117 u32
*digest
= (u32
*) hash_buf
->digest
;
14119 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14120 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14121 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14122 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14124 digest
[0] = byte_swap_32 (digest
[0]);
14125 digest
[1] = byte_swap_32 (digest
[1]);
14126 digest
[2] = byte_swap_32 (digest
[2]);
14127 digest
[3] = byte_swap_32 (digest
[3]);
14129 return (PARSER_OK
);
14132 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14134 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14136 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14138 u32
*digest
= (u32
*) hash_buf
->digest
;
14140 salt_t
*salt
= hash_buf
->salt
;
14144 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14146 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14148 tmp_buf
[3] += -4; // dont ask!
14150 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14152 salt
->salt_len
= 5;
14154 memcpy (digest
, tmp_buf
+ 5, 9);
14156 // yes, only 9 byte are needed to crack, but 10 to display
14158 salt
->salt_buf_pc
[7] = input_buf
[20];
14160 return (PARSER_OK
);
14163 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14165 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14167 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14169 u32
*digest
= (u32
*) hash_buf
->digest
;
14171 salt_t
*salt
= hash_buf
->salt
;
14175 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14177 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14179 tmp_buf
[3] += -4; // dont ask!
14183 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14185 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)
14189 char tmp_iter_buf
[11];
14191 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14193 tmp_iter_buf
[10] = 0;
14195 salt
->salt_iter
= atoi (tmp_iter_buf
);
14197 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14199 return (PARSER_SALT_ITERATION
);
14202 salt
->salt_iter
--; // first round in init
14204 // 2 additional bytes for display only
14206 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14207 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14211 memcpy (digest
, tmp_buf
+ 28, 8);
14213 digest
[0] = byte_swap_32 (digest
[0]);
14214 digest
[1] = byte_swap_32 (digest
[1]);
14218 return (PARSER_OK
);
14221 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14223 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14225 u32
*digest
= (u32
*) hash_buf
->digest
;
14227 salt_t
*salt
= hash_buf
->salt
;
14229 char *salt_buf_pos
= input_buf
;
14231 char *hash_buf_pos
= salt_buf_pos
+ 6;
14233 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14234 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14235 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14236 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14237 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14238 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14239 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14240 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14242 digest
[0] -= SHA256M_A
;
14243 digest
[1] -= SHA256M_B
;
14244 digest
[2] -= SHA256M_C
;
14245 digest
[3] -= SHA256M_D
;
14246 digest
[4] -= SHA256M_E
;
14247 digest
[5] -= SHA256M_F
;
14248 digest
[6] -= SHA256M_G
;
14249 digest
[7] -= SHA256M_H
;
14251 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14253 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14255 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14257 salt
->salt_len
= salt_len
;
14259 return (PARSER_OK
);
14262 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14264 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14266 u32
*digest
= (u32
*) hash_buf
->digest
;
14268 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14270 salt_t
*salt
= hash_buf
->salt
;
14272 char *salt_buf
= input_buf
+ 6;
14274 char *digest_buf
= strchr (salt_buf
, '$');
14276 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14278 uint salt_len
= digest_buf
- salt_buf
;
14280 digest_buf
++; // skip the '$' symbol
14282 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14284 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14286 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14288 salt
->salt_len
= salt_len
;
14290 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14291 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14292 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14293 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14295 digest
[0] = byte_swap_32 (digest
[0]);
14296 digest
[1] = byte_swap_32 (digest
[1]);
14297 digest
[2] = byte_swap_32 (digest
[2]);
14298 digest
[3] = byte_swap_32 (digest
[3]);
14300 digest
[0] -= MD5M_A
;
14301 digest
[1] -= MD5M_B
;
14302 digest
[2] -= MD5M_C
;
14303 digest
[3] -= MD5M_D
;
14305 return (PARSER_OK
);
14308 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14310 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14312 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14314 u32
*digest
= (u32
*) hash_buf
->digest
;
14316 salt_t
*salt
= hash_buf
->salt
;
14318 char *salt_buf
= input_buf
+ 3;
14320 char *digest_buf
= strchr (salt_buf
, '$');
14322 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14324 uint salt_len
= digest_buf
- salt_buf
;
14326 digest_buf
++; // skip the '$' symbol
14328 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14330 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14332 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14334 salt_buf_ptr
[salt_len
] = 0x2d;
14336 salt
->salt_len
= salt_len
+ 1;
14338 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14339 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14340 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14341 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14343 digest
[0] = byte_swap_32 (digest
[0]);
14344 digest
[1] = byte_swap_32 (digest
[1]);
14345 digest
[2] = byte_swap_32 (digest
[2]);
14346 digest
[3] = byte_swap_32 (digest
[3]);
14348 digest
[0] -= MD5M_A
;
14349 digest
[1] -= MD5M_B
;
14350 digest
[2] -= MD5M_C
;
14351 digest
[3] -= MD5M_D
;
14353 return (PARSER_OK
);
14356 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14358 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14360 u32
*digest
= (u32
*) hash_buf
->digest
;
14364 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14366 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14368 memcpy (digest
, tmp_buf
, 20);
14370 digest
[0] = byte_swap_32 (digest
[0]);
14371 digest
[1] = byte_swap_32 (digest
[1]);
14372 digest
[2] = byte_swap_32 (digest
[2]);
14373 digest
[3] = byte_swap_32 (digest
[3]);
14374 digest
[4] = byte_swap_32 (digest
[4]);
14376 digest
[0] -= SHA1M_A
;
14377 digest
[1] -= SHA1M_B
;
14378 digest
[2] -= SHA1M_C
;
14379 digest
[3] -= SHA1M_D
;
14380 digest
[4] -= SHA1M_E
;
14382 return (PARSER_OK
);
14385 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14387 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14389 u32
*digest
= (u32
*) hash_buf
->digest
;
14391 salt_t
*salt
= hash_buf
->salt
;
14393 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14394 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14395 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14396 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14398 digest
[0] = byte_swap_32 (digest
[0]);
14399 digest
[1] = byte_swap_32 (digest
[1]);
14400 digest
[2] = byte_swap_32 (digest
[2]);
14401 digest
[3] = byte_swap_32 (digest
[3]);
14403 digest
[0] -= MD5M_A
;
14404 digest
[1] -= MD5M_B
;
14405 digest
[2] -= MD5M_C
;
14406 digest
[3] -= MD5M_D
;
14408 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14410 uint salt_len
= input_len
- 32 - 1;
14412 char *salt_buf
= input_buf
+ 32 + 1;
14414 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14416 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14418 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14421 * add static "salt" part
14424 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14428 salt
->salt_len
= salt_len
;
14430 return (PARSER_OK
);
14433 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14435 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14437 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14439 u32
*digest
= (u32
*) hash_buf
->digest
;
14441 salt_t
*salt
= hash_buf
->salt
;
14443 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14449 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14451 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14453 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14455 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14457 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14461 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14463 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14465 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14467 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14471 char *keybuf_pos
= strchr (keylen_pos
, '$');
14473 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14475 uint keylen_len
= keybuf_pos
- keylen_pos
;
14477 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14481 char *databuf_pos
= strchr (keybuf_pos
, '$');
14483 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14485 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14487 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14491 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14493 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14499 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14500 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14501 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14502 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14504 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14505 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14506 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14507 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14509 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14510 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14511 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14512 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14514 salt
->salt_len
= 16;
14515 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14517 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14519 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14522 return (PARSER_OK
);
14525 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14527 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14529 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14531 u32
*digest
= (u32
*) hash_buf
->digest
;
14533 salt_t
*salt
= hash_buf
->salt
;
14539 // first is the N salt parameter
14541 char *N_pos
= input_buf
+ 6;
14543 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14547 salt
->scrypt_N
= atoi (N_pos
);
14551 char *r_pos
= strchr (N_pos
, ':');
14553 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14557 salt
->scrypt_r
= atoi (r_pos
);
14561 char *p_pos
= strchr (r_pos
, ':');
14563 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14567 salt
->scrypt_p
= atoi (p_pos
);
14571 char *saltbuf_pos
= strchr (p_pos
, ':');
14573 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14577 char *hash_pos
= strchr (saltbuf_pos
, ':');
14579 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14587 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14589 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14591 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14593 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14595 salt
->salt_len
= tmp_len
;
14596 salt
->salt_iter
= 1;
14598 // digest - base64 decode
14600 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14602 tmp_len
= input_len
- (hash_pos
- input_buf
);
14604 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14606 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14608 memcpy (digest
, tmp_buf
, 32);
14610 return (PARSER_OK
);
14613 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14615 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14617 u32
*digest
= (u32
*) hash_buf
->digest
;
14619 salt_t
*salt
= hash_buf
->salt
;
14625 char decrypted
[76]; // iv + hash
14627 juniper_decrypt_hash (input_buf
, decrypted
);
14629 char *md5crypt_hash
= decrypted
+ 12;
14631 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14633 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14635 char *salt_pos
= md5crypt_hash
+ 3;
14637 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14639 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14641 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14645 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14647 return (PARSER_OK
);
14650 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14652 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14654 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14656 u32
*digest
= (u32
*) hash_buf
->digest
;
14658 salt_t
*salt
= hash_buf
->salt
;
14660 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14666 // first is *raw* salt
14668 char *salt_pos
= input_buf
+ 3;
14670 char *hash_pos
= strchr (salt_pos
, '$');
14672 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14674 uint salt_len
= hash_pos
- salt_pos
;
14676 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14680 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14682 memcpy (salt_buf_ptr
, salt_pos
, 14);
14684 salt_buf_ptr
[17] = 0x01;
14685 salt_buf_ptr
[18] = 0x80;
14687 // add some stuff to normal salt to make sorted happy
14689 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14690 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14691 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14692 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14694 salt
->salt_len
= salt_len
;
14695 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14697 // base64 decode hash
14701 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14703 uint hash_len
= input_len
- 3 - salt_len
- 1;
14705 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14707 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14709 memcpy (digest
, tmp_buf
, 32);
14711 digest
[0] = byte_swap_32 (digest
[0]);
14712 digest
[1] = byte_swap_32 (digest
[1]);
14713 digest
[2] = byte_swap_32 (digest
[2]);
14714 digest
[3] = byte_swap_32 (digest
[3]);
14715 digest
[4] = byte_swap_32 (digest
[4]);
14716 digest
[5] = byte_swap_32 (digest
[5]);
14717 digest
[6] = byte_swap_32 (digest
[6]);
14718 digest
[7] = byte_swap_32 (digest
[7]);
14720 return (PARSER_OK
);
14723 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14725 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14727 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14729 u32
*digest
= (u32
*) hash_buf
->digest
;
14731 salt_t
*salt
= hash_buf
->salt
;
14737 // first is *raw* salt
14739 char *salt_pos
= input_buf
+ 3;
14741 char *hash_pos
= strchr (salt_pos
, '$');
14743 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14745 uint salt_len
= hash_pos
- salt_pos
;
14747 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14749 salt
->salt_len
= salt_len
;
14752 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14754 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14755 salt_buf_ptr
[salt_len
] = 0;
14757 // base64 decode hash
14761 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14763 uint hash_len
= input_len
- 3 - salt_len
- 1;
14765 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14767 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14769 memcpy (digest
, tmp_buf
, 32);
14772 salt
->scrypt_N
= 16384;
14773 salt
->scrypt_r
= 1;
14774 salt
->scrypt_p
= 1;
14775 salt
->salt_iter
= 1;
14777 return (PARSER_OK
);
14780 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14782 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14784 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14786 u32
*digest
= (u32
*) hash_buf
->digest
;
14788 salt_t
*salt
= hash_buf
->salt
;
14790 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14796 char *version_pos
= input_buf
+ 8 + 1;
14798 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14800 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14802 u32 version_len
= verifierHashSize_pos
- version_pos
;
14804 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14806 verifierHashSize_pos
++;
14808 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14810 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14812 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14814 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14818 char *saltSize_pos
= strchr (keySize_pos
, '*');
14820 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14822 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14824 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14828 char *osalt_pos
= strchr (saltSize_pos
, '*');
14830 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14832 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14834 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14838 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14840 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14842 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14844 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14846 encryptedVerifier_pos
++;
14848 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14850 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14852 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14854 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14856 encryptedVerifierHash_pos
++;
14858 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;
14860 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14862 const uint version
= atoi (version_pos
);
14864 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14866 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14868 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14870 const uint keySize
= atoi (keySize_pos
);
14872 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14874 office2007
->keySize
= keySize
;
14876 const uint saltSize
= atoi (saltSize_pos
);
14878 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14884 salt
->salt_len
= 16;
14885 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14887 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
14888 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
14889 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
14890 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
14896 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
14897 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
14898 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
14899 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
14901 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
14902 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
14903 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
14904 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
14905 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
14911 digest
[0] = office2007
->encryptedVerifierHash
[0];
14912 digest
[1] = office2007
->encryptedVerifierHash
[1];
14913 digest
[2] = office2007
->encryptedVerifierHash
[2];
14914 digest
[3] = office2007
->encryptedVerifierHash
[3];
14916 return (PARSER_OK
);
14919 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14921 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14923 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14925 u32
*digest
= (u32
*) hash_buf
->digest
;
14927 salt_t
*salt
= hash_buf
->salt
;
14929 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14935 char *version_pos
= input_buf
+ 8 + 1;
14937 char *spinCount_pos
= strchr (version_pos
, '*');
14939 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14941 u32 version_len
= spinCount_pos
- version_pos
;
14943 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14947 char *keySize_pos
= strchr (spinCount_pos
, '*');
14949 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14951 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
14953 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14957 char *saltSize_pos
= strchr (keySize_pos
, '*');
14959 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14961 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14963 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14967 char *osalt_pos
= strchr (saltSize_pos
, '*');
14969 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14971 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14973 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14977 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14979 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14981 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14983 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14985 encryptedVerifier_pos
++;
14987 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14989 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14991 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14993 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14995 encryptedVerifierHash_pos
++;
14997 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;
14999 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15001 const uint version
= atoi (version_pos
);
15003 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15005 const uint spinCount
= atoi (spinCount_pos
);
15007 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15009 const uint keySize
= atoi (keySize_pos
);
15011 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15013 const uint saltSize
= atoi (saltSize_pos
);
15015 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15021 salt
->salt_len
= 16;
15022 salt
->salt_iter
= spinCount
;
15024 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15025 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15026 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15027 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15033 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15034 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15035 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15036 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15038 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15039 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15040 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15041 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15042 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15043 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15044 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15045 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15051 digest
[0] = office2010
->encryptedVerifierHash
[0];
15052 digest
[1] = office2010
->encryptedVerifierHash
[1];
15053 digest
[2] = office2010
->encryptedVerifierHash
[2];
15054 digest
[3] = office2010
->encryptedVerifierHash
[3];
15056 return (PARSER_OK
);
15059 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15061 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15063 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15065 u32
*digest
= (u32
*) hash_buf
->digest
;
15067 salt_t
*salt
= hash_buf
->salt
;
15069 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15075 char *version_pos
= input_buf
+ 8 + 1;
15077 char *spinCount_pos
= strchr (version_pos
, '*');
15079 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15081 u32 version_len
= spinCount_pos
- version_pos
;
15083 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15087 char *keySize_pos
= strchr (spinCount_pos
, '*');
15089 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15091 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15093 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15097 char *saltSize_pos
= strchr (keySize_pos
, '*');
15099 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15101 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15103 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15107 char *osalt_pos
= strchr (saltSize_pos
, '*');
15109 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15111 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15113 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15117 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15119 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15121 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15123 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15125 encryptedVerifier_pos
++;
15127 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15129 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15131 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15133 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15135 encryptedVerifierHash_pos
++;
15137 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;
15139 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15141 const uint version
= atoi (version_pos
);
15143 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15145 const uint spinCount
= atoi (spinCount_pos
);
15147 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15149 const uint keySize
= atoi (keySize_pos
);
15151 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15153 const uint saltSize
= atoi (saltSize_pos
);
15155 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15161 salt
->salt_len
= 16;
15162 salt
->salt_iter
= spinCount
;
15164 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15165 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15166 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15167 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15173 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15174 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15175 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15176 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15178 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15179 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15180 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15181 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15182 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15183 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15184 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15185 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15191 digest
[0] = office2013
->encryptedVerifierHash
[0];
15192 digest
[1] = office2013
->encryptedVerifierHash
[1];
15193 digest
[2] = office2013
->encryptedVerifierHash
[2];
15194 digest
[3] = office2013
->encryptedVerifierHash
[3];
15196 return (PARSER_OK
);
15199 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15201 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15203 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15205 u32
*digest
= (u32
*) hash_buf
->digest
;
15207 salt_t
*salt
= hash_buf
->salt
;
15209 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15215 char *version_pos
= input_buf
+ 11;
15217 char *osalt_pos
= strchr (version_pos
, '*');
15219 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15221 u32 version_len
= osalt_pos
- version_pos
;
15223 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15227 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15229 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15231 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15233 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15235 encryptedVerifier_pos
++;
15237 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15239 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15241 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15243 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15245 encryptedVerifierHash_pos
++;
15247 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15249 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15251 const uint version
= *version_pos
- 0x30;
15253 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15259 oldoffice01
->version
= version
;
15261 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15262 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15263 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15264 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15266 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15267 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15268 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15269 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15271 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15272 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15273 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15274 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15276 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15277 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15278 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15279 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15285 salt
->salt_len
= 16;
15287 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15288 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15289 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15290 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15292 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15293 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15294 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15295 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15297 // this is a workaround as office produces multiple documents with the same salt
15299 salt
->salt_len
+= 32;
15301 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15302 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15303 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15304 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15305 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15306 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15307 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15308 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15314 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15315 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15316 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15317 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15319 return (PARSER_OK
);
15322 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15324 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15327 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15329 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15331 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15333 u32
*digest
= (u32
*) hash_buf
->digest
;
15335 salt_t
*salt
= hash_buf
->salt
;
15337 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15343 char *version_pos
= input_buf
+ 11;
15345 char *osalt_pos
= strchr (version_pos
, '*');
15347 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15349 u32 version_len
= osalt_pos
- version_pos
;
15351 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15355 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15357 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15359 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15361 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15363 encryptedVerifier_pos
++;
15365 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15367 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15369 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15371 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15373 encryptedVerifierHash_pos
++;
15375 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15377 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15379 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15381 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15385 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15387 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15389 const uint version
= *version_pos
- 0x30;
15391 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15397 oldoffice01
->version
= version
;
15399 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15400 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15401 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15402 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15404 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15405 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15406 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15407 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15409 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15410 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15411 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15412 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15414 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15415 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15416 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15417 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15419 oldoffice01
->rc4key
[1] = 0;
15420 oldoffice01
->rc4key
[0] = 0;
15422 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15423 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15424 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15425 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15426 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15427 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15428 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15429 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15430 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15431 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15433 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15434 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15440 salt
->salt_len
= 16;
15442 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15443 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15444 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15445 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15447 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15448 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15449 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15450 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15452 // this is a workaround as office produces multiple documents with the same salt
15454 salt
->salt_len
+= 32;
15456 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15457 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15458 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15459 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15460 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15461 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15462 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15463 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15469 digest
[0] = oldoffice01
->rc4key
[0];
15470 digest
[1] = oldoffice01
->rc4key
[1];
15474 return (PARSER_OK
);
15477 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15479 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15481 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15483 u32
*digest
= (u32
*) hash_buf
->digest
;
15485 salt_t
*salt
= hash_buf
->salt
;
15487 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15493 char *version_pos
= input_buf
+ 11;
15495 char *osalt_pos
= strchr (version_pos
, '*');
15497 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15499 u32 version_len
= osalt_pos
- version_pos
;
15501 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15505 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15507 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15509 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15511 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15513 encryptedVerifier_pos
++;
15515 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15517 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15519 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15521 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15523 encryptedVerifierHash_pos
++;
15525 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15527 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15529 const uint version
= *version_pos
- 0x30;
15531 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15537 oldoffice34
->version
= version
;
15539 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15540 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15541 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15542 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15544 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15545 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15546 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15547 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15549 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15550 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15551 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15552 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15553 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15555 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15556 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15557 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15558 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15559 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15565 salt
->salt_len
= 16;
15567 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15568 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15569 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15570 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15572 // this is a workaround as office produces multiple documents with the same salt
15574 salt
->salt_len
+= 32;
15576 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15577 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15578 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15579 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15580 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15581 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15582 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15583 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15589 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15590 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15591 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15592 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15594 return (PARSER_OK
);
15597 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15599 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15601 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15604 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15606 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15608 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15610 u32
*digest
= (u32
*) hash_buf
->digest
;
15612 salt_t
*salt
= hash_buf
->salt
;
15614 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15620 char *version_pos
= input_buf
+ 11;
15622 char *osalt_pos
= strchr (version_pos
, '*');
15624 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15626 u32 version_len
= osalt_pos
- version_pos
;
15628 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15632 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15634 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15636 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15638 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15640 encryptedVerifier_pos
++;
15642 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15644 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15646 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15648 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15650 encryptedVerifierHash_pos
++;
15652 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15654 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15656 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15658 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15662 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15664 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15666 const uint version
= *version_pos
- 0x30;
15668 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15674 oldoffice34
->version
= version
;
15676 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15677 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15678 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15679 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15681 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15682 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15683 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15684 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15686 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15687 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15688 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15689 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15690 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15692 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15693 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15694 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15695 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15696 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15698 oldoffice34
->rc4key
[1] = 0;
15699 oldoffice34
->rc4key
[0] = 0;
15701 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15702 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15703 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15704 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15705 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15706 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15707 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15708 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15709 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15710 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15712 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15713 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15719 salt
->salt_len
= 16;
15721 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15722 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15723 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15724 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15726 // this is a workaround as office produces multiple documents with the same salt
15728 salt
->salt_len
+= 32;
15730 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15731 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15732 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15733 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15734 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15735 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15736 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15737 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15743 digest
[0] = oldoffice34
->rc4key
[0];
15744 digest
[1] = oldoffice34
->rc4key
[1];
15748 return (PARSER_OK
);
15751 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15753 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15755 u32
*digest
= (u32
*) hash_buf
->digest
;
15757 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15758 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15759 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15760 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15762 digest
[0] = byte_swap_32 (digest
[0]);
15763 digest
[1] = byte_swap_32 (digest
[1]);
15764 digest
[2] = byte_swap_32 (digest
[2]);
15765 digest
[3] = byte_swap_32 (digest
[3]);
15767 return (PARSER_OK
);
15770 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15772 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15774 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15776 u32
*digest
= (u32
*) hash_buf
->digest
;
15778 salt_t
*salt
= hash_buf
->salt
;
15780 char *signature_pos
= input_buf
;
15782 char *salt_pos
= strchr (signature_pos
, '$');
15784 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15786 u32 signature_len
= salt_pos
- signature_pos
;
15788 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15792 char *hash_pos
= strchr (salt_pos
, '$');
15794 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15796 u32 salt_len
= hash_pos
- salt_pos
;
15798 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15802 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15804 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15806 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
15807 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
15808 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
15809 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
15810 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
15812 digest
[0] -= SHA1M_A
;
15813 digest
[1] -= SHA1M_B
;
15814 digest
[2] -= SHA1M_C
;
15815 digest
[3] -= SHA1M_D
;
15816 digest
[4] -= SHA1M_E
;
15818 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15820 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15822 salt
->salt_len
= salt_len
;
15824 return (PARSER_OK
);
15827 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15829 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15831 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15833 u32
*digest
= (u32
*) hash_buf
->digest
;
15835 salt_t
*salt
= hash_buf
->salt
;
15837 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15843 char *iter_pos
= input_buf
+ 14;
15845 const int iter
= atoi (iter_pos
);
15847 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15849 salt
->salt_iter
= iter
- 1;
15851 char *salt_pos
= strchr (iter_pos
, '$');
15853 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15857 char *hash_pos
= strchr (salt_pos
, '$');
15859 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15861 const uint salt_len
= hash_pos
- salt_pos
;
15865 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15867 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15869 salt
->salt_len
= salt_len
;
15871 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15872 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15874 // add some stuff to normal salt to make sorted happy
15876 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15877 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15878 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15879 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15880 salt
->salt_buf
[4] = salt
->salt_iter
;
15882 // base64 decode hash
15886 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15888 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15890 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15892 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15894 memcpy (digest
, tmp_buf
, 32);
15896 digest
[0] = byte_swap_32 (digest
[0]);
15897 digest
[1] = byte_swap_32 (digest
[1]);
15898 digest
[2] = byte_swap_32 (digest
[2]);
15899 digest
[3] = byte_swap_32 (digest
[3]);
15900 digest
[4] = byte_swap_32 (digest
[4]);
15901 digest
[5] = byte_swap_32 (digest
[5]);
15902 digest
[6] = byte_swap_32 (digest
[6]);
15903 digest
[7] = byte_swap_32 (digest
[7]);
15905 return (PARSER_OK
);
15908 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15910 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15912 u32
*digest
= (u32
*) hash_buf
->digest
;
15914 salt_t
*salt
= hash_buf
->salt
;
15916 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15917 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15921 digest
[0] = byte_swap_32 (digest
[0]);
15922 digest
[1] = byte_swap_32 (digest
[1]);
15924 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15925 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15926 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15928 char iter_c
= input_buf
[17];
15929 char iter_d
= input_buf
[19];
15931 // atm only defaults, let's see if there's more request
15932 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15933 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15935 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15937 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
15938 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
15939 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
15940 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
15942 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15943 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15944 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15945 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15947 salt
->salt_len
= 16;
15949 return (PARSER_OK
);
15952 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15954 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
15956 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15958 u32
*digest
= (u32
*) hash_buf
->digest
;
15960 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
15962 salt_t
*salt
= hash_buf
->salt
;
15964 char *salt_pos
= input_buf
+ 10;
15966 char *hash_pos
= strchr (salt_pos
, '$');
15968 uint salt_len
= hash_pos
- salt_pos
;
15970 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15974 uint hash_len
= input_len
- 10 - salt_len
- 1;
15976 // base64 decode salt
15980 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15982 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
15984 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
15986 tmp_buf
[salt_len
] = 0x80;
15988 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
15990 salt
->salt_len
= salt_len
;
15992 // base64 decode salt
15994 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15996 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15998 uint user_len
= hash_len
- 32;
16000 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16002 user_len
--; // skip the trailing space
16004 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16005 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16006 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16007 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16009 digest
[0] = byte_swap_32 (digest
[0]);
16010 digest
[1] = byte_swap_32 (digest
[1]);
16011 digest
[2] = byte_swap_32 (digest
[2]);
16012 digest
[3] = byte_swap_32 (digest
[3]);
16014 // store username for host only (output hash if cracked)
16016 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16017 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16019 return (PARSER_OK
);
16022 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16024 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16026 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16028 u32
*digest
= (u32
*) hash_buf
->digest
;
16030 salt_t
*salt
= hash_buf
->salt
;
16032 char *iter_pos
= input_buf
+ 10;
16034 u32 iter
= atoi (iter_pos
);
16038 return (PARSER_SALT_ITERATION
);
16041 iter
--; // first iteration is special
16043 salt
->salt_iter
= iter
;
16045 char *base64_pos
= strchr (iter_pos
, '}');
16047 if (base64_pos
== NULL
)
16049 return (PARSER_SIGNATURE_UNMATCHED
);
16054 // base64 decode salt
16056 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16060 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16062 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16064 if (decoded_len
< 24)
16066 return (PARSER_SALT_LENGTH
);
16071 uint salt_len
= decoded_len
- 20;
16073 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16074 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16076 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16078 salt
->salt_len
= salt_len
;
16082 u32
*digest_ptr
= (u32
*) tmp_buf
;
16084 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16085 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16086 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16087 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16088 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16090 return (PARSER_OK
);
16093 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16095 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16097 u32
*digest
= (u32
*) hash_buf
->digest
;
16099 salt_t
*salt
= hash_buf
->salt
;
16101 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16102 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16103 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16104 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16105 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16107 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16109 uint salt_len
= input_len
- 40 - 1;
16111 char *salt_buf
= input_buf
+ 40 + 1;
16113 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16115 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16117 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16119 salt
->salt_len
= salt_len
;
16121 return (PARSER_OK
);
16124 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16126 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16128 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16130 u32
*digest
= (u32
*) hash_buf
->digest
;
16132 salt_t
*salt
= hash_buf
->salt
;
16134 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16140 char *V_pos
= input_buf
+ 5;
16142 char *R_pos
= strchr (V_pos
, '*');
16144 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16146 u32 V_len
= R_pos
- V_pos
;
16150 char *bits_pos
= strchr (R_pos
, '*');
16152 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16154 u32 R_len
= bits_pos
- R_pos
;
16158 char *P_pos
= strchr (bits_pos
, '*');
16160 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16162 u32 bits_len
= P_pos
- bits_pos
;
16166 char *enc_md_pos
= strchr (P_pos
, '*');
16168 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16170 u32 P_len
= enc_md_pos
- P_pos
;
16174 char *id_len_pos
= strchr (enc_md_pos
, '*');
16176 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16178 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16182 char *id_buf_pos
= strchr (id_len_pos
, '*');
16184 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16186 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16190 char *u_len_pos
= strchr (id_buf_pos
, '*');
16192 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16194 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16196 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16200 char *u_buf_pos
= strchr (u_len_pos
, '*');
16202 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16204 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16208 char *o_len_pos
= strchr (u_buf_pos
, '*');
16210 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16212 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16214 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16218 char *o_buf_pos
= strchr (o_len_pos
, '*');
16220 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16222 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16226 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;
16228 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16232 const int V
= atoi (V_pos
);
16233 const int R
= atoi (R_pos
);
16234 const int P
= atoi (P_pos
);
16236 if (V
!= 1) return (PARSER_SALT_VALUE
);
16237 if (R
!= 2) return (PARSER_SALT_VALUE
);
16239 const int enc_md
= atoi (enc_md_pos
);
16241 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16243 const int id_len
= atoi (id_len_pos
);
16244 const int u_len
= atoi (u_len_pos
);
16245 const int o_len
= atoi (o_len_pos
);
16247 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16248 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16249 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16251 const int bits
= atoi (bits_pos
);
16253 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16255 // copy data to esalt
16261 pdf
->enc_md
= enc_md
;
16263 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16264 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16265 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16266 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16267 pdf
->id_len
= id_len
;
16269 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16270 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16271 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16272 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16273 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16274 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16275 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16276 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16277 pdf
->u_len
= u_len
;
16279 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16280 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16281 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16282 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16283 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16284 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16285 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16286 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16287 pdf
->o_len
= o_len
;
16289 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16290 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16291 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16292 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16294 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16295 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16296 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16297 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16298 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16299 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16300 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16301 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16303 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16304 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16305 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16306 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16307 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16308 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16309 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16310 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16312 // we use ID for salt, maybe needs to change, we will see...
16314 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16315 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16316 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16317 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16318 salt
->salt_len
= pdf
->id_len
;
16320 digest
[0] = pdf
->u_buf
[0];
16321 digest
[1] = pdf
->u_buf
[1];
16322 digest
[2] = pdf
->u_buf
[2];
16323 digest
[3] = pdf
->u_buf
[3];
16325 return (PARSER_OK
);
16328 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16330 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16333 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16335 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16337 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16339 u32
*digest
= (u32
*) hash_buf
->digest
;
16341 salt_t
*salt
= hash_buf
->salt
;
16343 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16349 char *V_pos
= input_buf
+ 5;
16351 char *R_pos
= strchr (V_pos
, '*');
16353 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16355 u32 V_len
= R_pos
- V_pos
;
16359 char *bits_pos
= strchr (R_pos
, '*');
16361 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16363 u32 R_len
= bits_pos
- R_pos
;
16367 char *P_pos
= strchr (bits_pos
, '*');
16369 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16371 u32 bits_len
= P_pos
- bits_pos
;
16375 char *enc_md_pos
= strchr (P_pos
, '*');
16377 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16379 u32 P_len
= enc_md_pos
- P_pos
;
16383 char *id_len_pos
= strchr (enc_md_pos
, '*');
16385 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16387 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16391 char *id_buf_pos
= strchr (id_len_pos
, '*');
16393 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16395 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16399 char *u_len_pos
= strchr (id_buf_pos
, '*');
16401 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16403 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16405 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16409 char *u_buf_pos
= strchr (u_len_pos
, '*');
16411 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16413 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16417 char *o_len_pos
= strchr (u_buf_pos
, '*');
16419 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16421 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16423 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16427 char *o_buf_pos
= strchr (o_len_pos
, '*');
16429 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16431 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16435 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16437 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16439 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16441 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16445 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;
16447 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16451 const int V
= atoi (V_pos
);
16452 const int R
= atoi (R_pos
);
16453 const int P
= atoi (P_pos
);
16455 if (V
!= 1) return (PARSER_SALT_VALUE
);
16456 if (R
!= 2) return (PARSER_SALT_VALUE
);
16458 const int enc_md
= atoi (enc_md_pos
);
16460 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16462 const int id_len
= atoi (id_len_pos
);
16463 const int u_len
= atoi (u_len_pos
);
16464 const int o_len
= atoi (o_len_pos
);
16466 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16467 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16468 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16470 const int bits
= atoi (bits_pos
);
16472 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16474 // copy data to esalt
16480 pdf
->enc_md
= enc_md
;
16482 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16483 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16484 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16485 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16486 pdf
->id_len
= id_len
;
16488 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16489 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16490 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16491 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16492 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16493 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16494 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16495 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16496 pdf
->u_len
= u_len
;
16498 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16499 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16500 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16501 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16502 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16503 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16504 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16505 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16506 pdf
->o_len
= o_len
;
16508 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16509 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16510 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16511 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16513 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16514 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16515 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16516 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16517 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16518 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16519 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16520 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16522 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16523 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16524 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16525 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16526 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16527 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16528 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16529 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16531 pdf
->rc4key
[1] = 0;
16532 pdf
->rc4key
[0] = 0;
16534 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16535 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16536 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16537 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16538 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16539 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16540 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16541 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16542 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16543 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16545 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16546 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16548 // we use ID for salt, maybe needs to change, we will see...
16550 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16551 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16552 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16553 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16554 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16555 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16556 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16557 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16558 salt
->salt_len
= pdf
->id_len
+ 16;
16560 digest
[0] = pdf
->rc4key
[0];
16561 digest
[1] = pdf
->rc4key
[1];
16565 return (PARSER_OK
);
16568 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16570 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16572 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16574 u32
*digest
= (u32
*) hash_buf
->digest
;
16576 salt_t
*salt
= hash_buf
->salt
;
16578 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16584 char *V_pos
= input_buf
+ 5;
16586 char *R_pos
= strchr (V_pos
, '*');
16588 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16590 u32 V_len
= R_pos
- V_pos
;
16594 char *bits_pos
= strchr (R_pos
, '*');
16596 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16598 u32 R_len
= bits_pos
- R_pos
;
16602 char *P_pos
= strchr (bits_pos
, '*');
16604 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16606 u32 bits_len
= P_pos
- bits_pos
;
16610 char *enc_md_pos
= strchr (P_pos
, '*');
16612 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16614 u32 P_len
= enc_md_pos
- P_pos
;
16618 char *id_len_pos
= strchr (enc_md_pos
, '*');
16620 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16622 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16626 char *id_buf_pos
= strchr (id_len_pos
, '*');
16628 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16630 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16634 char *u_len_pos
= strchr (id_buf_pos
, '*');
16636 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16638 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16640 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16644 char *u_buf_pos
= strchr (u_len_pos
, '*');
16646 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16648 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16652 char *o_len_pos
= strchr (u_buf_pos
, '*');
16654 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16656 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16658 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16662 char *o_buf_pos
= strchr (o_len_pos
, '*');
16664 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16666 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16670 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;
16672 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16676 const int V
= atoi (V_pos
);
16677 const int R
= atoi (R_pos
);
16678 const int P
= atoi (P_pos
);
16682 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16683 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16685 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16687 const int id_len
= atoi (id_len_pos
);
16688 const int u_len
= atoi (u_len_pos
);
16689 const int o_len
= atoi (o_len_pos
);
16691 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16693 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16694 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16696 const int bits
= atoi (bits_pos
);
16698 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16704 enc_md
= atoi (enc_md_pos
);
16707 // copy data to esalt
16713 pdf
->enc_md
= enc_md
;
16715 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16716 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16717 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16718 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16722 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
16723 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
16724 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
16725 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
16728 pdf
->id_len
= id_len
;
16730 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16731 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16732 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16733 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16734 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16735 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16736 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16737 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16738 pdf
->u_len
= u_len
;
16740 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16741 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16742 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16743 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16744 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16745 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16746 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16747 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16748 pdf
->o_len
= o_len
;
16750 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16751 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16752 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16753 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16757 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16758 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16759 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16760 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16763 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16764 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16765 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16766 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16767 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16768 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16769 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16770 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16772 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16773 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16774 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16775 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16776 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16777 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16778 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16779 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16781 // precompute rc4 data for later use
16797 uint salt_pc_block
[32];
16799 char *salt_pc_ptr
= (char *) salt_pc_block
;
16801 memcpy (salt_pc_ptr
, padding
, 32);
16802 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16804 uint salt_pc_digest
[4];
16806 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16808 pdf
->rc4data
[0] = salt_pc_digest
[0];
16809 pdf
->rc4data
[1] = salt_pc_digest
[1];
16811 // we use ID for salt, maybe needs to change, we will see...
16813 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16814 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16815 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16816 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16817 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16818 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16819 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16820 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16821 salt
->salt_len
= pdf
->id_len
+ 16;
16823 salt
->salt_iter
= ROUNDS_PDF14
;
16825 digest
[0] = pdf
->u_buf
[0];
16826 digest
[1] = pdf
->u_buf
[1];
16830 return (PARSER_OK
);
16833 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16835 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16837 if (ret
!= PARSER_OK
)
16842 u32
*digest
= (u32
*) hash_buf
->digest
;
16844 salt_t
*salt
= hash_buf
->salt
;
16846 digest
[0] -= SHA256M_A
;
16847 digest
[1] -= SHA256M_B
;
16848 digest
[2] -= SHA256M_C
;
16849 digest
[3] -= SHA256M_D
;
16850 digest
[4] -= SHA256M_E
;
16851 digest
[5] -= SHA256M_F
;
16852 digest
[6] -= SHA256M_G
;
16853 digest
[7] -= SHA256M_H
;
16855 salt
->salt_buf
[2] = 0x80;
16857 return (PARSER_OK
);
16860 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16862 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16864 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16866 u32
*digest
= (u32
*) hash_buf
->digest
;
16868 salt_t
*salt
= hash_buf
->salt
;
16870 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16876 char *V_pos
= input_buf
+ 5;
16878 char *R_pos
= strchr (V_pos
, '*');
16880 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16882 u32 V_len
= R_pos
- V_pos
;
16886 char *bits_pos
= strchr (R_pos
, '*');
16888 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16890 u32 R_len
= bits_pos
- R_pos
;
16894 char *P_pos
= strchr (bits_pos
, '*');
16896 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16898 u32 bits_len
= P_pos
- bits_pos
;
16902 char *enc_md_pos
= strchr (P_pos
, '*');
16904 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16906 u32 P_len
= enc_md_pos
- P_pos
;
16910 char *id_len_pos
= strchr (enc_md_pos
, '*');
16912 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16914 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16918 char *id_buf_pos
= strchr (id_len_pos
, '*');
16920 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16922 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16926 char *u_len_pos
= strchr (id_buf_pos
, '*');
16928 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16930 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16934 char *u_buf_pos
= strchr (u_len_pos
, '*');
16936 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16938 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16942 char *o_len_pos
= strchr (u_buf_pos
, '*');
16944 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16946 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16950 char *o_buf_pos
= strchr (o_len_pos
, '*');
16952 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16954 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16958 char *last
= strchr (o_buf_pos
, '*');
16960 if (last
== NULL
) last
= input_buf
+ input_len
;
16962 u32 o_buf_len
= last
- o_buf_pos
;
16966 const int V
= atoi (V_pos
);
16967 const int R
= atoi (R_pos
);
16971 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
16972 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
16974 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16976 const int bits
= atoi (bits_pos
);
16978 if (bits
!= 256) return (PARSER_SALT_VALUE
);
16980 int enc_md
= atoi (enc_md_pos
);
16982 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
16984 const uint id_len
= atoi (id_len_pos
);
16985 const uint u_len
= atoi (u_len_pos
);
16986 const uint o_len
= atoi (o_len_pos
);
16988 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
16989 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
16990 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
16991 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
16992 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
16993 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
16994 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
16995 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
16997 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
16998 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
16999 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17001 // copy data to esalt
17003 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17005 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17007 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17010 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17011 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17013 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17014 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17016 salt
->salt_len
= 8;
17017 salt
->salt_iter
= ROUNDS_PDF17L8
;
17019 digest
[0] = pdf
->u_buf
[0];
17020 digest
[1] = pdf
->u_buf
[1];
17021 digest
[2] = pdf
->u_buf
[2];
17022 digest
[3] = pdf
->u_buf
[3];
17023 digest
[4] = pdf
->u_buf
[4];
17024 digest
[5] = pdf
->u_buf
[5];
17025 digest
[6] = pdf
->u_buf
[6];
17026 digest
[7] = pdf
->u_buf
[7];
17028 return (PARSER_OK
);
17031 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17033 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17035 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17037 u32
*digest
= (u32
*) hash_buf
->digest
;
17039 salt_t
*salt
= hash_buf
->salt
;
17041 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17049 char *iter_pos
= input_buf
+ 7;
17051 u32 iter
= atoi (iter_pos
);
17053 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17054 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17056 // first is *raw* salt
17058 char *salt_pos
= strchr (iter_pos
, ':');
17060 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17064 char *hash_pos
= strchr (salt_pos
, ':');
17066 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17068 u32 salt_len
= hash_pos
- salt_pos
;
17070 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17074 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17076 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17080 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17082 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17084 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17086 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17087 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17089 salt
->salt_len
= salt_len
;
17090 salt
->salt_iter
= iter
- 1;
17096 memset (tmp_buf
, 0, sizeof (tmp_buf
));
17098 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17100 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17102 memcpy (digest
, tmp_buf
, 16);
17104 digest
[0] = byte_swap_32 (digest
[0]);
17105 digest
[1] = byte_swap_32 (digest
[1]);
17106 digest
[2] = byte_swap_32 (digest
[2]);
17107 digest
[3] = byte_swap_32 (digest
[3]);
17109 // add some stuff to normal salt to make sorted happy
17111 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17112 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17113 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17114 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17115 salt
->salt_buf
[4] = salt
->salt_iter
;
17117 return (PARSER_OK
);
17120 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17122 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17124 u32
*digest
= (u32
*) hash_buf
->digest
;
17126 salt_t
*salt
= hash_buf
->salt
;
17128 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17129 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17130 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17131 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17133 digest
[0] = byte_swap_32 (digest
[0]);
17134 digest
[1] = byte_swap_32 (digest
[1]);
17135 digest
[2] = byte_swap_32 (digest
[2]);
17136 digest
[3] = byte_swap_32 (digest
[3]);
17138 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17140 uint salt_len
= input_len
- 32 - 1;
17142 char *salt_buf
= input_buf
+ 32 + 1;
17144 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17146 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17148 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17150 salt
->salt_len
= salt_len
;
17152 return (PARSER_OK
);
17155 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17157 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17159 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17161 u32
*digest
= (u32
*) hash_buf
->digest
;
17163 salt_t
*salt
= hash_buf
->salt
;
17165 char *user_pos
= input_buf
+ 10;
17167 char *salt_pos
= strchr (user_pos
, '*');
17169 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17173 char *hash_pos
= strchr (salt_pos
, '*');
17177 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17179 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17181 uint user_len
= salt_pos
- user_pos
- 1;
17183 uint salt_len
= hash_pos
- salt_pos
- 1;
17185 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17191 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17192 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17193 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17194 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17196 digest
[0] = byte_swap_32 (digest
[0]);
17197 digest
[1] = byte_swap_32 (digest
[1]);
17198 digest
[2] = byte_swap_32 (digest
[2]);
17199 digest
[3] = byte_swap_32 (digest
[3]);
17201 digest
[0] -= MD5M_A
;
17202 digest
[1] -= MD5M_B
;
17203 digest
[2] -= MD5M_C
;
17204 digest
[3] -= MD5M_D
;
17210 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17212 // first 4 bytes are the "challenge"
17214 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17215 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17216 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17217 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17219 // append the user name
17221 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17223 salt
->salt_len
= 4 + user_len
;
17225 return (PARSER_OK
);
17228 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17230 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17232 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17234 u32
*digest
= (u32
*) hash_buf
->digest
;
17236 salt_t
*salt
= hash_buf
->salt
;
17238 char *salt_pos
= input_buf
+ 9;
17240 char *hash_pos
= strchr (salt_pos
, '*');
17242 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17246 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17248 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17250 uint salt_len
= hash_pos
- salt_pos
- 1;
17252 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17258 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17259 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17260 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17261 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17262 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17268 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17270 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17272 salt
->salt_len
= salt_len
;
17274 return (PARSER_OK
);
17277 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17279 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17281 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17283 u32
*digest
= (u32
*) hash_buf
->digest
;
17285 salt_t
*salt
= hash_buf
->salt
;
17287 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17293 char *cry_master_len_pos
= input_buf
+ 9;
17295 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17297 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17299 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17301 cry_master_buf_pos
++;
17303 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17305 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17307 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17309 cry_salt_len_pos
++;
17311 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17313 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17315 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17317 cry_salt_buf_pos
++;
17319 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17321 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17323 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17327 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17329 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17331 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17335 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17337 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17339 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17343 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17345 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17347 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17349 public_key_len_pos
++;
17351 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17353 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17355 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17357 public_key_buf_pos
++;
17359 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;
17361 const uint cry_master_len
= atoi (cry_master_len_pos
);
17362 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17363 const uint ckey_len
= atoi (ckey_len_pos
);
17364 const uint public_key_len
= atoi (public_key_len_pos
);
17366 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17367 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17368 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17369 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17371 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 8)
17373 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17375 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17378 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 8)
17380 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17382 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17385 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 8)
17387 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17389 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17392 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17393 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17394 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17397 * store digest (should be unique enought, hopefully)
17400 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17401 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17402 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17403 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17409 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17411 const uint cry_rounds
= atoi (cry_rounds_pos
);
17413 salt
->salt_iter
= cry_rounds
- 1;
17415 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17417 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17419 salt
->salt_len
= salt_len
;
17421 return (PARSER_OK
);
17424 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17426 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17428 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17430 u32
*digest
= (u32
*) hash_buf
->digest
;
17432 salt_t
*salt
= hash_buf
->salt
;
17434 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17436 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17438 char temp_input_buf
[input_len
+ 1];
17440 memset (temp_input_buf
, 0, sizeof (temp_input_buf
));
17441 memcpy (temp_input_buf
, input_buf
, input_len
);
17445 char *URI_server_pos
= temp_input_buf
+ 6;
17447 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17449 if (URI_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17451 URI_client_pos
[0] = 0;
17454 uint URI_server_len
= strlen (URI_server_pos
);
17456 if (URI_server_len
> 512) return (PARSER_SALT_LENGTH
);
17460 char *user_pos
= strchr (URI_client_pos
, '*');
17462 if (user_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17467 uint URI_client_len
= strlen (URI_client_pos
);
17469 if (URI_client_len
> 512) return (PARSER_SALT_LENGTH
);
17473 char *realm_pos
= strchr (user_pos
, '*');
17475 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17480 uint user_len
= strlen (user_pos
);
17482 if (user_len
> 116) return (PARSER_SALT_LENGTH
);
17486 char *method_pos
= strchr (realm_pos
, '*');
17488 if (method_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17493 uint realm_len
= strlen (realm_pos
);
17495 if (realm_len
> 116) return (PARSER_SALT_LENGTH
);
17499 char *URI_prefix_pos
= strchr (method_pos
, '*');
17501 if (URI_prefix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17503 URI_prefix_pos
[0] = 0;
17506 uint method_len
= strlen (method_pos
);
17508 if (method_len
> 246) return (PARSER_SALT_LENGTH
);
17512 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17514 if (URI_resource_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17516 URI_resource_pos
[0] = 0;
17517 URI_resource_pos
++;
17519 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17521 if (URI_prefix_len
> 245) return (PARSER_SALT_LENGTH
);
17525 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17527 if (URI_suffix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17529 URI_suffix_pos
[0] = 0;
17532 uint URI_resource_len
= strlen (URI_resource_pos
);
17534 if (URI_resource_len
< 1) return (PARSER_SALT_LENGTH
);
17535 if (URI_resource_len
> 246) return (PARSER_SALT_LENGTH
);
17539 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17541 if (nonce_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17546 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17548 if (URI_suffix_len
> 245) return (PARSER_SALT_LENGTH
);
17552 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17554 if (nonce_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17556 nonce_client_pos
[0] = 0;
17557 nonce_client_pos
++;
17559 uint nonce_len
= strlen (nonce_pos
);
17561 if (nonce_len
< 1) return (PARSER_SALT_LENGTH
);
17562 if (nonce_len
> 50) return (PARSER_SALT_LENGTH
);
17566 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17568 if (nonce_count_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17570 nonce_count_pos
[0] = 0;
17573 uint nonce_client_len
= strlen (nonce_client_pos
);
17575 if (nonce_client_len
> 50) return (PARSER_SALT_LENGTH
);
17579 char *qop_pos
= strchr (nonce_count_pos
, '*');
17581 if (qop_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17586 uint nonce_count_len
= strlen (nonce_count_pos
);
17588 if (nonce_count_len
> 50) return (PARSER_SALT_LENGTH
);
17592 char *directive_pos
= strchr (qop_pos
, '*');
17594 if (directive_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17596 directive_pos
[0] = 0;
17599 uint qop_len
= strlen (qop_pos
);
17601 if (qop_len
> 50) return (PARSER_SALT_LENGTH
);
17605 char *digest_pos
= strchr (directive_pos
, '*');
17607 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17612 uint directive_len
= strlen (directive_pos
);
17614 if (directive_len
!= 3) return (PARSER_SALT_LENGTH
);
17616 if (memcmp (directive_pos
, "MD5", 3))
17618 log_info ("ERROR: only the MD5 directive is currently supported\n");
17620 return (PARSER_SIP_AUTH_DIRECTIVE
);
17624 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17629 uint md5_max_len
= 4 * 64;
17631 uint md5_remaining_len
= md5_max_len
;
17633 uint tmp_md5_buf
[md5_max_len
/ 4];
17635 memset (tmp_md5_buf
, 0, sizeof (tmp_md5_buf
));
17637 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17639 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17641 md5_len
+= method_len
+ 1;
17642 tmp_md5_ptr
+= method_len
+ 1;
17644 if (URI_prefix_len
> 0)
17646 md5_remaining_len
= md5_max_len
- md5_len
;
17648 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17650 md5_len
+= URI_prefix_len
+ 1;
17651 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17654 md5_remaining_len
= md5_max_len
- md5_len
;
17656 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17658 md5_len
+= URI_resource_len
;
17659 tmp_md5_ptr
+= URI_resource_len
;
17661 if (URI_suffix_len
> 0)
17663 md5_remaining_len
= md5_max_len
- md5_len
;
17665 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17667 md5_len
+= 1 + URI_suffix_len
;
17670 uint tmp_digest
[4];
17672 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17674 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17675 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17676 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17677 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17683 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17685 uint esalt_len
= 0;
17687 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17689 // there are 2 possibilities for the esalt:
17691 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17693 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17695 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17697 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17709 esalt_len
= 1 + nonce_len
+ 1 + 32;
17711 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17713 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17721 // add 0x80 to esalt
17723 esalt_buf_ptr
[esalt_len
] = 0x80;
17725 sip
->esalt_len
= esalt_len
;
17731 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17733 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17735 uint max_salt_len
= 119;
17737 if (salt_len
> max_salt_len
) return (PARSER_SALT_LENGTH
);
17739 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17741 sip
->salt_len
= salt_len
;
17744 * fake salt (for sorting)
17747 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17751 uint fake_salt_len
= salt_len
;
17753 if (fake_salt_len
> max_salt_len
)
17755 fake_salt_len
= max_salt_len
;
17758 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17760 salt
->salt_len
= fake_salt_len
;
17766 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
17767 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
17768 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
17769 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
17771 digest
[0] = byte_swap_32 (digest
[0]);
17772 digest
[1] = byte_swap_32 (digest
[1]);
17773 digest
[2] = byte_swap_32 (digest
[2]);
17774 digest
[3] = byte_swap_32 (digest
[3]);
17776 return (PARSER_OK
);
17779 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17781 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17783 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17785 u32
*digest
= (u32
*) hash_buf
->digest
;
17787 salt_t
*salt
= hash_buf
->salt
;
17791 char *digest_pos
= input_buf
;
17793 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
17800 char *salt_buf
= input_buf
+ 8 + 1;
17804 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17806 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17808 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17810 salt
->salt_len
= salt_len
;
17812 return (PARSER_OK
);
17815 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17817 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
17819 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17821 u32
*digest
= (u32
*) hash_buf
->digest
;
17823 salt_t
*salt
= hash_buf
->salt
;
17825 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
17831 char *p_buf_pos
= input_buf
+ 4;
17833 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
17835 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17837 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
17839 NumCyclesPower_pos
++;
17841 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
17843 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17845 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
17849 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
17851 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17853 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
17857 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
17859 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17861 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
17865 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
17867 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17869 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
17873 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
17875 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17877 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
17881 char *data_len_pos
= strchr (crc_buf_pos
, '$');
17883 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17885 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
17889 char *unpack_size_pos
= strchr (data_len_pos
, '$');
17891 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17893 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
17897 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
17899 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17901 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
17905 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;
17907 const uint iter
= atoi (NumCyclesPower_pos
);
17908 const uint crc
= atoi (crc_buf_pos
);
17909 const uint p_buf
= atoi (p_buf_pos
);
17910 const uint salt_len
= atoi (salt_len_pos
);
17911 const uint iv_len
= atoi (iv_len_pos
);
17912 const uint unpack_size
= atoi (unpack_size_pos
);
17913 const uint data_len
= atoi (data_len_pos
);
17919 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
17920 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
17922 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
17924 if (data_len
> 384) return (PARSER_SALT_VALUE
);
17926 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
17932 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
17933 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
17934 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
17935 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
17937 seven_zip
->iv_len
= iv_len
;
17939 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
17941 seven_zip
->salt_len
= 0;
17943 seven_zip
->crc
= crc
;
17945 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
17947 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
17949 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
17952 seven_zip
->data_len
= data_len
;
17954 seven_zip
->unpack_size
= unpack_size
;
17958 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
17959 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
17960 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
17961 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
17963 salt
->salt_len
= 16;
17965 salt
->salt_sign
[0] = iter
;
17967 salt
->salt_iter
= 1 << iter
;
17978 return (PARSER_OK
);
17981 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17983 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
17985 u32
*digest
= (u32
*) hash_buf
->digest
;
17987 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17988 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17989 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17990 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17991 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
17992 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
17993 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
17994 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
17996 digest
[0] = byte_swap_32 (digest
[0]);
17997 digest
[1] = byte_swap_32 (digest
[1]);
17998 digest
[2] = byte_swap_32 (digest
[2]);
17999 digest
[3] = byte_swap_32 (digest
[3]);
18000 digest
[4] = byte_swap_32 (digest
[4]);
18001 digest
[5] = byte_swap_32 (digest
[5]);
18002 digest
[6] = byte_swap_32 (digest
[6]);
18003 digest
[7] = byte_swap_32 (digest
[7]);
18005 return (PARSER_OK
);
18008 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18010 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18012 u32
*digest
= (u32
*) hash_buf
->digest
;
18014 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18015 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18016 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18017 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18018 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18019 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18020 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18021 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18022 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18023 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18024 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18025 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18026 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18027 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18028 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18029 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18031 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18032 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18033 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18034 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18035 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18036 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18037 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18038 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18039 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18040 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18041 digest
[10] = byte_swap_32 (digest
[10]);
18042 digest
[11] = byte_swap_32 (digest
[11]);
18043 digest
[12] = byte_swap_32 (digest
[12]);
18044 digest
[13] = byte_swap_32 (digest
[13]);
18045 digest
[14] = byte_swap_32 (digest
[14]);
18046 digest
[15] = byte_swap_32 (digest
[15]);
18048 return (PARSER_OK
);
18051 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18053 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18055 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18057 u32
*digest
= (u32
*) hash_buf
->digest
;
18059 salt_t
*salt
= hash_buf
->salt
;
18061 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18069 char *iter_pos
= input_buf
+ 4;
18071 u32 iter
= atoi (iter_pos
);
18073 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18074 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18076 // first is *raw* salt
18078 char *salt_pos
= strchr (iter_pos
, ':');
18080 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18084 char *hash_pos
= strchr (salt_pos
, ':');
18086 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18088 u32 salt_len
= hash_pos
- salt_pos
;
18090 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18094 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18096 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18100 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18102 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18104 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18106 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18107 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18109 salt
->salt_len
= salt_len
;
18110 salt
->salt_iter
= iter
- 1;
18116 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18118 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18120 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18122 memcpy (digest
, tmp_buf
, 16);
18124 // add some stuff to normal salt to make sorted happy
18126 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18127 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18128 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18129 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18130 salt
->salt_buf
[4] = salt
->salt_iter
;
18132 return (PARSER_OK
);
18135 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18137 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18139 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18141 u32
*digest
= (u32
*) hash_buf
->digest
;
18143 salt_t
*salt
= hash_buf
->salt
;
18145 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18153 char *iter_pos
= input_buf
+ 5;
18155 u32 iter
= atoi (iter_pos
);
18157 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18158 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18160 // first is *raw* salt
18162 char *salt_pos
= strchr (iter_pos
, ':');
18164 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18168 char *hash_pos
= strchr (salt_pos
, ':');
18170 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18172 u32 salt_len
= hash_pos
- salt_pos
;
18174 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18178 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18180 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18184 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18186 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18188 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18190 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18191 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18193 salt
->salt_len
= salt_len
;
18194 salt
->salt_iter
= iter
- 1;
18200 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18202 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18204 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18206 memcpy (digest
, tmp_buf
, 16);
18208 digest
[0] = byte_swap_32 (digest
[0]);
18209 digest
[1] = byte_swap_32 (digest
[1]);
18210 digest
[2] = byte_swap_32 (digest
[2]);
18211 digest
[3] = byte_swap_32 (digest
[3]);
18213 // add some stuff to normal salt to make sorted happy
18215 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18216 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18217 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18218 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18219 salt
->salt_buf
[4] = salt
->salt_iter
;
18221 return (PARSER_OK
);
18224 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18226 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18228 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18230 u64
*digest
= (u64
*) hash_buf
->digest
;
18232 salt_t
*salt
= hash_buf
->salt
;
18234 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18242 char *iter_pos
= input_buf
+ 7;
18244 u32 iter
= atoi (iter_pos
);
18246 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18247 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18249 // first is *raw* salt
18251 char *salt_pos
= strchr (iter_pos
, ':');
18253 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18257 char *hash_pos
= strchr (salt_pos
, ':');
18259 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18261 u32 salt_len
= hash_pos
- salt_pos
;
18263 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18267 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18269 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18273 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18275 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18277 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18279 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18280 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18282 salt
->salt_len
= salt_len
;
18283 salt
->salt_iter
= iter
- 1;
18289 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18291 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18293 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18295 memcpy (digest
, tmp_buf
, 64);
18297 digest
[0] = byte_swap_64 (digest
[0]);
18298 digest
[1] = byte_swap_64 (digest
[1]);
18299 digest
[2] = byte_swap_64 (digest
[2]);
18300 digest
[3] = byte_swap_64 (digest
[3]);
18301 digest
[4] = byte_swap_64 (digest
[4]);
18302 digest
[5] = byte_swap_64 (digest
[5]);
18303 digest
[6] = byte_swap_64 (digest
[6]);
18304 digest
[7] = byte_swap_64 (digest
[7]);
18306 // add some stuff to normal salt to make sorted happy
18308 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18309 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18310 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18311 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18312 salt
->salt_buf
[4] = salt
->salt_iter
;
18314 return (PARSER_OK
);
18317 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18319 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18321 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18323 uint
*digest
= (uint
*) hash_buf
->digest
;
18325 salt_t
*salt
= hash_buf
->salt
;
18331 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18333 char *hash_pos
= strchr (salt_pos
, '$');
18335 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18337 u32 salt_len
= hash_pos
- salt_pos
;
18339 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18343 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18345 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18349 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18350 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18368 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18369 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18371 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18372 salt
->salt_len
= 8;
18374 return (PARSER_OK
);
18377 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18379 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18381 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18383 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18385 if (c19
& 3) return (PARSER_HASH_VALUE
);
18387 salt_t
*salt
= hash_buf
->salt
;
18389 u32
*digest
= (u32
*) hash_buf
->digest
;
18393 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18394 | itoa64_to_int (input_buf
[2]) << 6
18395 | itoa64_to_int (input_buf
[3]) << 12
18396 | itoa64_to_int (input_buf
[4]) << 18;
18400 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18401 | itoa64_to_int (input_buf
[6]) << 6
18402 | itoa64_to_int (input_buf
[7]) << 12
18403 | itoa64_to_int (input_buf
[8]) << 18;
18405 salt
->salt_len
= 4;
18409 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18411 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18413 memcpy (digest
, tmp_buf
, 8);
18417 IP (digest
[0], digest
[1], tt
);
18419 digest
[0] = rotr32 (digest
[0], 31);
18420 digest
[1] = rotr32 (digest
[1], 31);
18424 return (PARSER_OK
);
18427 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18429 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18431 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18433 u32
*digest
= (u32
*) hash_buf
->digest
;
18435 salt_t
*salt
= hash_buf
->salt
;
18441 char *type_pos
= input_buf
+ 6 + 1;
18443 char *salt_pos
= strchr (type_pos
, '*');
18445 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18447 u32 type_len
= salt_pos
- type_pos
;
18449 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18453 char *crypted_pos
= strchr (salt_pos
, '*');
18455 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18457 u32 salt_len
= crypted_pos
- salt_pos
;
18459 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18463 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18465 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18471 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18472 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18474 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18475 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18477 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18478 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18479 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18480 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18482 salt
->salt_len
= 24;
18483 salt
->salt_iter
= ROUNDS_RAR3
;
18485 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18486 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18488 digest
[0] = 0xc43d7b00;
18489 digest
[1] = 0x40070000;
18493 return (PARSER_OK
);
18496 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18498 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18500 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18502 u32
*digest
= (u32
*) hash_buf
->digest
;
18504 salt_t
*salt
= hash_buf
->salt
;
18506 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18512 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18514 char *param1_pos
= strchr (param0_pos
, '$');
18516 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18518 u32 param0_len
= param1_pos
- param0_pos
;
18522 char *param2_pos
= strchr (param1_pos
, '$');
18524 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18526 u32 param1_len
= param2_pos
- param1_pos
;
18530 char *param3_pos
= strchr (param2_pos
, '$');
18532 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18534 u32 param2_len
= param3_pos
- param2_pos
;
18538 char *param4_pos
= strchr (param3_pos
, '$');
18540 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18542 u32 param3_len
= param4_pos
- param3_pos
;
18546 char *param5_pos
= strchr (param4_pos
, '$');
18548 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18550 u32 param4_len
= param5_pos
- param4_pos
;
18554 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18556 char *salt_buf
= param1_pos
;
18557 char *iv
= param3_pos
;
18558 char *pswcheck
= param5_pos
;
18560 const uint salt_len
= atoi (param0_pos
);
18561 const uint iterations
= atoi (param2_pos
);
18562 const uint pswcheck_len
= atoi (param4_pos
);
18568 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18569 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18570 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18572 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18573 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18574 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18580 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18581 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18582 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18583 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
18585 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
18586 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
18587 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
18588 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
18590 salt
->salt_len
= 16;
18592 salt
->salt_sign
[0] = iterations
;
18594 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18600 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
18601 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
18605 return (PARSER_OK
);
18608 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18610 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18612 u32
*digest
= (u32
*) hash_buf
->digest
;
18614 salt_t
*salt
= hash_buf
->salt
;
18616 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18617 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18618 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18619 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18620 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18621 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18622 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18623 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18625 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18627 uint salt_len
= input_len
- 64 - 1;
18629 char *salt_buf
= input_buf
+ 64 + 1;
18631 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18633 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18635 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18637 salt
->salt_len
= salt_len
;
18640 * we can precompute the first sha256 transform
18645 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18646 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18647 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18648 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18649 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18650 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18651 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18652 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18653 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18654 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18655 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18656 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18657 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18658 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18659 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18660 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18664 pc256
[0] = SHA256M_A
;
18665 pc256
[1] = SHA256M_B
;
18666 pc256
[2] = SHA256M_C
;
18667 pc256
[3] = SHA256M_D
;
18668 pc256
[4] = SHA256M_E
;
18669 pc256
[5] = SHA256M_F
;
18670 pc256
[6] = SHA256M_G
;
18671 pc256
[7] = SHA256M_H
;
18673 sha256_64 (w
, pc256
);
18675 salt
->salt_buf_pc
[0] = pc256
[0];
18676 salt
->salt_buf_pc
[1] = pc256
[1];
18677 salt
->salt_buf_pc
[2] = pc256
[2];
18678 salt
->salt_buf_pc
[3] = pc256
[3];
18679 salt
->salt_buf_pc
[4] = pc256
[4];
18680 salt
->salt_buf_pc
[5] = pc256
[5];
18681 salt
->salt_buf_pc
[6] = pc256
[6];
18682 salt
->salt_buf_pc
[7] = pc256
[7];
18684 digest
[0] -= pc256
[0];
18685 digest
[1] -= pc256
[1];
18686 digest
[2] -= pc256
[2];
18687 digest
[3] -= pc256
[3];
18688 digest
[4] -= pc256
[4];
18689 digest
[5] -= pc256
[5];
18690 digest
[6] -= pc256
[6];
18691 digest
[7] -= pc256
[7];
18693 return (PARSER_OK
);
18696 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18698 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18700 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18702 u32
*digest
= (u32
*) hash_buf
->digest
;
18704 salt_t
*salt
= hash_buf
->salt
;
18710 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18712 char *data_buf_pos
= strchr (data_len_pos
, '$');
18714 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18716 u32 data_len_len
= data_buf_pos
- data_len_pos
;
18718 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18719 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18723 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18725 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
18727 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
18729 u32 data_len
= atoi (data_len_pos
);
18731 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
18737 char *salt_pos
= data_buf_pos
;
18739 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18740 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18741 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
18742 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
18744 // this is actually the CT, which is also the hash later (if matched)
18746 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
18747 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
18748 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
18749 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
18751 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
18753 salt
->salt_iter
= 10 - 1;
18759 digest
[0] = salt
->salt_buf
[4];
18760 digest
[1] = salt
->salt_buf
[5];
18761 digest
[2] = salt
->salt_buf
[6];
18762 digest
[3] = salt
->salt_buf
[7];
18764 return (PARSER_OK
);
18767 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18769 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
18771 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18773 u32
*digest
= (u32
*) hash_buf
->digest
;
18775 salt_t
*salt
= hash_buf
->salt
;
18781 char *salt_pos
= input_buf
+ 11 + 1;
18783 char *iter_pos
= strchr (salt_pos
, ',');
18785 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18787 u32 salt_len
= iter_pos
- salt_pos
;
18789 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
18793 char *hash_pos
= strchr (iter_pos
, ',');
18795 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18797 u32 iter_len
= hash_pos
- iter_pos
;
18799 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
18803 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
18805 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
18811 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18812 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18813 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
18814 salt
->salt_buf
[3] = 0x00018000;
18816 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18817 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18818 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
18819 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
18821 salt
->salt_len
= salt_len
/ 2;
18823 salt
->salt_iter
= atoi (iter_pos
) - 1;
18829 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18830 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18831 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18832 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18833 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18834 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
18835 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
18836 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
18838 return (PARSER_OK
);
18841 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18843 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
18845 u32
*digest
= (u32
*) hash_buf
->digest
;
18847 salt_t
*salt
= hash_buf
->salt
;
18853 char *hash_pos
= input_buf
+ 64;
18854 char *salt1_pos
= input_buf
+ 128;
18855 char *salt2_pos
= input_buf
;
18861 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
18862 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
18863 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
18864 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
18866 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
18867 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
18868 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
18869 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
18871 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
18872 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
18873 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
18874 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
18876 salt
->salt_len
= 48;
18878 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
18884 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18885 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18886 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18887 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18888 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18889 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
18890 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
18891 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
18893 return (PARSER_OK
);
18897 * parallel running threads
18902 BOOL WINAPI
sigHandler_default (DWORD sig
)
18906 case CTRL_CLOSE_EVENT
:
18909 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
18910 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
18911 * function otherwise it is to late (e.g. after returning from this function)
18916 SetConsoleCtrlHandler (NULL
, TRUE
);
18923 case CTRL_LOGOFF_EVENT
:
18924 case CTRL_SHUTDOWN_EVENT
:
18928 SetConsoleCtrlHandler (NULL
, TRUE
);
18936 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
18940 case CTRL_CLOSE_EVENT
:
18944 SetConsoleCtrlHandler (NULL
, TRUE
);
18951 case CTRL_LOGOFF_EVENT
:
18952 case CTRL_SHUTDOWN_EVENT
:
18956 SetConsoleCtrlHandler (NULL
, TRUE
);
18964 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
18966 if (callback
== NULL
)
18968 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
18972 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
18978 void sigHandler_default (int sig
)
18982 signal (sig
, NULL
);
18985 void sigHandler_benchmark (int sig
)
18989 signal (sig
, NULL
);
18992 void hc_signal (void (callback
) (int))
18994 if (callback
== NULL
) callback
= SIG_DFL
;
18996 signal (SIGINT
, callback
);
18997 signal (SIGTERM
, callback
);
18998 signal (SIGABRT
, callback
);
19003 void status_display ();
19005 void *thread_keypress (void *p
)
19007 int benchmark
= *((int *) p
);
19009 uint quiet
= data
.quiet
;
19013 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19015 int ch
= tty_getchar();
19017 if (ch
== -1) break;
19019 if (ch
== 0) continue;
19025 hc_thread_mutex_lock (mux_display
);
19040 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19041 if (quiet
== 0) fflush (stdout
);
19053 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19054 if (quiet
== 0) fflush (stdout
);
19066 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19067 if (quiet
== 0) fflush (stdout
);
19079 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19080 if (quiet
== 0) fflush (stdout
);
19088 if (benchmark
== 1) break;
19090 stop_at_checkpoint ();
19094 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19095 if (quiet
== 0) fflush (stdout
);
19103 if (benchmark
== 1)
19115 hc_thread_mutex_unlock (mux_display
);
19127 bool class_num (const u8 c
)
19129 return ((c
>= '0') && (c
<= '9'));
19132 bool class_lower (const u8 c
)
19134 return ((c
>= 'a') && (c
<= 'z'));
19137 bool class_upper (const u8 c
)
19139 return ((c
>= 'A') && (c
<= 'Z'));
19142 bool class_alpha (const u8 c
)
19144 return (class_lower (c
) || class_upper (c
));
19147 int conv_ctoi (const u8 c
)
19153 else if (class_upper (c
))
19155 return c
- 'A' + 10;
19161 int conv_itoc (const u8 c
)
19169 return c
+ 'A' - 10;
19179 #define INCR_POS if (++rule_pos == rule_len) return (-1)
19180 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
19181 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
19182 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
19183 #define MAX_KERNEL_RULES 255
19184 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
19185 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19186 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19188 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
19189 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
19190 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19191 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19193 int cpu_rule_to_kernel_rule (char rule_buf
[BUFSIZ
], uint rule_len
, kernel_rule_t
*rule
)
19198 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19200 switch (rule_buf
[rule_pos
])
19206 case RULE_OP_MANGLE_NOOP
:
19207 SET_NAME (rule
, rule_buf
[rule_pos
]);
19210 case RULE_OP_MANGLE_LREST
:
19211 SET_NAME (rule
, rule_buf
[rule_pos
]);
19214 case RULE_OP_MANGLE_UREST
:
19215 SET_NAME (rule
, rule_buf
[rule_pos
]);
19218 case RULE_OP_MANGLE_LREST_UFIRST
:
19219 SET_NAME (rule
, rule_buf
[rule_pos
]);
19222 case RULE_OP_MANGLE_UREST_LFIRST
:
19223 SET_NAME (rule
, rule_buf
[rule_pos
]);
19226 case RULE_OP_MANGLE_TREST
:
19227 SET_NAME (rule
, rule_buf
[rule_pos
]);
19230 case RULE_OP_MANGLE_TOGGLE_AT
:
19231 SET_NAME (rule
, rule_buf
[rule_pos
]);
19232 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19235 case RULE_OP_MANGLE_REVERSE
:
19236 SET_NAME (rule
, rule_buf
[rule_pos
]);
19239 case RULE_OP_MANGLE_DUPEWORD
:
19240 SET_NAME (rule
, rule_buf
[rule_pos
]);
19243 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19244 SET_NAME (rule
, rule_buf
[rule_pos
]);
19245 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19248 case RULE_OP_MANGLE_REFLECT
:
19249 SET_NAME (rule
, rule_buf
[rule_pos
]);
19252 case RULE_OP_MANGLE_ROTATE_LEFT
:
19253 SET_NAME (rule
, rule_buf
[rule_pos
]);
19256 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19257 SET_NAME (rule
, rule_buf
[rule_pos
]);
19260 case RULE_OP_MANGLE_APPEND
:
19261 SET_NAME (rule
, rule_buf
[rule_pos
]);
19262 SET_P0 (rule
, rule_buf
[rule_pos
]);
19265 case RULE_OP_MANGLE_PREPEND
:
19266 SET_NAME (rule
, rule_buf
[rule_pos
]);
19267 SET_P0 (rule
, rule_buf
[rule_pos
]);
19270 case RULE_OP_MANGLE_DELETE_FIRST
:
19271 SET_NAME (rule
, rule_buf
[rule_pos
]);
19274 case RULE_OP_MANGLE_DELETE_LAST
:
19275 SET_NAME (rule
, rule_buf
[rule_pos
]);
19278 case RULE_OP_MANGLE_DELETE_AT
:
19279 SET_NAME (rule
, rule_buf
[rule_pos
]);
19280 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19283 case RULE_OP_MANGLE_EXTRACT
:
19284 SET_NAME (rule
, rule_buf
[rule_pos
]);
19285 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19286 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19289 case RULE_OP_MANGLE_OMIT
:
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_INSERT
:
19296 SET_NAME (rule
, rule_buf
[rule_pos
]);
19297 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19298 SET_P1 (rule
, rule_buf
[rule_pos
]);
19301 case RULE_OP_MANGLE_OVERSTRIKE
:
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_TRUNCATE_AT
:
19308 SET_NAME (rule
, rule_buf
[rule_pos
]);
19309 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19312 case RULE_OP_MANGLE_REPLACE
:
19313 SET_NAME (rule
, rule_buf
[rule_pos
]);
19314 SET_P0 (rule
, rule_buf
[rule_pos
]);
19315 SET_P1 (rule
, rule_buf
[rule_pos
]);
19318 case RULE_OP_MANGLE_PURGECHAR
:
19322 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19326 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19327 SET_NAME (rule
, rule_buf
[rule_pos
]);
19328 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19331 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19332 SET_NAME (rule
, rule_buf
[rule_pos
]);
19333 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19336 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19337 SET_NAME (rule
, rule_buf
[rule_pos
]);
19340 case RULE_OP_MANGLE_SWITCH_FIRST
:
19341 SET_NAME (rule
, rule_buf
[rule_pos
]);
19344 case RULE_OP_MANGLE_SWITCH_LAST
:
19345 SET_NAME (rule
, rule_buf
[rule_pos
]);
19348 case RULE_OP_MANGLE_SWITCH_AT
:
19349 SET_NAME (rule
, rule_buf
[rule_pos
]);
19350 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19351 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19354 case RULE_OP_MANGLE_CHR_SHIFTL
:
19355 SET_NAME (rule
, rule_buf
[rule_pos
]);
19356 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19359 case RULE_OP_MANGLE_CHR_SHIFTR
:
19360 SET_NAME (rule
, rule_buf
[rule_pos
]);
19361 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19364 case RULE_OP_MANGLE_CHR_INCR
:
19365 SET_NAME (rule
, rule_buf
[rule_pos
]);
19366 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19369 case RULE_OP_MANGLE_CHR_DECR
:
19370 SET_NAME (rule
, rule_buf
[rule_pos
]);
19371 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19374 case RULE_OP_MANGLE_REPLACE_NP1
:
19375 SET_NAME (rule
, rule_buf
[rule_pos
]);
19376 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19379 case RULE_OP_MANGLE_REPLACE_NM1
:
19380 SET_NAME (rule
, rule_buf
[rule_pos
]);
19381 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19384 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19385 SET_NAME (rule
, rule_buf
[rule_pos
]);
19386 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19389 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19390 SET_NAME (rule
, rule_buf
[rule_pos
]);
19391 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19394 case RULE_OP_MANGLE_TITLE
:
19395 SET_NAME (rule
, rule_buf
[rule_pos
]);
19404 if (rule_pos
< rule_len
) return (-1);
19409 int kernel_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], kernel_rule_t
*rule
)
19413 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19417 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19421 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19425 case RULE_OP_MANGLE_NOOP
:
19426 rule_buf
[rule_pos
] = rule_cmd
;
19429 case RULE_OP_MANGLE_LREST
:
19430 rule_buf
[rule_pos
] = rule_cmd
;
19433 case RULE_OP_MANGLE_UREST
:
19434 rule_buf
[rule_pos
] = rule_cmd
;
19437 case RULE_OP_MANGLE_LREST_UFIRST
:
19438 rule_buf
[rule_pos
] = rule_cmd
;
19441 case RULE_OP_MANGLE_UREST_LFIRST
:
19442 rule_buf
[rule_pos
] = rule_cmd
;
19445 case RULE_OP_MANGLE_TREST
:
19446 rule_buf
[rule_pos
] = rule_cmd
;
19449 case RULE_OP_MANGLE_TOGGLE_AT
:
19450 rule_buf
[rule_pos
] = rule_cmd
;
19451 GET_P0_CONV (rule
);
19454 case RULE_OP_MANGLE_REVERSE
:
19455 rule_buf
[rule_pos
] = rule_cmd
;
19458 case RULE_OP_MANGLE_DUPEWORD
:
19459 rule_buf
[rule_pos
] = rule_cmd
;
19462 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19463 rule_buf
[rule_pos
] = rule_cmd
;
19464 GET_P0_CONV (rule
);
19467 case RULE_OP_MANGLE_REFLECT
:
19468 rule_buf
[rule_pos
] = rule_cmd
;
19471 case RULE_OP_MANGLE_ROTATE_LEFT
:
19472 rule_buf
[rule_pos
] = rule_cmd
;
19475 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19476 rule_buf
[rule_pos
] = rule_cmd
;
19479 case RULE_OP_MANGLE_APPEND
:
19480 rule_buf
[rule_pos
] = rule_cmd
;
19484 case RULE_OP_MANGLE_PREPEND
:
19485 rule_buf
[rule_pos
] = rule_cmd
;
19489 case RULE_OP_MANGLE_DELETE_FIRST
:
19490 rule_buf
[rule_pos
] = rule_cmd
;
19493 case RULE_OP_MANGLE_DELETE_LAST
:
19494 rule_buf
[rule_pos
] = rule_cmd
;
19497 case RULE_OP_MANGLE_DELETE_AT
:
19498 rule_buf
[rule_pos
] = rule_cmd
;
19499 GET_P0_CONV (rule
);
19502 case RULE_OP_MANGLE_EXTRACT
:
19503 rule_buf
[rule_pos
] = rule_cmd
;
19504 GET_P0_CONV (rule
);
19505 GET_P1_CONV (rule
);
19508 case RULE_OP_MANGLE_OMIT
:
19509 rule_buf
[rule_pos
] = rule_cmd
;
19510 GET_P0_CONV (rule
);
19511 GET_P1_CONV (rule
);
19514 case RULE_OP_MANGLE_INSERT
:
19515 rule_buf
[rule_pos
] = rule_cmd
;
19516 GET_P0_CONV (rule
);
19520 case RULE_OP_MANGLE_OVERSTRIKE
:
19521 rule_buf
[rule_pos
] = rule_cmd
;
19522 GET_P0_CONV (rule
);
19526 case RULE_OP_MANGLE_TRUNCATE_AT
:
19527 rule_buf
[rule_pos
] = rule_cmd
;
19528 GET_P0_CONV (rule
);
19531 case RULE_OP_MANGLE_REPLACE
:
19532 rule_buf
[rule_pos
] = rule_cmd
;
19537 case RULE_OP_MANGLE_PURGECHAR
:
19541 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19545 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19546 rule_buf
[rule_pos
] = rule_cmd
;
19547 GET_P0_CONV (rule
);
19550 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19551 rule_buf
[rule_pos
] = rule_cmd
;
19552 GET_P0_CONV (rule
);
19555 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19556 rule_buf
[rule_pos
] = rule_cmd
;
19559 case RULE_OP_MANGLE_SWITCH_FIRST
:
19560 rule_buf
[rule_pos
] = rule_cmd
;
19563 case RULE_OP_MANGLE_SWITCH_LAST
:
19564 rule_buf
[rule_pos
] = rule_cmd
;
19567 case RULE_OP_MANGLE_SWITCH_AT
:
19568 rule_buf
[rule_pos
] = rule_cmd
;
19569 GET_P0_CONV (rule
);
19570 GET_P1_CONV (rule
);
19573 case RULE_OP_MANGLE_CHR_SHIFTL
:
19574 rule_buf
[rule_pos
] = rule_cmd
;
19575 GET_P0_CONV (rule
);
19578 case RULE_OP_MANGLE_CHR_SHIFTR
:
19579 rule_buf
[rule_pos
] = rule_cmd
;
19580 GET_P0_CONV (rule
);
19583 case RULE_OP_MANGLE_CHR_INCR
:
19584 rule_buf
[rule_pos
] = rule_cmd
;
19585 GET_P0_CONV (rule
);
19588 case RULE_OP_MANGLE_CHR_DECR
:
19589 rule_buf
[rule_pos
] = rule_cmd
;
19590 GET_P0_CONV (rule
);
19593 case RULE_OP_MANGLE_REPLACE_NP1
:
19594 rule_buf
[rule_pos
] = rule_cmd
;
19595 GET_P0_CONV (rule
);
19598 case RULE_OP_MANGLE_REPLACE_NM1
:
19599 rule_buf
[rule_pos
] = rule_cmd
;
19600 GET_P0_CONV (rule
);
19603 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19604 rule_buf
[rule_pos
] = rule_cmd
;
19605 GET_P0_CONV (rule
);
19608 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19609 rule_buf
[rule_pos
] = rule_cmd
;
19610 GET_P0_CONV (rule
);
19613 case RULE_OP_MANGLE_TITLE
:
19614 rule_buf
[rule_pos
] = rule_cmd
;
19618 return rule_pos
- 1;
19636 * CPU rules : this is from hashcat sources, cpu based rules
19639 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19640 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19642 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19643 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19644 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19646 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19647 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19648 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19650 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19654 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19659 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19663 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19668 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19672 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19677 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19682 for (l
= 0; l
< arr_len
; l
++)
19684 r
= arr_len
- 1 - l
;
19688 MANGLE_SWITCH (arr
, l
, r
);
19694 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19696 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19698 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19700 return (arr_len
* 2);
19703 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19705 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19707 int orig_len
= arr_len
;
19711 for (i
= 0; i
< times
; i
++)
19713 memcpy (&arr
[arr_len
], arr
, orig_len
);
19715 arr_len
+= orig_len
;
19721 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19723 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19725 mangle_double (arr
, arr_len
);
19727 mangle_reverse (arr
+ arr_len
, arr_len
);
19729 return (arr_len
* 2);
19732 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
19737 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
19739 MANGLE_SWITCH (arr
, l
, r
);
19745 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
19750 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
19752 MANGLE_SWITCH (arr
, l
, r
);
19758 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19760 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19764 return (arr_len
+ 1);
19767 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19769 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19773 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19775 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19780 return (arr_len
+ 1);
19783 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19785 if (upos
>= arr_len
) return (arr_len
);
19789 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
19791 arr
[arr_pos
] = arr
[arr_pos
+ 1];
19794 return (arr_len
- 1);
19797 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19799 if (upos
>= arr_len
) return (arr_len
);
19801 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
19805 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
19807 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
19813 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19815 if (upos
>= arr_len
) return (arr_len
);
19817 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
19821 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
19823 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
19826 return (arr_len
- ulen
);
19829 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19831 if (upos
>= arr_len
) return (arr_len
);
19833 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19837 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
19839 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19844 return (arr_len
+ 1);
19847 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
)
19849 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
19851 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
19853 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
19855 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
19857 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
19859 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
19861 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
19863 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
19865 return (arr_len
+ arr2_cpy
);
19868 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19870 if (upos
>= arr_len
) return (arr_len
);
19877 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19879 if (upos
>= arr_len
) return (arr_len
);
19881 memset (arr
+ upos
, 0, arr_len
- upos
);
19886 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
19890 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19892 if (arr
[arr_pos
] != oldc
) continue;
19894 arr
[arr_pos
] = newc
;
19900 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19906 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19908 if (arr
[arr_pos
] == c
) continue;
19910 arr
[ret_len
] = arr
[arr_pos
];
19918 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19920 if (ulen
> arr_len
) return (arr_len
);
19922 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19926 memcpy (cs
, arr
, ulen
);
19930 for (i
= 0; i
< ulen
; i
++)
19934 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
19940 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19942 if (ulen
> arr_len
) return (arr_len
);
19944 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19946 int upos
= arr_len
- ulen
;
19950 for (i
= 0; i
< ulen
; i
++)
19952 char c
= arr
[upos
+ i
];
19954 arr_len
= mangle_append (arr
, arr_len
, c
);
19960 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19962 if ( arr_len
== 0) return (arr_len
);
19963 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19965 char c
= arr
[upos
];
19969 for (i
= 0; i
< ulen
; i
++)
19971 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
19977 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
19979 if ( arr_len
== 0) return (arr_len
);
19980 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19984 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19986 int new_pos
= arr_pos
* 2;
19988 arr
[new_pos
] = arr
[arr_pos
];
19990 arr
[new_pos
+ 1] = arr
[arr_pos
];
19993 return (arr_len
* 2);
19996 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
19998 if (upos
>= arr_len
) return (arr_len
);
19999 if (upos2
>= arr_len
) return (arr_len
);
20001 MANGLE_SWITCH (arr
, upos
, upos2
);
20006 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20008 MANGLE_SWITCH (arr
, upos
, upos2
);
20013 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20015 if (upos
>= arr_len
) return (arr_len
);
20022 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20024 if (upos
>= arr_len
) return (arr_len
);
20031 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20033 if (upos
>= arr_len
) return (arr_len
);
20040 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20042 if (upos
>= arr_len
) return (arr_len
);
20049 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20051 int upper_next
= 1;
20055 for (pos
= 0; pos
< arr_len
; pos
++)
20057 if (arr
[pos
] == ' ')
20068 MANGLE_UPPER_AT (arr
, pos
);
20072 MANGLE_LOWER_AT (arr
, pos
);
20079 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20081 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20087 for (j
= 0; j
< rp_gen_num
; j
++)
20094 switch ((char) get_random_num (0, 9))
20097 r
= get_random_num (0, sizeof (grp_op_nop
));
20098 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20102 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20103 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20104 p1
= get_random_num (0, sizeof (grp_pos
));
20105 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20109 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20110 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20111 p1
= get_random_num (1, 6);
20112 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20116 r
= get_random_num (0, sizeof (grp_op_chr
));
20117 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20118 p1
= get_random_num (0x20, 0x7e);
20119 rule_buf
[rule_pos
++] = (char) p1
;
20123 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20124 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20125 p1
= get_random_num (0x20, 0x7e);
20126 rule_buf
[rule_pos
++] = (char) p1
;
20127 p2
= get_random_num (0x20, 0x7e);
20129 p2
= get_random_num (0x20, 0x7e);
20130 rule_buf
[rule_pos
++] = (char) p2
;
20134 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20135 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20136 p1
= get_random_num (0, sizeof (grp_pos
));
20137 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20138 p2
= get_random_num (0x20, 0x7e);
20139 rule_buf
[rule_pos
++] = (char) p2
;
20143 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20144 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20145 p1
= get_random_num (0, sizeof (grp_pos
));
20146 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20147 p2
= get_random_num (0, sizeof (grp_pos
));
20149 p2
= get_random_num (0, sizeof (grp_pos
));
20150 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20154 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20155 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
20156 p1
= get_random_num (0, sizeof (grp_pos
));
20157 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20158 p2
= get_random_num (1, sizeof (grp_pos
));
20160 p2
= get_random_num (1, sizeof (grp_pos
));
20161 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20165 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
20166 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
20167 p1
= get_random_num (0, sizeof (grp_pos
));
20168 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20169 p2
= get_random_num (1, sizeof (grp_pos
));
20170 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20171 p3
= get_random_num (0, sizeof (grp_pos
));
20172 rule_buf
[rule_pos
++] = grp_pos
[p3
];
20180 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
20182 char mem
[BLOCK_SIZE
];
20184 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
20186 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
20188 if (in_len
< 1) return (RULE_RC_REJECT_ERROR
);
20190 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
20192 int out_len
= in_len
;
20193 int mem_len
= in_len
;
20195 memcpy (out
, in
, out_len
);
20199 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
20201 int upos
; int upos2
;
20204 switch (rule
[rule_pos
])
20209 case RULE_OP_MANGLE_NOOP
:
20212 case RULE_OP_MANGLE_LREST
:
20213 out_len
= mangle_lrest (out
, out_len
);
20216 case RULE_OP_MANGLE_UREST
:
20217 out_len
= mangle_urest (out
, out_len
);
20220 case RULE_OP_MANGLE_LREST_UFIRST
:
20221 out_len
= mangle_lrest (out
, out_len
);
20222 if (out_len
) MANGLE_UPPER_AT (out
, 0);
20225 case RULE_OP_MANGLE_UREST_LFIRST
:
20226 out_len
= mangle_urest (out
, out_len
);
20227 if (out_len
) MANGLE_LOWER_AT (out
, 0);
20230 case RULE_OP_MANGLE_TREST
:
20231 out_len
= mangle_trest (out
, out_len
);
20234 case RULE_OP_MANGLE_TOGGLE_AT
:
20235 NEXT_RULEPOS (rule_pos
);
20236 NEXT_RPTOI (rule
, rule_pos
, upos
);
20237 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
20240 case RULE_OP_MANGLE_REVERSE
:
20241 out_len
= mangle_reverse (out
, out_len
);
20244 case RULE_OP_MANGLE_DUPEWORD
:
20245 out_len
= mangle_double (out
, out_len
);
20248 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20249 NEXT_RULEPOS (rule_pos
);
20250 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20251 out_len
= mangle_double_times (out
, out_len
, ulen
);
20254 case RULE_OP_MANGLE_REFLECT
:
20255 out_len
= mangle_reflect (out
, out_len
);
20258 case RULE_OP_MANGLE_ROTATE_LEFT
:
20259 mangle_rotate_left (out
, out_len
);
20262 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20263 mangle_rotate_right (out
, out_len
);
20266 case RULE_OP_MANGLE_APPEND
:
20267 NEXT_RULEPOS (rule_pos
);
20268 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
20271 case RULE_OP_MANGLE_PREPEND
:
20272 NEXT_RULEPOS (rule_pos
);
20273 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
20276 case RULE_OP_MANGLE_DELETE_FIRST
:
20277 out_len
= mangle_delete_at (out
, out_len
, 0);
20280 case RULE_OP_MANGLE_DELETE_LAST
:
20281 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
20284 case RULE_OP_MANGLE_DELETE_AT
:
20285 NEXT_RULEPOS (rule_pos
);
20286 NEXT_RPTOI (rule
, rule_pos
, upos
);
20287 out_len
= mangle_delete_at (out
, out_len
, upos
);
20290 case RULE_OP_MANGLE_EXTRACT
:
20291 NEXT_RULEPOS (rule_pos
);
20292 NEXT_RPTOI (rule
, rule_pos
, upos
);
20293 NEXT_RULEPOS (rule_pos
);
20294 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20295 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
20298 case RULE_OP_MANGLE_OMIT
:
20299 NEXT_RULEPOS (rule_pos
);
20300 NEXT_RPTOI (rule
, rule_pos
, upos
);
20301 NEXT_RULEPOS (rule_pos
);
20302 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20303 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
20306 case RULE_OP_MANGLE_INSERT
:
20307 NEXT_RULEPOS (rule_pos
);
20308 NEXT_RPTOI (rule
, rule_pos
, upos
);
20309 NEXT_RULEPOS (rule_pos
);
20310 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
20313 case RULE_OP_MANGLE_OVERSTRIKE
:
20314 NEXT_RULEPOS (rule_pos
);
20315 NEXT_RPTOI (rule
, rule_pos
, upos
);
20316 NEXT_RULEPOS (rule_pos
);
20317 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20320 case RULE_OP_MANGLE_TRUNCATE_AT
:
20321 NEXT_RULEPOS (rule_pos
);
20322 NEXT_RPTOI (rule
, rule_pos
, upos
);
20323 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20326 case RULE_OP_MANGLE_REPLACE
:
20327 NEXT_RULEPOS (rule_pos
);
20328 NEXT_RULEPOS (rule_pos
);
20329 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20332 case RULE_OP_MANGLE_PURGECHAR
:
20333 NEXT_RULEPOS (rule_pos
);
20334 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20337 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20341 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20342 NEXT_RULEPOS (rule_pos
);
20343 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20344 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20347 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20348 NEXT_RULEPOS (rule_pos
);
20349 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20350 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20353 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20354 out_len
= mangle_dupechar (out
, out_len
);
20357 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20358 NEXT_RULEPOS (rule_pos
);
20359 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20360 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20363 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20364 NEXT_RULEPOS (rule_pos
);
20365 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20366 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20369 case RULE_OP_MANGLE_SWITCH_FIRST
:
20370 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20373 case RULE_OP_MANGLE_SWITCH_LAST
:
20374 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20377 case RULE_OP_MANGLE_SWITCH_AT
:
20378 NEXT_RULEPOS (rule_pos
);
20379 NEXT_RPTOI (rule
, rule_pos
, upos
);
20380 NEXT_RULEPOS (rule_pos
);
20381 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20382 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20385 case RULE_OP_MANGLE_CHR_SHIFTL
:
20386 NEXT_RULEPOS (rule_pos
);
20387 NEXT_RPTOI (rule
, rule_pos
, upos
);
20388 mangle_chr_shiftl (out
, out_len
, upos
);
20391 case RULE_OP_MANGLE_CHR_SHIFTR
:
20392 NEXT_RULEPOS (rule_pos
);
20393 NEXT_RPTOI (rule
, rule_pos
, upos
);
20394 mangle_chr_shiftr (out
, out_len
, upos
);
20397 case RULE_OP_MANGLE_CHR_INCR
:
20398 NEXT_RULEPOS (rule_pos
);
20399 NEXT_RPTOI (rule
, rule_pos
, upos
);
20400 mangle_chr_incr (out
, out_len
, upos
);
20403 case RULE_OP_MANGLE_CHR_DECR
:
20404 NEXT_RULEPOS (rule_pos
);
20405 NEXT_RPTOI (rule
, rule_pos
, upos
);
20406 mangle_chr_decr (out
, out_len
, upos
);
20409 case RULE_OP_MANGLE_REPLACE_NP1
:
20410 NEXT_RULEPOS (rule_pos
);
20411 NEXT_RPTOI (rule
, rule_pos
, upos
);
20412 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20415 case RULE_OP_MANGLE_REPLACE_NM1
:
20416 NEXT_RULEPOS (rule_pos
);
20417 NEXT_RPTOI (rule
, rule_pos
, upos
);
20418 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20421 case RULE_OP_MANGLE_TITLE
:
20422 out_len
= mangle_title (out
, out_len
);
20425 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20426 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20427 NEXT_RULEPOS (rule_pos
);
20428 NEXT_RPTOI (rule
, rule_pos
, upos
);
20429 NEXT_RULEPOS (rule_pos
);
20430 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20431 NEXT_RULEPOS (rule_pos
);
20432 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20433 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20436 case RULE_OP_MANGLE_APPEND_MEMORY
:
20437 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20438 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20439 memcpy (out
+ out_len
, mem
, mem_len
);
20440 out_len
+= mem_len
;
20443 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20444 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20445 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20446 memcpy (mem
+ mem_len
, out
, out_len
);
20447 out_len
+= mem_len
;
20448 memcpy (out
, mem
, out_len
);
20451 case RULE_OP_MEMORIZE_WORD
:
20452 memcpy (mem
, out
, out_len
);
20456 case RULE_OP_REJECT_LESS
:
20457 NEXT_RULEPOS (rule_pos
);
20458 NEXT_RPTOI (rule
, rule_pos
, upos
);
20459 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20462 case RULE_OP_REJECT_GREATER
:
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_CONTAIN
:
20469 NEXT_RULEPOS (rule_pos
);
20470 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20473 case RULE_OP_REJECT_NOT_CONTAIN
:
20474 NEXT_RULEPOS (rule_pos
);
20475 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20478 case RULE_OP_REJECT_EQUAL_FIRST
:
20479 NEXT_RULEPOS (rule_pos
);
20480 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20483 case RULE_OP_REJECT_EQUAL_LAST
:
20484 NEXT_RULEPOS (rule_pos
);
20485 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20488 case RULE_OP_REJECT_EQUAL_AT
:
20489 NEXT_RULEPOS (rule_pos
);
20490 NEXT_RPTOI (rule
, rule_pos
, upos
);
20491 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20492 NEXT_RULEPOS (rule_pos
);
20493 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20496 case RULE_OP_REJECT_CONTAINS
:
20497 NEXT_RULEPOS (rule_pos
);
20498 NEXT_RPTOI (rule
, rule_pos
, upos
);
20499 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20500 NEXT_RULEPOS (rule_pos
);
20501 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20502 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20505 case RULE_OP_REJECT_MEMORY
:
20506 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20510 return (RULE_RC_SYNTAX_ERROR
);
20515 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);