2 * Author......: Jens Steube <jens.steube@gmail.com>
13 #define GET_ACCEL(x) KERNEL_ACCEL_ ## x
14 #define GET_LOOPS(x) KERNEL_LOOPS_ ## x
20 u32
rotl32 (const u32 a
, const u32 n
)
22 return ((a
<< n
) | (a
>> (32 - n
)));
25 u32
rotr32 (const u32 a
, const u32 n
)
27 return ((a
>> n
) | (a
<< (32 - n
)));
30 u64
rotl64 (const u64 a
, const u64 n
)
32 return ((a
<< n
) | (a
>> (64 - n
)));
35 u64
rotr64 (const u64 a
, const u64 n
)
37 return ((a
>> n
) | (a
<< (64 - n
)));
40 u32
byte_swap_32 (const u32 n
)
42 return (n
& 0xff000000) >> 24
43 | (n
& 0x00ff0000) >> 8
44 | (n
& 0x0000ff00) << 8
45 | (n
& 0x000000ff) << 24;
48 u64
byte_swap_64 (const u64 n
)
50 return (n
& 0xff00000000000000ULL
) >> 56
51 | (n
& 0x00ff000000000000ULL
) >> 40
52 | (n
& 0x0000ff0000000000ULL
) >> 24
53 | (n
& 0x000000ff00000000ULL
) >> 8
54 | (n
& 0x00000000ff000000ULL
) << 8
55 | (n
& 0x0000000000ff0000ULL
) << 24
56 | (n
& 0x000000000000ff00ULL
) << 40
57 | (n
& 0x00000000000000ffULL
) << 56;
61 * ciphers for use on cpu
68 * hashes for use on cpu
72 #include "cpu-sha256.c"
80 void log_final (FILE *fp
, const char *fmt
, va_list ap
)
86 for (int i
= 0; i
< last_len
; i
++)
96 int max_len
= (int) sizeof (s
);
98 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
100 if (len
> max_len
) len
= max_len
;
102 fwrite (s
, len
, 1, fp
);
109 void log_out_nn (FILE *fp
, const char *fmt
, ...)
111 if (SUPPRESS_OUTPUT
) return;
117 log_final (fp
, fmt
, ap
);
122 void log_info_nn (const char *fmt
, ...)
124 if (SUPPRESS_OUTPUT
) return;
130 log_final (stdout
, fmt
, ap
);
135 void log_error_nn (const char *fmt
, ...)
137 if (SUPPRESS_OUTPUT
) return;
143 log_final (stderr
, fmt
, ap
);
148 void log_out (FILE *fp
, const char *fmt
, ...)
150 if (SUPPRESS_OUTPUT
) return;
156 log_final (fp
, fmt
, ap
);
165 void log_info (const char *fmt
, ...)
167 if (SUPPRESS_OUTPUT
) return;
173 log_final (stdout
, fmt
, ap
);
177 fputc ('\n', stdout
);
182 void log_error (const char *fmt
, ...)
184 if (SUPPRESS_OUTPUT
) return;
186 fputc ('\n', stderr
);
187 fputc ('\n', stderr
);
193 log_final (stderr
, fmt
, ap
);
197 fputc ('\n', stderr
);
198 fputc ('\n', stderr
);
207 u8
int_to_base32 (const u8 c
)
209 static const u8 tbl
[0x20] =
211 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
212 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
218 u8
base32_to_int (const u8 c
)
220 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
221 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
226 u8
int_to_itoa32 (const u8 c
)
228 static const u8 tbl
[0x20] =
230 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
231 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
237 u8
itoa32_to_int (const u8 c
)
239 if ((c
>= '0') && (c
<= '9')) return c
- '0';
240 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
245 u8
int_to_itoa64 (const u8 c
)
247 static const u8 tbl
[0x40] =
249 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
250 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
251 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
252 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
258 u8
itoa64_to_int (const u8 c
)
260 static const u8 tbl
[0x100] =
262 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
263 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
264 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
265 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
266 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
267 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
268 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
269 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
270 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
271 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
272 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
273 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
274 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
275 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
276 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
277 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
283 u8
int_to_base64 (const u8 c
)
285 static const u8 tbl
[0x40] =
287 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
288 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
289 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
290 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
296 u8
base64_to_int (const u8 c
)
298 static const u8 tbl
[0x100] =
300 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
301 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
302 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
303 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
304 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
305 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
306 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
307 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
308 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
309 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
310 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
311 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
312 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
313 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
314 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
315 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
321 u8
int_to_bf64 (const u8 c
)
323 static const u8 tbl
[0x40] =
325 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
326 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
327 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
328 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
334 u8
bf64_to_int (const u8 c
)
336 static const u8 tbl
[0x100] =
338 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
339 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
340 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
341 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
342 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
343 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
344 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
345 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
346 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
347 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
348 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
349 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
350 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
351 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
352 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
353 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
359 u8
int_to_lotus64 (const u8 c
)
361 if (c
< 10) return '0' + c
;
362 else if (c
< 36) return 'A' + c
- 10;
363 else if (c
< 62) return 'a' + c
- 36;
364 else if (c
== 62) return '+';
365 else if (c
== 63) return '/';
370 u8
lotus64_to_int (const u8 c
)
372 if ((c
>= '0') && (c
<= '9')) return c
- '0';
373 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
374 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
375 else if (c
== '+') return 62;
376 else if (c
== '/') return 63;
382 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
384 const u8
*in_ptr
= in_buf
;
386 u8
*out_ptr
= out_buf
;
388 for (int i
= 0; i
< in_len
; i
+= 8)
390 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
391 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
392 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
393 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
394 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
395 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
396 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
397 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
399 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
400 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
401 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
402 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
403 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
409 for (int i
= 0; i
< in_len
; i
++)
411 if (in_buf
[i
] != '=') continue;
416 int out_len
= (in_len
* 5) / 8;
421 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
423 const u8
*in_ptr
= in_buf
;
425 u8
*out_ptr
= out_buf
;
427 for (int i
= 0; i
< in_len
; i
+= 5)
429 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
430 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
431 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
432 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
433 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
434 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
435 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
436 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
438 out_ptr
[0] = out_val0
& 0x7f;
439 out_ptr
[1] = out_val1
& 0x7f;
440 out_ptr
[2] = out_val2
& 0x7f;
441 out_ptr
[3] = out_val3
& 0x7f;
442 out_ptr
[4] = out_val4
& 0x7f;
443 out_ptr
[5] = out_val5
& 0x7f;
444 out_ptr
[6] = out_val6
& 0x7f;
445 out_ptr
[7] = out_val7
& 0x7f;
451 int out_len
= (in_len
* 8) / 5;
453 for (int i
= 0; i
< (7 - (in_len
% 7)); i
++)
457 out_buf
[out_len
] = '=';
463 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
465 const u8
*in_ptr
= in_buf
;
467 u8
*out_ptr
= out_buf
;
469 for (int i
= 0; i
< in_len
; i
+= 4)
471 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
472 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
473 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
474 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
476 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
477 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
478 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
484 for (int i
= 0; i
< in_len
; i
++)
486 if (in_buf
[i
] != '=') continue;
491 int out_len
= (in_len
* 6) / 8;
496 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
498 const u8
*in_ptr
= in_buf
;
500 u8
*out_ptr
= out_buf
;
502 for (int i
= 0; i
< in_len
; i
+= 3)
504 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
505 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
506 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
507 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
509 out_ptr
[0] = out_val0
& 0x7f;
510 out_ptr
[1] = out_val1
& 0x7f;
511 out_ptr
[2] = out_val2
& 0x7f;
512 out_ptr
[3] = out_val3
& 0x7f;
518 int out_len
= (in_len
* 8) / 6;
520 for (int i
= 0; i
< (3 - (in_len
% 3)); i
++)
524 out_buf
[out_len
] = '=';
530 int is_valid_hex_char (const u8 c
)
532 if ((c
>= '0') && (c
<= '9')) return 1;
533 if ((c
>= 'A') && (c
<= 'F')) return 1;
534 if ((c
>= 'a') && (c
<= 'f')) return 1;
539 u8
hex_convert (const u8 c
)
541 return (c
& 15) + (c
>> 6) * 9;
544 u8
hex_to_u8 (const u8 hex
[2])
548 v
|= (hex_convert (hex
[1]) << 0);
549 v
|= (hex_convert (hex
[0]) << 4);
554 u32
hex_to_u32 (const u8 hex
[8])
558 v
|= ((u32
) hex_convert (hex
[7])) << 0;
559 v
|= ((u32
) hex_convert (hex
[6])) << 4;
560 v
|= ((u32
) hex_convert (hex
[5])) << 8;
561 v
|= ((u32
) hex_convert (hex
[4])) << 12;
562 v
|= ((u32
) hex_convert (hex
[3])) << 16;
563 v
|= ((u32
) hex_convert (hex
[2])) << 20;
564 v
|= ((u32
) hex_convert (hex
[1])) << 24;
565 v
|= ((u32
) hex_convert (hex
[0])) << 28;
570 u64
hex_to_u64 (const u8 hex
[16])
574 v
|= ((u64
) hex_convert (hex
[15]) << 0);
575 v
|= ((u64
) hex_convert (hex
[14]) << 4);
576 v
|= ((u64
) hex_convert (hex
[13]) << 8);
577 v
|= ((u64
) hex_convert (hex
[12]) << 12);
578 v
|= ((u64
) hex_convert (hex
[11]) << 16);
579 v
|= ((u64
) hex_convert (hex
[10]) << 20);
580 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
581 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
582 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
583 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
584 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
585 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
586 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
587 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
588 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
589 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
594 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
596 hex
[0] = v
>> 28 & 15;
597 hex
[1] = v
>> 24 & 15;
598 hex
[2] = v
>> 20 & 15;
599 hex
[3] = v
>> 16 & 15;
600 hex
[4] = v
>> 12 & 15;
601 hex
[5] = v
>> 8 & 15;
602 hex
[6] = v
>> 4 & 15;
603 hex
[7] = v
>> 0 & 15;
607 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
608 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
609 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
610 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
611 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
612 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
613 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
614 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
621 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
625 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
634 for (int i
= 0; i
< 16; i
+= 4)
644 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
651 out
[i
+ 0] = _out
[0];
652 out
[i
+ 1] = _out
[1];
653 out
[i
+ 2] = _out
[2];
654 out
[i
+ 3] = _out
[3];
663 static void juniper_decrypt_hash (char *in
, char *out
)
669 memset (base64_buf
, 0, sizeof (base64_buf
));
671 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
675 u32 juniper_iv
[4] = { 0 };
677 memcpy (juniper_iv
, base64_buf
, 12);
679 memcpy (out
, juniper_iv
, 12);
685 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
686 juniper_key
[1] = byte_swap_32 (0x8df91059);
687 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
688 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
692 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
693 u32
*out_ptr
= (u32
*) (out
+ 12);
695 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
698 void phpass_decode (u8 digest
[16], u8 buf
[22])
702 l
= itoa64_to_int (buf
[ 0]) << 0;
703 l
|= itoa64_to_int (buf
[ 1]) << 6;
704 l
|= itoa64_to_int (buf
[ 2]) << 12;
705 l
|= itoa64_to_int (buf
[ 3]) << 18;
707 digest
[ 0] = (l
>> 0) & 0xff;
708 digest
[ 1] = (l
>> 8) & 0xff;
709 digest
[ 2] = (l
>> 16) & 0xff;
711 l
= itoa64_to_int (buf
[ 4]) << 0;
712 l
|= itoa64_to_int (buf
[ 5]) << 6;
713 l
|= itoa64_to_int (buf
[ 6]) << 12;
714 l
|= itoa64_to_int (buf
[ 7]) << 18;
716 digest
[ 3] = (l
>> 0) & 0xff;
717 digest
[ 4] = (l
>> 8) & 0xff;
718 digest
[ 5] = (l
>> 16) & 0xff;
720 l
= itoa64_to_int (buf
[ 8]) << 0;
721 l
|= itoa64_to_int (buf
[ 9]) << 6;
722 l
|= itoa64_to_int (buf
[10]) << 12;
723 l
|= itoa64_to_int (buf
[11]) << 18;
725 digest
[ 6] = (l
>> 0) & 0xff;
726 digest
[ 7] = (l
>> 8) & 0xff;
727 digest
[ 8] = (l
>> 16) & 0xff;
729 l
= itoa64_to_int (buf
[12]) << 0;
730 l
|= itoa64_to_int (buf
[13]) << 6;
731 l
|= itoa64_to_int (buf
[14]) << 12;
732 l
|= itoa64_to_int (buf
[15]) << 18;
734 digest
[ 9] = (l
>> 0) & 0xff;
735 digest
[10] = (l
>> 8) & 0xff;
736 digest
[11] = (l
>> 16) & 0xff;
738 l
= itoa64_to_int (buf
[16]) << 0;
739 l
|= itoa64_to_int (buf
[17]) << 6;
740 l
|= itoa64_to_int (buf
[18]) << 12;
741 l
|= itoa64_to_int (buf
[19]) << 18;
743 digest
[12] = (l
>> 0) & 0xff;
744 digest
[13] = (l
>> 8) & 0xff;
745 digest
[14] = (l
>> 16) & 0xff;
747 l
= itoa64_to_int (buf
[20]) << 0;
748 l
|= itoa64_to_int (buf
[21]) << 6;
750 digest
[15] = (l
>> 0) & 0xff;
753 void phpass_encode (u8 digest
[16], u8 buf
[22])
757 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
759 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
760 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
761 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
762 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
764 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
766 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
767 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
768 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
769 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
771 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
773 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
774 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
775 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
776 buf
[11] = int_to_itoa64 (l
& 0x3f);
778 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
780 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
781 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
782 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
783 buf
[15] = int_to_itoa64 (l
& 0x3f);
785 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
787 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
788 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
789 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
790 buf
[19] = int_to_itoa64 (l
& 0x3f);
792 l
= (digest
[15] << 0);
794 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
795 buf
[21] = int_to_itoa64 (l
& 0x3f);
798 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
802 l
= itoa64_to_int (buf
[ 0]) << 0;
803 l
|= itoa64_to_int (buf
[ 1]) << 6;
804 l
|= itoa64_to_int (buf
[ 2]) << 12;
805 l
|= itoa64_to_int (buf
[ 3]) << 18;
807 digest
[ 0] = (l
>> 16) & 0xff;
808 digest
[ 6] = (l
>> 8) & 0xff;
809 digest
[12] = (l
>> 0) & 0xff;
811 l
= itoa64_to_int (buf
[ 4]) << 0;
812 l
|= itoa64_to_int (buf
[ 5]) << 6;
813 l
|= itoa64_to_int (buf
[ 6]) << 12;
814 l
|= itoa64_to_int (buf
[ 7]) << 18;
816 digest
[ 1] = (l
>> 16) & 0xff;
817 digest
[ 7] = (l
>> 8) & 0xff;
818 digest
[13] = (l
>> 0) & 0xff;
820 l
= itoa64_to_int (buf
[ 8]) << 0;
821 l
|= itoa64_to_int (buf
[ 9]) << 6;
822 l
|= itoa64_to_int (buf
[10]) << 12;
823 l
|= itoa64_to_int (buf
[11]) << 18;
825 digest
[ 2] = (l
>> 16) & 0xff;
826 digest
[ 8] = (l
>> 8) & 0xff;
827 digest
[14] = (l
>> 0) & 0xff;
829 l
= itoa64_to_int (buf
[12]) << 0;
830 l
|= itoa64_to_int (buf
[13]) << 6;
831 l
|= itoa64_to_int (buf
[14]) << 12;
832 l
|= itoa64_to_int (buf
[15]) << 18;
834 digest
[ 3] = (l
>> 16) & 0xff;
835 digest
[ 9] = (l
>> 8) & 0xff;
836 digest
[15] = (l
>> 0) & 0xff;
838 l
= itoa64_to_int (buf
[16]) << 0;
839 l
|= itoa64_to_int (buf
[17]) << 6;
840 l
|= itoa64_to_int (buf
[18]) << 12;
841 l
|= itoa64_to_int (buf
[19]) << 18;
843 digest
[ 4] = (l
>> 16) & 0xff;
844 digest
[10] = (l
>> 8) & 0xff;
845 digest
[ 5] = (l
>> 0) & 0xff;
847 l
= itoa64_to_int (buf
[20]) << 0;
848 l
|= itoa64_to_int (buf
[21]) << 6;
850 digest
[11] = (l
>> 0) & 0xff;
853 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
857 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
859 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
860 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
861 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
862 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
864 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
866 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
867 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
868 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
869 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
871 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
873 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
874 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
875 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
876 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
880 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
881 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
882 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
883 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
887 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
888 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
889 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
890 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 l
= (digest
[11] << 0);
894 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
895 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
898 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
902 l
= itoa64_to_int (buf
[ 0]) << 0;
903 l
|= itoa64_to_int (buf
[ 1]) << 6;
904 l
|= itoa64_to_int (buf
[ 2]) << 12;
905 l
|= itoa64_to_int (buf
[ 3]) << 18;
907 digest
[ 0] = (l
>> 16) & 0xff;
908 digest
[21] = (l
>> 8) & 0xff;
909 digest
[42] = (l
>> 0) & 0xff;
911 l
= itoa64_to_int (buf
[ 4]) << 0;
912 l
|= itoa64_to_int (buf
[ 5]) << 6;
913 l
|= itoa64_to_int (buf
[ 6]) << 12;
914 l
|= itoa64_to_int (buf
[ 7]) << 18;
916 digest
[22] = (l
>> 16) & 0xff;
917 digest
[43] = (l
>> 8) & 0xff;
918 digest
[ 1] = (l
>> 0) & 0xff;
920 l
= itoa64_to_int (buf
[ 8]) << 0;
921 l
|= itoa64_to_int (buf
[ 9]) << 6;
922 l
|= itoa64_to_int (buf
[10]) << 12;
923 l
|= itoa64_to_int (buf
[11]) << 18;
925 digest
[44] = (l
>> 16) & 0xff;
926 digest
[ 2] = (l
>> 8) & 0xff;
927 digest
[23] = (l
>> 0) & 0xff;
929 l
= itoa64_to_int (buf
[12]) << 0;
930 l
|= itoa64_to_int (buf
[13]) << 6;
931 l
|= itoa64_to_int (buf
[14]) << 12;
932 l
|= itoa64_to_int (buf
[15]) << 18;
934 digest
[ 3] = (l
>> 16) & 0xff;
935 digest
[24] = (l
>> 8) & 0xff;
936 digest
[45] = (l
>> 0) & 0xff;
938 l
= itoa64_to_int (buf
[16]) << 0;
939 l
|= itoa64_to_int (buf
[17]) << 6;
940 l
|= itoa64_to_int (buf
[18]) << 12;
941 l
|= itoa64_to_int (buf
[19]) << 18;
943 digest
[25] = (l
>> 16) & 0xff;
944 digest
[46] = (l
>> 8) & 0xff;
945 digest
[ 4] = (l
>> 0) & 0xff;
947 l
= itoa64_to_int (buf
[20]) << 0;
948 l
|= itoa64_to_int (buf
[21]) << 6;
949 l
|= itoa64_to_int (buf
[22]) << 12;
950 l
|= itoa64_to_int (buf
[23]) << 18;
952 digest
[47] = (l
>> 16) & 0xff;
953 digest
[ 5] = (l
>> 8) & 0xff;
954 digest
[26] = (l
>> 0) & 0xff;
956 l
= itoa64_to_int (buf
[24]) << 0;
957 l
|= itoa64_to_int (buf
[25]) << 6;
958 l
|= itoa64_to_int (buf
[26]) << 12;
959 l
|= itoa64_to_int (buf
[27]) << 18;
961 digest
[ 6] = (l
>> 16) & 0xff;
962 digest
[27] = (l
>> 8) & 0xff;
963 digest
[48] = (l
>> 0) & 0xff;
965 l
= itoa64_to_int (buf
[28]) << 0;
966 l
|= itoa64_to_int (buf
[29]) << 6;
967 l
|= itoa64_to_int (buf
[30]) << 12;
968 l
|= itoa64_to_int (buf
[31]) << 18;
970 digest
[28] = (l
>> 16) & 0xff;
971 digest
[49] = (l
>> 8) & 0xff;
972 digest
[ 7] = (l
>> 0) & 0xff;
974 l
= itoa64_to_int (buf
[32]) << 0;
975 l
|= itoa64_to_int (buf
[33]) << 6;
976 l
|= itoa64_to_int (buf
[34]) << 12;
977 l
|= itoa64_to_int (buf
[35]) << 18;
979 digest
[50] = (l
>> 16) & 0xff;
980 digest
[ 8] = (l
>> 8) & 0xff;
981 digest
[29] = (l
>> 0) & 0xff;
983 l
= itoa64_to_int (buf
[36]) << 0;
984 l
|= itoa64_to_int (buf
[37]) << 6;
985 l
|= itoa64_to_int (buf
[38]) << 12;
986 l
|= itoa64_to_int (buf
[39]) << 18;
988 digest
[ 9] = (l
>> 16) & 0xff;
989 digest
[30] = (l
>> 8) & 0xff;
990 digest
[51] = (l
>> 0) & 0xff;
992 l
= itoa64_to_int (buf
[40]) << 0;
993 l
|= itoa64_to_int (buf
[41]) << 6;
994 l
|= itoa64_to_int (buf
[42]) << 12;
995 l
|= itoa64_to_int (buf
[43]) << 18;
997 digest
[31] = (l
>> 16) & 0xff;
998 digest
[52] = (l
>> 8) & 0xff;
999 digest
[10] = (l
>> 0) & 0xff;
1001 l
= itoa64_to_int (buf
[44]) << 0;
1002 l
|= itoa64_to_int (buf
[45]) << 6;
1003 l
|= itoa64_to_int (buf
[46]) << 12;
1004 l
|= itoa64_to_int (buf
[47]) << 18;
1006 digest
[53] = (l
>> 16) & 0xff;
1007 digest
[11] = (l
>> 8) & 0xff;
1008 digest
[32] = (l
>> 0) & 0xff;
1010 l
= itoa64_to_int (buf
[48]) << 0;
1011 l
|= itoa64_to_int (buf
[49]) << 6;
1012 l
|= itoa64_to_int (buf
[50]) << 12;
1013 l
|= itoa64_to_int (buf
[51]) << 18;
1015 digest
[12] = (l
>> 16) & 0xff;
1016 digest
[33] = (l
>> 8) & 0xff;
1017 digest
[54] = (l
>> 0) & 0xff;
1019 l
= itoa64_to_int (buf
[52]) << 0;
1020 l
|= itoa64_to_int (buf
[53]) << 6;
1021 l
|= itoa64_to_int (buf
[54]) << 12;
1022 l
|= itoa64_to_int (buf
[55]) << 18;
1024 digest
[34] = (l
>> 16) & 0xff;
1025 digest
[55] = (l
>> 8) & 0xff;
1026 digest
[13] = (l
>> 0) & 0xff;
1028 l
= itoa64_to_int (buf
[56]) << 0;
1029 l
|= itoa64_to_int (buf
[57]) << 6;
1030 l
|= itoa64_to_int (buf
[58]) << 12;
1031 l
|= itoa64_to_int (buf
[59]) << 18;
1033 digest
[56] = (l
>> 16) & 0xff;
1034 digest
[14] = (l
>> 8) & 0xff;
1035 digest
[35] = (l
>> 0) & 0xff;
1037 l
= itoa64_to_int (buf
[60]) << 0;
1038 l
|= itoa64_to_int (buf
[61]) << 6;
1039 l
|= itoa64_to_int (buf
[62]) << 12;
1040 l
|= itoa64_to_int (buf
[63]) << 18;
1042 digest
[15] = (l
>> 16) & 0xff;
1043 digest
[36] = (l
>> 8) & 0xff;
1044 digest
[57] = (l
>> 0) & 0xff;
1046 l
= itoa64_to_int (buf
[64]) << 0;
1047 l
|= itoa64_to_int (buf
[65]) << 6;
1048 l
|= itoa64_to_int (buf
[66]) << 12;
1049 l
|= itoa64_to_int (buf
[67]) << 18;
1051 digest
[37] = (l
>> 16) & 0xff;
1052 digest
[58] = (l
>> 8) & 0xff;
1053 digest
[16] = (l
>> 0) & 0xff;
1055 l
= itoa64_to_int (buf
[68]) << 0;
1056 l
|= itoa64_to_int (buf
[69]) << 6;
1057 l
|= itoa64_to_int (buf
[70]) << 12;
1058 l
|= itoa64_to_int (buf
[71]) << 18;
1060 digest
[59] = (l
>> 16) & 0xff;
1061 digest
[17] = (l
>> 8) & 0xff;
1062 digest
[38] = (l
>> 0) & 0xff;
1064 l
= itoa64_to_int (buf
[72]) << 0;
1065 l
|= itoa64_to_int (buf
[73]) << 6;
1066 l
|= itoa64_to_int (buf
[74]) << 12;
1067 l
|= itoa64_to_int (buf
[75]) << 18;
1069 digest
[18] = (l
>> 16) & 0xff;
1070 digest
[39] = (l
>> 8) & 0xff;
1071 digest
[60] = (l
>> 0) & 0xff;
1073 l
= itoa64_to_int (buf
[76]) << 0;
1074 l
|= itoa64_to_int (buf
[77]) << 6;
1075 l
|= itoa64_to_int (buf
[78]) << 12;
1076 l
|= itoa64_to_int (buf
[79]) << 18;
1078 digest
[40] = (l
>> 16) & 0xff;
1079 digest
[61] = (l
>> 8) & 0xff;
1080 digest
[19] = (l
>> 0) & 0xff;
1082 l
= itoa64_to_int (buf
[80]) << 0;
1083 l
|= itoa64_to_int (buf
[81]) << 6;
1084 l
|= itoa64_to_int (buf
[82]) << 12;
1085 l
|= itoa64_to_int (buf
[83]) << 18;
1087 digest
[62] = (l
>> 16) & 0xff;
1088 digest
[20] = (l
>> 8) & 0xff;
1089 digest
[41] = (l
>> 0) & 0xff;
1091 l
= itoa64_to_int (buf
[84]) << 0;
1092 l
|= itoa64_to_int (buf
[85]) << 6;
1094 digest
[63] = (l
>> 0) & 0xff;
1097 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1101 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1103 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1104 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1105 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1106 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1108 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1110 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1111 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1112 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1113 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1115 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1117 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1118 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1119 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1120 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1124 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1125 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1126 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1127 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1131 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1132 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1133 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1134 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1138 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1139 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1140 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1141 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1145 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1146 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1147 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1148 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1152 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1153 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1154 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1155 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1159 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1160 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1161 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1162 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1166 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1167 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1168 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1169 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1173 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1174 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1175 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1176 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1180 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1181 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1182 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1183 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1187 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1188 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1189 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1190 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1194 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1195 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1196 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1197 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1201 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1202 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1203 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1204 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1208 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1209 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1210 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1211 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1215 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1216 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1217 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1218 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1222 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1223 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1224 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1225 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1229 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1230 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1231 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1232 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1236 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1237 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1238 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1239 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1243 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1244 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1245 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1246 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 l
= 0 | 0 | (digest
[63] << 0);
1250 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1251 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1254 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1258 l
= itoa64_to_int (buf
[ 0]) << 0;
1259 l
|= itoa64_to_int (buf
[ 1]) << 6;
1260 l
|= itoa64_to_int (buf
[ 2]) << 12;
1261 l
|= itoa64_to_int (buf
[ 3]) << 18;
1263 digest
[ 2] = (l
>> 0) & 0xff;
1264 digest
[ 1] = (l
>> 8) & 0xff;
1265 digest
[ 0] = (l
>> 16) & 0xff;
1267 l
= itoa64_to_int (buf
[ 4]) << 0;
1268 l
|= itoa64_to_int (buf
[ 5]) << 6;
1269 l
|= itoa64_to_int (buf
[ 6]) << 12;
1270 l
|= itoa64_to_int (buf
[ 7]) << 18;
1272 digest
[ 5] = (l
>> 0) & 0xff;
1273 digest
[ 4] = (l
>> 8) & 0xff;
1274 digest
[ 3] = (l
>> 16) & 0xff;
1276 l
= itoa64_to_int (buf
[ 8]) << 0;
1277 l
|= itoa64_to_int (buf
[ 9]) << 6;
1278 l
|= itoa64_to_int (buf
[10]) << 12;
1279 l
|= itoa64_to_int (buf
[11]) << 18;
1281 digest
[ 8] = (l
>> 0) & 0xff;
1282 digest
[ 7] = (l
>> 8) & 0xff;
1283 digest
[ 6] = (l
>> 16) & 0xff;
1285 l
= itoa64_to_int (buf
[12]) << 0;
1286 l
|= itoa64_to_int (buf
[13]) << 6;
1287 l
|= itoa64_to_int (buf
[14]) << 12;
1288 l
|= itoa64_to_int (buf
[15]) << 18;
1290 digest
[11] = (l
>> 0) & 0xff;
1291 digest
[10] = (l
>> 8) & 0xff;
1292 digest
[ 9] = (l
>> 16) & 0xff;
1294 l
= itoa64_to_int (buf
[16]) << 0;
1295 l
|= itoa64_to_int (buf
[17]) << 6;
1296 l
|= itoa64_to_int (buf
[18]) << 12;
1297 l
|= itoa64_to_int (buf
[19]) << 18;
1299 digest
[14] = (l
>> 0) & 0xff;
1300 digest
[13] = (l
>> 8) & 0xff;
1301 digest
[12] = (l
>> 16) & 0xff;
1303 l
= itoa64_to_int (buf
[20]) << 0;
1304 l
|= itoa64_to_int (buf
[21]) << 6;
1305 l
|= itoa64_to_int (buf
[22]) << 12;
1306 l
|= itoa64_to_int (buf
[23]) << 18;
1308 digest
[17] = (l
>> 0) & 0xff;
1309 digest
[16] = (l
>> 8) & 0xff;
1310 digest
[15] = (l
>> 16) & 0xff;
1312 l
= itoa64_to_int (buf
[24]) << 0;
1313 l
|= itoa64_to_int (buf
[25]) << 6;
1314 l
|= itoa64_to_int (buf
[26]) << 12;
1316 digest
[19] = (l
>> 8) & 0xff;
1317 digest
[18] = (l
>> 16) & 0xff;
1320 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1324 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1326 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1327 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1328 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1329 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1331 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1333 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1334 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1335 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1336 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1338 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1340 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1341 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1342 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1343 buf
[11] = int_to_itoa64 (l
& 0x3f);
1345 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1347 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1348 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1349 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1350 buf
[15] = int_to_itoa64 (l
& 0x3f);
1352 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1354 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1355 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1356 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1357 buf
[19] = int_to_itoa64 (l
& 0x3f);
1359 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1361 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1362 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1363 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1364 buf
[23] = int_to_itoa64 (l
& 0x3f);
1366 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1368 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1369 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1370 buf
[26] = int_to_itoa64 (l
& 0x3f);
1373 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1377 l
= itoa64_to_int (buf
[ 0]) << 0;
1378 l
|= itoa64_to_int (buf
[ 1]) << 6;
1379 l
|= itoa64_to_int (buf
[ 2]) << 12;
1380 l
|= itoa64_to_int (buf
[ 3]) << 18;
1382 digest
[ 2] = (l
>> 0) & 0xff;
1383 digest
[ 1] = (l
>> 8) & 0xff;
1384 digest
[ 0] = (l
>> 16) & 0xff;
1386 l
= itoa64_to_int (buf
[ 4]) << 0;
1387 l
|= itoa64_to_int (buf
[ 5]) << 6;
1388 l
|= itoa64_to_int (buf
[ 6]) << 12;
1389 l
|= itoa64_to_int (buf
[ 7]) << 18;
1391 digest
[ 5] = (l
>> 0) & 0xff;
1392 digest
[ 4] = (l
>> 8) & 0xff;
1393 digest
[ 3] = (l
>> 16) & 0xff;
1395 l
= itoa64_to_int (buf
[ 8]) << 0;
1396 l
|= itoa64_to_int (buf
[ 9]) << 6;
1397 l
|= itoa64_to_int (buf
[10]) << 12;
1398 l
|= itoa64_to_int (buf
[11]) << 18;
1400 digest
[ 8] = (l
>> 0) & 0xff;
1401 digest
[ 7] = (l
>> 8) & 0xff;
1402 digest
[ 6] = (l
>> 16) & 0xff;
1404 l
= itoa64_to_int (buf
[12]) << 0;
1405 l
|= itoa64_to_int (buf
[13]) << 6;
1406 l
|= itoa64_to_int (buf
[14]) << 12;
1407 l
|= itoa64_to_int (buf
[15]) << 18;
1409 digest
[11] = (l
>> 0) & 0xff;
1410 digest
[10] = (l
>> 8) & 0xff;
1411 digest
[ 9] = (l
>> 16) & 0xff;
1413 l
= itoa64_to_int (buf
[16]) << 0;
1414 l
|= itoa64_to_int (buf
[17]) << 6;
1415 l
|= itoa64_to_int (buf
[18]) << 12;
1416 l
|= itoa64_to_int (buf
[19]) << 18;
1418 digest
[14] = (l
>> 0) & 0xff;
1419 digest
[13] = (l
>> 8) & 0xff;
1420 digest
[12] = (l
>> 16) & 0xff;
1422 l
= itoa64_to_int (buf
[20]) << 0;
1423 l
|= itoa64_to_int (buf
[21]) << 6;
1424 l
|= itoa64_to_int (buf
[22]) << 12;
1425 l
|= itoa64_to_int (buf
[23]) << 18;
1427 digest
[17] = (l
>> 0) & 0xff;
1428 digest
[16] = (l
>> 8) & 0xff;
1429 digest
[15] = (l
>> 16) & 0xff;
1431 l
= itoa64_to_int (buf
[24]) << 0;
1432 l
|= itoa64_to_int (buf
[25]) << 6;
1433 l
|= itoa64_to_int (buf
[26]) << 12;
1434 l
|= itoa64_to_int (buf
[27]) << 18;
1436 digest
[20] = (l
>> 0) & 0xff;
1437 digest
[19] = (l
>> 8) & 0xff;
1438 digest
[18] = (l
>> 16) & 0xff;
1440 l
= itoa64_to_int (buf
[28]) << 0;
1441 l
|= itoa64_to_int (buf
[29]) << 6;
1442 l
|= itoa64_to_int (buf
[30]) << 12;
1443 l
|= itoa64_to_int (buf
[31]) << 18;
1445 digest
[23] = (l
>> 0) & 0xff;
1446 digest
[22] = (l
>> 8) & 0xff;
1447 digest
[21] = (l
>> 16) & 0xff;
1449 l
= itoa64_to_int (buf
[32]) << 0;
1450 l
|= itoa64_to_int (buf
[33]) << 6;
1451 l
|= itoa64_to_int (buf
[34]) << 12;
1452 l
|= itoa64_to_int (buf
[35]) << 18;
1454 digest
[26] = (l
>> 0) & 0xff;
1455 digest
[25] = (l
>> 8) & 0xff;
1456 digest
[24] = (l
>> 16) & 0xff;
1458 l
= itoa64_to_int (buf
[36]) << 0;
1459 l
|= itoa64_to_int (buf
[37]) << 6;
1460 l
|= itoa64_to_int (buf
[38]) << 12;
1461 l
|= itoa64_to_int (buf
[39]) << 18;
1463 digest
[29] = (l
>> 0) & 0xff;
1464 digest
[28] = (l
>> 8) & 0xff;
1465 digest
[27] = (l
>> 16) & 0xff;
1467 l
= itoa64_to_int (buf
[40]) << 0;
1468 l
|= itoa64_to_int (buf
[41]) << 6;
1469 l
|= itoa64_to_int (buf
[42]) << 12;
1471 //digest[32] = (l >> 0) & 0xff;
1472 digest
[31] = (l
>> 8) & 0xff;
1473 digest
[30] = (l
>> 16) & 0xff;
1476 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1480 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1482 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1483 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1484 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1485 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1487 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1489 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1490 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1491 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1492 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1494 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1496 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1497 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1498 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1499 buf
[11] = int_to_itoa64 (l
& 0x3f);
1501 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1503 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1504 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1505 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1506 buf
[15] = int_to_itoa64 (l
& 0x3f);
1508 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1510 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1511 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1512 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1513 buf
[19] = int_to_itoa64 (l
& 0x3f);
1515 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1517 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1518 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1519 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1520 buf
[23] = int_to_itoa64 (l
& 0x3f);
1522 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1524 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1525 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1526 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1527 buf
[27] = int_to_itoa64 (l
& 0x3f);
1529 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1531 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1532 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1533 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1534 buf
[31] = int_to_itoa64 (l
& 0x3f);
1536 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1538 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1539 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1540 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1541 buf
[35] = int_to_itoa64 (l
& 0x3f);
1543 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1545 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1546 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1547 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1548 buf
[39] = int_to_itoa64 (l
& 0x3f);
1550 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1552 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1553 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1554 buf
[42] = int_to_itoa64 (l
& 0x3f);
1557 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1561 l
= itoa64_to_int (buf
[ 0]) << 0;
1562 l
|= itoa64_to_int (buf
[ 1]) << 6;
1563 l
|= itoa64_to_int (buf
[ 2]) << 12;
1564 l
|= itoa64_to_int (buf
[ 3]) << 18;
1566 digest
[ 2] = (l
>> 0) & 0xff;
1567 digest
[ 1] = (l
>> 8) & 0xff;
1568 digest
[ 0] = (l
>> 16) & 0xff;
1570 l
= itoa64_to_int (buf
[ 4]) << 0;
1571 l
|= itoa64_to_int (buf
[ 5]) << 6;
1572 l
|= itoa64_to_int (buf
[ 6]) << 12;
1573 l
|= itoa64_to_int (buf
[ 7]) << 18;
1575 digest
[ 5] = (l
>> 0) & 0xff;
1576 digest
[ 4] = (l
>> 8) & 0xff;
1577 digest
[ 3] = (l
>> 16) & 0xff;
1579 l
= itoa64_to_int (buf
[ 8]) << 0;
1580 l
|= itoa64_to_int (buf
[ 9]) << 6;
1581 l
|= itoa64_to_int (buf
[10]) << 12;
1582 l
|= itoa64_to_int (buf
[11]) << 18;
1584 digest
[ 8] = (l
>> 0) & 0xff;
1585 digest
[ 7] = (l
>> 8) & 0xff;
1586 digest
[ 6] = (l
>> 16) & 0xff;
1588 l
= itoa64_to_int (buf
[12]) << 0;
1589 l
|= itoa64_to_int (buf
[13]) << 6;
1590 l
|= itoa64_to_int (buf
[14]) << 12;
1591 l
|= itoa64_to_int (buf
[15]) << 18;
1593 digest
[11] = (l
>> 0) & 0xff;
1594 digest
[10] = (l
>> 8) & 0xff;
1595 digest
[ 9] = (l
>> 16) & 0xff;
1597 l
= itoa64_to_int (buf
[16]) << 0;
1598 l
|= itoa64_to_int (buf
[17]) << 6;
1599 l
|= itoa64_to_int (buf
[18]) << 12;
1600 l
|= itoa64_to_int (buf
[19]) << 18;
1602 digest
[14] = (l
>> 0) & 0xff;
1603 digest
[13] = (l
>> 8) & 0xff;
1604 digest
[12] = (l
>> 16) & 0xff;
1606 l
= itoa64_to_int (buf
[20]) << 0;
1607 l
|= itoa64_to_int (buf
[21]) << 6;
1608 l
|= itoa64_to_int (buf
[22]) << 12;
1609 l
|= itoa64_to_int (buf
[23]) << 18;
1611 digest
[17] = (l
>> 0) & 0xff;
1612 digest
[16] = (l
>> 8) & 0xff;
1613 digest
[15] = (l
>> 16) & 0xff;
1615 l
= itoa64_to_int (buf
[24]) << 0;
1616 l
|= itoa64_to_int (buf
[25]) << 6;
1617 l
|= itoa64_to_int (buf
[26]) << 12;
1618 l
|= itoa64_to_int (buf
[27]) << 18;
1620 digest
[20] = (l
>> 0) & 0xff;
1621 digest
[19] = (l
>> 8) & 0xff;
1622 digest
[18] = (l
>> 16) & 0xff;
1624 l
= itoa64_to_int (buf
[28]) << 0;
1625 l
|= itoa64_to_int (buf
[29]) << 6;
1626 l
|= itoa64_to_int (buf
[30]) << 12;
1627 l
|= itoa64_to_int (buf
[31]) << 18;
1629 digest
[23] = (l
>> 0) & 0xff;
1630 digest
[22] = (l
>> 8) & 0xff;
1631 digest
[21] = (l
>> 16) & 0xff;
1633 l
= itoa64_to_int (buf
[32]) << 0;
1634 l
|= itoa64_to_int (buf
[33]) << 6;
1635 l
|= itoa64_to_int (buf
[34]) << 12;
1636 l
|= itoa64_to_int (buf
[35]) << 18;
1638 digest
[26] = (l
>> 0) & 0xff;
1639 digest
[25] = (l
>> 8) & 0xff;
1640 digest
[24] = (l
>> 16) & 0xff;
1642 l
= itoa64_to_int (buf
[36]) << 0;
1643 l
|= itoa64_to_int (buf
[37]) << 6;
1644 l
|= itoa64_to_int (buf
[38]) << 12;
1645 l
|= itoa64_to_int (buf
[39]) << 18;
1647 digest
[29] = (l
>> 0) & 0xff;
1648 digest
[28] = (l
>> 8) & 0xff;
1649 digest
[27] = (l
>> 16) & 0xff;
1651 l
= itoa64_to_int (buf
[40]) << 0;
1652 l
|= itoa64_to_int (buf
[41]) << 6;
1653 l
|= itoa64_to_int (buf
[42]) << 12;
1654 l
|= itoa64_to_int (buf
[43]) << 18;
1656 digest
[32] = (l
>> 0) & 0xff;
1657 digest
[31] = (l
>> 8) & 0xff;
1658 digest
[30] = (l
>> 16) & 0xff;
1660 l
= itoa64_to_int (buf
[44]) << 0;
1661 l
|= itoa64_to_int (buf
[45]) << 6;
1662 l
|= itoa64_to_int (buf
[46]) << 12;
1663 l
|= itoa64_to_int (buf
[47]) << 18;
1665 digest
[35] = (l
>> 0) & 0xff;
1666 digest
[34] = (l
>> 8) & 0xff;
1667 digest
[33] = (l
>> 16) & 0xff;
1669 l
= itoa64_to_int (buf
[48]) << 0;
1670 l
|= itoa64_to_int (buf
[49]) << 6;
1671 l
|= itoa64_to_int (buf
[50]) << 12;
1672 l
|= itoa64_to_int (buf
[51]) << 18;
1674 digest
[38] = (l
>> 0) & 0xff;
1675 digest
[37] = (l
>> 8) & 0xff;
1676 digest
[36] = (l
>> 16) & 0xff;
1678 l
= itoa64_to_int (buf
[52]) << 0;
1679 l
|= itoa64_to_int (buf
[53]) << 6;
1680 l
|= itoa64_to_int (buf
[54]) << 12;
1681 l
|= itoa64_to_int (buf
[55]) << 18;
1683 digest
[41] = (l
>> 0) & 0xff;
1684 digest
[40] = (l
>> 8) & 0xff;
1685 digest
[39] = (l
>> 16) & 0xff;
1687 l
= itoa64_to_int (buf
[56]) << 0;
1688 l
|= itoa64_to_int (buf
[57]) << 6;
1689 l
|= itoa64_to_int (buf
[58]) << 12;
1690 l
|= itoa64_to_int (buf
[59]) << 18;
1692 digest
[44] = (l
>> 0) & 0xff;
1693 digest
[43] = (l
>> 8) & 0xff;
1694 digest
[42] = (l
>> 16) & 0xff;
1696 l
= itoa64_to_int (buf
[60]) << 0;
1697 l
|= itoa64_to_int (buf
[61]) << 6;
1698 l
|= itoa64_to_int (buf
[62]) << 12;
1699 l
|= itoa64_to_int (buf
[63]) << 18;
1701 digest
[47] = (l
>> 0) & 0xff;
1702 digest
[46] = (l
>> 8) & 0xff;
1703 digest
[45] = (l
>> 16) & 0xff;
1705 l
= itoa64_to_int (buf
[64]) << 0;
1706 l
|= itoa64_to_int (buf
[65]) << 6;
1707 l
|= itoa64_to_int (buf
[66]) << 12;
1708 l
|= itoa64_to_int (buf
[67]) << 18;
1710 digest
[50] = (l
>> 0) & 0xff;
1711 digest
[49] = (l
>> 8) & 0xff;
1712 digest
[48] = (l
>> 16) & 0xff;
1714 l
= itoa64_to_int (buf
[68]) << 0;
1715 l
|= itoa64_to_int (buf
[69]) << 6;
1716 l
|= itoa64_to_int (buf
[70]) << 12;
1717 l
|= itoa64_to_int (buf
[71]) << 18;
1719 digest
[53] = (l
>> 0) & 0xff;
1720 digest
[52] = (l
>> 8) & 0xff;
1721 digest
[51] = (l
>> 16) & 0xff;
1723 l
= itoa64_to_int (buf
[72]) << 0;
1724 l
|= itoa64_to_int (buf
[73]) << 6;
1725 l
|= itoa64_to_int (buf
[74]) << 12;
1726 l
|= itoa64_to_int (buf
[75]) << 18;
1728 digest
[56] = (l
>> 0) & 0xff;
1729 digest
[55] = (l
>> 8) & 0xff;
1730 digest
[54] = (l
>> 16) & 0xff;
1732 l
= itoa64_to_int (buf
[76]) << 0;
1733 l
|= itoa64_to_int (buf
[77]) << 6;
1734 l
|= itoa64_to_int (buf
[78]) << 12;
1735 l
|= itoa64_to_int (buf
[79]) << 18;
1737 digest
[59] = (l
>> 0) & 0xff;
1738 digest
[58] = (l
>> 8) & 0xff;
1739 digest
[57] = (l
>> 16) & 0xff;
1741 l
= itoa64_to_int (buf
[80]) << 0;
1742 l
|= itoa64_to_int (buf
[81]) << 6;
1743 l
|= itoa64_to_int (buf
[82]) << 12;
1744 l
|= itoa64_to_int (buf
[83]) << 18;
1746 digest
[62] = (l
>> 0) & 0xff;
1747 digest
[61] = (l
>> 8) & 0xff;
1748 digest
[60] = (l
>> 16) & 0xff;
1750 l
= itoa64_to_int (buf
[84]) << 0;
1751 l
|= itoa64_to_int (buf
[85]) << 6;
1753 digest
[63] = (l
>> 16) & 0xff;
1756 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1760 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1762 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1763 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1764 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1765 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1767 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1769 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1770 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1771 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1772 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1774 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1776 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1777 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1778 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1779 buf
[11] = int_to_itoa64 (l
& 0x3f);
1781 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1783 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1784 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1785 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1786 buf
[15] = int_to_itoa64 (l
& 0x3f);
1788 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1790 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1791 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1792 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1793 buf
[19] = int_to_itoa64 (l
& 0x3f);
1795 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1797 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1798 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1799 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1800 buf
[23] = int_to_itoa64 (l
& 0x3f);
1802 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1804 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1805 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1806 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1807 buf
[27] = int_to_itoa64 (l
& 0x3f);
1809 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1811 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1812 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1813 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1814 buf
[31] = int_to_itoa64 (l
& 0x3f);
1816 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1818 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1819 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1820 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1821 buf
[35] = int_to_itoa64 (l
& 0x3f);
1823 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1825 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1826 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1827 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1828 buf
[39] = int_to_itoa64 (l
& 0x3f);
1830 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1832 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1833 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1834 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1835 buf
[43] = int_to_itoa64 (l
& 0x3f);
1837 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1839 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1840 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1841 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1842 buf
[47] = int_to_itoa64 (l
& 0x3f);
1844 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1846 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1847 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1848 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1849 buf
[51] = int_to_itoa64 (l
& 0x3f);
1851 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1853 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1854 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1855 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1856 buf
[55] = int_to_itoa64 (l
& 0x3f);
1858 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1860 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1861 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1862 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1863 buf
[59] = int_to_itoa64 (l
& 0x3f);
1865 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1867 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1868 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1869 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1870 buf
[63] = int_to_itoa64 (l
& 0x3f);
1872 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1874 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1875 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1876 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1877 buf
[67] = int_to_itoa64 (l
& 0x3f);
1879 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1881 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1882 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1883 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1884 buf
[71] = int_to_itoa64 (l
& 0x3f);
1886 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1888 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1889 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1890 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1891 buf
[75] = int_to_itoa64 (l
& 0x3f);
1893 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1895 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1896 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1897 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1898 buf
[79] = int_to_itoa64 (l
& 0x3f);
1900 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1902 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1903 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1904 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1905 buf
[83] = int_to_itoa64 (l
& 0x3f);
1907 l
= 0 | 0 | (digest
[63] << 16);
1909 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1910 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1913 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1917 l
= itoa64_to_int (buf
[ 0]) << 0;
1918 l
|= itoa64_to_int (buf
[ 1]) << 6;
1919 l
|= itoa64_to_int (buf
[ 2]) << 12;
1920 l
|= itoa64_to_int (buf
[ 3]) << 18;
1922 digest
[ 0] = (l
>> 16) & 0xff;
1923 digest
[10] = (l
>> 8) & 0xff;
1924 digest
[20] = (l
>> 0) & 0xff;
1926 l
= itoa64_to_int (buf
[ 4]) << 0;
1927 l
|= itoa64_to_int (buf
[ 5]) << 6;
1928 l
|= itoa64_to_int (buf
[ 6]) << 12;
1929 l
|= itoa64_to_int (buf
[ 7]) << 18;
1931 digest
[21] = (l
>> 16) & 0xff;
1932 digest
[ 1] = (l
>> 8) & 0xff;
1933 digest
[11] = (l
>> 0) & 0xff;
1935 l
= itoa64_to_int (buf
[ 8]) << 0;
1936 l
|= itoa64_to_int (buf
[ 9]) << 6;
1937 l
|= itoa64_to_int (buf
[10]) << 12;
1938 l
|= itoa64_to_int (buf
[11]) << 18;
1940 digest
[12] = (l
>> 16) & 0xff;
1941 digest
[22] = (l
>> 8) & 0xff;
1942 digest
[ 2] = (l
>> 0) & 0xff;
1944 l
= itoa64_to_int (buf
[12]) << 0;
1945 l
|= itoa64_to_int (buf
[13]) << 6;
1946 l
|= itoa64_to_int (buf
[14]) << 12;
1947 l
|= itoa64_to_int (buf
[15]) << 18;
1949 digest
[ 3] = (l
>> 16) & 0xff;
1950 digest
[13] = (l
>> 8) & 0xff;
1951 digest
[23] = (l
>> 0) & 0xff;
1953 l
= itoa64_to_int (buf
[16]) << 0;
1954 l
|= itoa64_to_int (buf
[17]) << 6;
1955 l
|= itoa64_to_int (buf
[18]) << 12;
1956 l
|= itoa64_to_int (buf
[19]) << 18;
1958 digest
[24] = (l
>> 16) & 0xff;
1959 digest
[ 4] = (l
>> 8) & 0xff;
1960 digest
[14] = (l
>> 0) & 0xff;
1962 l
= itoa64_to_int (buf
[20]) << 0;
1963 l
|= itoa64_to_int (buf
[21]) << 6;
1964 l
|= itoa64_to_int (buf
[22]) << 12;
1965 l
|= itoa64_to_int (buf
[23]) << 18;
1967 digest
[15] = (l
>> 16) & 0xff;
1968 digest
[25] = (l
>> 8) & 0xff;
1969 digest
[ 5] = (l
>> 0) & 0xff;
1971 l
= itoa64_to_int (buf
[24]) << 0;
1972 l
|= itoa64_to_int (buf
[25]) << 6;
1973 l
|= itoa64_to_int (buf
[26]) << 12;
1974 l
|= itoa64_to_int (buf
[27]) << 18;
1976 digest
[ 6] = (l
>> 16) & 0xff;
1977 digest
[16] = (l
>> 8) & 0xff;
1978 digest
[26] = (l
>> 0) & 0xff;
1980 l
= itoa64_to_int (buf
[28]) << 0;
1981 l
|= itoa64_to_int (buf
[29]) << 6;
1982 l
|= itoa64_to_int (buf
[30]) << 12;
1983 l
|= itoa64_to_int (buf
[31]) << 18;
1985 digest
[27] = (l
>> 16) & 0xff;
1986 digest
[ 7] = (l
>> 8) & 0xff;
1987 digest
[17] = (l
>> 0) & 0xff;
1989 l
= itoa64_to_int (buf
[32]) << 0;
1990 l
|= itoa64_to_int (buf
[33]) << 6;
1991 l
|= itoa64_to_int (buf
[34]) << 12;
1992 l
|= itoa64_to_int (buf
[35]) << 18;
1994 digest
[18] = (l
>> 16) & 0xff;
1995 digest
[28] = (l
>> 8) & 0xff;
1996 digest
[ 8] = (l
>> 0) & 0xff;
1998 l
= itoa64_to_int (buf
[36]) << 0;
1999 l
|= itoa64_to_int (buf
[37]) << 6;
2000 l
|= itoa64_to_int (buf
[38]) << 12;
2001 l
|= itoa64_to_int (buf
[39]) << 18;
2003 digest
[ 9] = (l
>> 16) & 0xff;
2004 digest
[19] = (l
>> 8) & 0xff;
2005 digest
[29] = (l
>> 0) & 0xff;
2007 l
= itoa64_to_int (buf
[40]) << 0;
2008 l
|= itoa64_to_int (buf
[41]) << 6;
2009 l
|= itoa64_to_int (buf
[42]) << 12;
2011 digest
[31] = (l
>> 8) & 0xff;
2012 digest
[30] = (l
>> 0) & 0xff;
2015 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2019 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2021 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2022 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2023 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2024 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2026 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2028 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2029 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2030 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2031 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2033 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2035 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2036 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2037 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2038 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2042 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2043 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2044 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2045 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2049 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2050 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2051 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2052 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2056 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2057 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2058 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2059 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2063 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2064 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2065 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2066 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2070 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2071 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2072 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2073 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2077 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2078 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2079 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2080 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2084 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2085 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2086 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2087 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2091 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2092 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2093 buf
[42] = int_to_itoa64 (l
& 0x3f);
2096 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2100 l
= itoa64_to_int (buf
[ 0]) << 0;
2101 l
|= itoa64_to_int (buf
[ 1]) << 6;
2102 l
|= itoa64_to_int (buf
[ 2]) << 12;
2103 l
|= itoa64_to_int (buf
[ 3]) << 18;
2105 digest
[ 0] = (l
>> 0) & 0xff;
2106 digest
[ 1] = (l
>> 8) & 0xff;
2107 digest
[ 2] = (l
>> 16) & 0xff;
2109 l
= itoa64_to_int (buf
[ 4]) << 0;
2110 l
|= itoa64_to_int (buf
[ 5]) << 6;
2111 l
|= itoa64_to_int (buf
[ 6]) << 12;
2112 l
|= itoa64_to_int (buf
[ 7]) << 18;
2114 digest
[ 3] = (l
>> 0) & 0xff;
2115 digest
[ 4] = (l
>> 8) & 0xff;
2116 digest
[ 5] = (l
>> 16) & 0xff;
2118 l
= itoa64_to_int (buf
[ 8]) << 0;
2119 l
|= itoa64_to_int (buf
[ 9]) << 6;
2120 l
|= itoa64_to_int (buf
[10]) << 12;
2121 l
|= itoa64_to_int (buf
[11]) << 18;
2123 digest
[ 6] = (l
>> 0) & 0xff;
2124 digest
[ 7] = (l
>> 8) & 0xff;
2125 digest
[ 8] = (l
>> 16) & 0xff;
2127 l
= itoa64_to_int (buf
[12]) << 0;
2128 l
|= itoa64_to_int (buf
[13]) << 6;
2129 l
|= itoa64_to_int (buf
[14]) << 12;
2130 l
|= itoa64_to_int (buf
[15]) << 18;
2132 digest
[ 9] = (l
>> 0) & 0xff;
2133 digest
[10] = (l
>> 8) & 0xff;
2134 digest
[11] = (l
>> 16) & 0xff;
2136 l
= itoa64_to_int (buf
[16]) << 0;
2137 l
|= itoa64_to_int (buf
[17]) << 6;
2138 l
|= itoa64_to_int (buf
[18]) << 12;
2139 l
|= itoa64_to_int (buf
[19]) << 18;
2141 digest
[12] = (l
>> 0) & 0xff;
2142 digest
[13] = (l
>> 8) & 0xff;
2143 digest
[14] = (l
>> 16) & 0xff;
2145 l
= itoa64_to_int (buf
[20]) << 0;
2146 l
|= itoa64_to_int (buf
[21]) << 6;
2147 l
|= itoa64_to_int (buf
[22]) << 12;
2148 l
|= itoa64_to_int (buf
[23]) << 18;
2150 digest
[15] = (l
>> 0) & 0xff;
2151 digest
[16] = (l
>> 8) & 0xff;
2152 digest
[17] = (l
>> 16) & 0xff;
2154 l
= itoa64_to_int (buf
[24]) << 0;
2155 l
|= itoa64_to_int (buf
[25]) << 6;
2156 l
|= itoa64_to_int (buf
[26]) << 12;
2157 l
|= itoa64_to_int (buf
[27]) << 18;
2159 digest
[18] = (l
>> 0) & 0xff;
2160 digest
[19] = (l
>> 8) & 0xff;
2161 digest
[20] = (l
>> 16) & 0xff;
2163 l
= itoa64_to_int (buf
[28]) << 0;
2164 l
|= itoa64_to_int (buf
[29]) << 6;
2165 l
|= itoa64_to_int (buf
[30]) << 12;
2166 l
|= itoa64_to_int (buf
[31]) << 18;
2168 digest
[21] = (l
>> 0) & 0xff;
2169 digest
[22] = (l
>> 8) & 0xff;
2170 digest
[23] = (l
>> 16) & 0xff;
2172 l
= itoa64_to_int (buf
[32]) << 0;
2173 l
|= itoa64_to_int (buf
[33]) << 6;
2174 l
|= itoa64_to_int (buf
[34]) << 12;
2175 l
|= itoa64_to_int (buf
[35]) << 18;
2177 digest
[24] = (l
>> 0) & 0xff;
2178 digest
[25] = (l
>> 8) & 0xff;
2179 digest
[26] = (l
>> 16) & 0xff;
2181 l
= itoa64_to_int (buf
[36]) << 0;
2182 l
|= itoa64_to_int (buf
[37]) << 6;
2183 l
|= itoa64_to_int (buf
[38]) << 12;
2184 l
|= itoa64_to_int (buf
[39]) << 18;
2186 digest
[27] = (l
>> 0) & 0xff;
2187 digest
[28] = (l
>> 8) & 0xff;
2188 digest
[29] = (l
>> 16) & 0xff;
2190 l
= itoa64_to_int (buf
[40]) << 0;
2191 l
|= itoa64_to_int (buf
[41]) << 6;
2192 l
|= itoa64_to_int (buf
[42]) << 12;
2193 l
|= itoa64_to_int (buf
[43]) << 18;
2195 digest
[30] = (l
>> 0) & 0xff;
2196 digest
[31] = (l
>> 8) & 0xff;
2197 digest
[32] = (l
>> 16) & 0xff;
2232 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2236 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2238 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2239 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2240 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2241 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2243 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2245 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2246 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2247 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2248 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2250 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2252 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2253 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2254 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2255 buf
[11] = int_to_itoa64 (l
& 0x3f);
2257 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2259 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2260 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2261 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2262 buf
[15] = int_to_itoa64 (l
& 0x3f);
2264 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2266 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2267 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2268 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2269 buf
[19] = int_to_itoa64 (l
& 0x3f);
2271 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2273 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2274 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2275 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2276 buf
[23] = int_to_itoa64 (l
& 0x3f);
2278 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2280 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2281 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2282 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2283 buf
[27] = int_to_itoa64 (l
& 0x3f);
2285 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2287 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2288 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2289 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2290 buf
[31] = int_to_itoa64 (l
& 0x3f);
2292 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2294 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2295 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2296 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2297 buf
[35] = int_to_itoa64 (l
& 0x3f);
2299 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2301 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2302 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2303 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2304 buf
[39] = int_to_itoa64 (l
& 0x3f);
2306 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2308 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2309 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2310 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2311 //buf[43] = int_to_itoa64 (l & 0x3f);
2319 static struct termio savemodes
;
2320 static int havemodes
= 0;
2324 struct termio modmodes
;
2326 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2330 modmodes
= savemodes
;
2331 modmodes
.c_lflag
&= ~ICANON
;
2332 modmodes
.c_cc
[VMIN
] = 1;
2333 modmodes
.c_cc
[VTIME
] = 0;
2335 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2344 FD_SET (fileno (stdin
), &rfds
);
2351 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2353 if (retval
== 0) return 0;
2354 if (retval
== -1) return -1;
2361 if (!havemodes
) return 0;
2363 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2368 static struct termios savemodes
;
2369 static int havemodes
= 0;
2373 struct termios modmodes
;
2375 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2379 modmodes
= savemodes
;
2380 modmodes
.c_lflag
&= ~ICANON
;
2381 modmodes
.c_cc
[VMIN
] = 1;
2382 modmodes
.c_cc
[VTIME
] = 0;
2384 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2393 FD_SET (fileno (stdin
), &rfds
);
2400 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2402 if (retval
== 0) return 0;
2403 if (retval
== -1) return -1;
2410 if (!havemodes
) return 0;
2412 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2417 static DWORD saveMode
= 0;
2421 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2423 GetConsoleMode (stdinHandle
, &saveMode
);
2424 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2431 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2433 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2435 if (rc
== WAIT_TIMEOUT
) return 0;
2436 if (rc
== WAIT_ABANDONED
) return -1;
2437 if (rc
== WAIT_FAILED
) return -1;
2439 // The whole ReadConsoleInput () part is a workaround.
2440 // For some unknown reason, maybe a mingw bug, a random signal
2441 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2442 // Then it wants to read with getche () a keyboard input
2443 // which has never been made.
2445 INPUT_RECORD buf
[100];
2449 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2451 FlushConsoleInputBuffer (stdinHandle
);
2453 for (uint i
= 0; i
< num
; i
++)
2455 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2457 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2459 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2461 return KeyEvent
.uChar
.AsciiChar
;
2469 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2471 SetConsoleMode (stdinHandle
, saveMode
);
2481 #define MSG_ENOMEM "Insufficient memory available"
2483 void *mycalloc (size_t nmemb
, size_t size
)
2485 void *p
= calloc (nmemb
, size
);
2489 log_error ("ERROR: %s", MSG_ENOMEM
);
2497 void *mymalloc (size_t size
)
2499 void *p
= malloc (size
);
2503 log_error ("ERROR: %s", MSG_ENOMEM
);
2508 memset (p
, 0, size
);
2513 void myfree (void *ptr
)
2515 if (ptr
== NULL
) return;
2520 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2522 void *p
= realloc (ptr
, oldsz
+ add
);
2526 log_error ("ERROR: %s", MSG_ENOMEM
);
2531 memset ((char *) p
+ oldsz
, 0, add
);
2536 char *mystrdup (const char *s
)
2538 const size_t len
= strlen (s
);
2540 char *b
= (char *) mymalloc (len
+ 1);
2547 FILE *logfile_open (char *logfile
)
2549 FILE *fp
= fopen (logfile
, "ab");
2559 void logfile_close (FILE *fp
)
2561 if (fp
== stdout
) return;
2566 void logfile_append (const char *fmt
, ...)
2568 if (data
.logfile_disable
== 1) return;
2570 FILE *fp
= logfile_open (data
.logfile
);
2576 vfprintf (fp
, fmt
, ap
);
2587 int logfile_generate_id ()
2589 const int n
= rand ();
2598 char *logfile_generate_topid ()
2600 const int id
= logfile_generate_id ();
2602 char *topid
= (char *) mymalloc (1 + 16 + 1);
2604 sprintf (topid
, "TOP%08x", id
);
2609 char *logfile_generate_subid ()
2611 const int id
= logfile_generate_id ();
2613 char *subid
= (char *) mymalloc (1 + 16 + 1);
2615 sprintf (subid
, "SUB%08x", id
);
2627 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2629 FlushFileBuffers (h
);
2638 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2642 if (hc_NvAPI_EnumPhysicalGPUs (nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2646 log_info ("WARN: No NvAPI adapters found");
2656 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2660 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2662 if (hc_NVML_nvmlDeviceGetHandleByIndex (data
.hm_dll_nv
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2664 // can be used to determine if the device by index matches the cuda device by index
2665 // char name[100]; memset (name, 0, sizeof (name));
2666 // hc_NVML_nvmlDeviceGetName (data.hm_dll_nv, nvGPUHandle[i], name, sizeof (name) - 1);
2673 log_info ("WARN: No NVML adapters found");
2682 void hm_close (HM_LIB hm_dll
)
2688 FreeLibrary (hm_dll
);
2693 HM_LIB
hm_init (const cl_uint vendor_id
)
2695 HM_LIB hm_dll
= NULL
;
2697 if (vendor_id
== VENDOR_ID_AMD
)
2700 hm_dll
= dlopen ("libatiadlxx.so", RTLD_LAZY
| RTLD_GLOBAL
);
2703 hm_dll
= LoadLibrary ("atiadlxx.dll");
2707 hm_dll
= LoadLibrary ("atiadlxy.dll");
2714 if (vendor_id
== VENDOR_ID_NV
)
2716 hm_dll
= dlopen ("libnvidia-ml.so", RTLD_LAZY
| RTLD_GLOBAL
);
2723 int get_adapters_num_amd (HM_LIB hm_dll_amd
, int *iNumberAdapters
)
2725 if (hc_ADL_Adapter_NumberOfAdapters_Get (hm_dll_amd
, iNumberAdapters
) != ADL_OK
) return -1;
2727 if (iNumberAdapters
== 0)
2729 log_info ("WARN: No ADL adapters found.");
2738 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2740 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2741 ADLODParameters lpOdParameters;
2743 lpOdParameters.iSize = sizeof (ADLODParameters);
2744 size_t plevels_size = 0;
2746 if (hc_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2748 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2749 __func__, iAdapterIndex,
2750 lpOdParameters.iNumberOfPerformanceLevels,
2751 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2752 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2754 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2756 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2758 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2760 if (hc_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2762 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2763 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2764 __func__, iAdapterIndex, j,
2765 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2767 myfree (lpOdPerformanceLevels);
2773 LPAdapterInfo
hm_get_adapter_info_amd (HM_LIB hm_dll_amd
, int iNumberAdapters
)
2775 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2777 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2779 if (hc_ADL_Adapter_AdapterInfo_Get (hm_dll_amd
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2781 return lpAdapterInfo
;
2786 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2789 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2793 for (uint i = 0; i < num_adl_adapters; i++)
2795 int opencl_bus_num = hm_device[i].busid;
2796 int opencl_dev_num = hm_device[i].devid;
2798 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2806 if (idx >= DEVICES_MAX) return -1;
2811 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2813 for (uint i = 0; i < opencl_num_devices; i++)
2815 cl_device_topology_amd device_topology;
2817 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2819 hm_device[i].busid = device_topology.pcie.bus;
2820 hm_device[i].devid = device_topology.pcie.device;
2825 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2827 // basically bubble sort
2829 for (int i
= 0; i
< num_adl_adapters
; i
++)
2831 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2833 // get info of adapter [x]
2835 u32 adapter_index_x
= valid_adl_device_list
[j
];
2836 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2838 u32 bus_num_x
= info_x
.iBusNumber
;
2839 u32 dev_num_x
= info_x
.iDeviceNumber
;
2841 // get info of adapter [y]
2843 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2844 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2846 u32 bus_num_y
= info_y
.iBusNumber
;
2847 u32 dev_num_y
= info_y
.iDeviceNumber
;
2851 if (bus_num_y
< bus_num_x
)
2855 else if (bus_num_y
== bus_num_x
)
2857 if (dev_num_y
< dev_num_x
)
2865 u32 temp
= valid_adl_device_list
[j
+ 1];
2867 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2868 valid_adl_device_list
[j
+ 0] = temp
;
2874 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2876 *num_adl_adapters
= 0;
2878 u32
*adl_adapters
= NULL
;
2880 int *bus_numbers
= NULL
;
2881 int *device_numbers
= NULL
;
2883 for (int i
= 0; i
< iNumberAdapters
; i
++)
2885 AdapterInfo info
= lpAdapterInfo
[i
];
2887 if (strlen (info
.strUDID
) < 1) continue;
2890 if (info
.iVendorID
!= 1002) continue;
2892 if (info
.iVendorID
!= 0x1002) continue;
2895 if (info
.iBusNumber
< 0) continue;
2896 if (info
.iDeviceNumber
< 0) continue;
2900 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2902 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2909 if (found
) continue;
2911 // add it to the list
2913 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2915 adl_adapters
[*num_adl_adapters
] = i
;
2917 // rest is just bookkeeping
2919 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2920 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2922 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2923 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2925 (*num_adl_adapters
)++;
2928 myfree (bus_numbers
);
2929 myfree (device_numbers
);
2931 // sort the list by increasing bus id, device id number
2933 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2935 return adl_adapters
;
2938 int hm_check_fanspeed_control (HM_LIB hm_dll_amd
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2940 // loop through all valid devices
2942 for (int i
= 0; i
< num_adl_adapters
; i
++)
2944 u32 adapter_index
= valid_adl_device_list
[i
];
2948 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2950 // unfortunately this doesn't work since bus id and dev id are not unique
2951 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2952 // if (opencl_device_index == -1) continue;
2954 int opencl_device_index
= i
;
2956 // if (hm_show_performance_level (hm_dll_amd, info.iAdapterIndex) != 0) return -1;
2958 // get fanspeed info
2960 if (hm_device
[opencl_device_index
].od_version
== 5)
2962 ADLFanSpeedInfo FanSpeedInfo
;
2964 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2966 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2968 if (hc_ADL_Overdrive5_FanSpeedInfo_Get (hm_dll_amd
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2970 // check read and write capability in fanspeedinfo
2972 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2973 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2975 hm_device
[opencl_device_index
].fan_supported
= 1;
2979 hm_device
[opencl_device_index
].fan_supported
= 0;
2982 else // od_version == 6
2984 ADLOD6FanSpeedInfo faninfo
;
2986 memset (&faninfo
, 0, sizeof (faninfo
));
2988 if (hc_ADL_Overdrive6_FanSpeed_Get (hm_dll_amd
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2990 // check read capability in fanspeedinfo
2992 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2994 hm_device
[opencl_device_index
].fan_supported
= 1;
2998 hm_device
[opencl_device_index
].fan_supported
= 0;
3006 int hm_get_overdrive_version (HM_LIB hm_dll_amd
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3008 for (int i
= 0; i
< num_adl_adapters
; i
++)
3010 u32 adapter_index
= valid_adl_device_list
[i
];
3014 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3016 // get overdrive version
3018 int od_supported
= 0;
3022 if (hc_ADL_Overdrive_Caps (hm_dll_amd
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3024 // store the overdrive version in hm_device
3026 // unfortunately this doesn't work since bus id and dev id are not unique
3027 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3028 // if (opencl_device_index == -1) continue;
3030 int opencl_device_index
= i
;
3032 hm_device
[opencl_device_index
].od_version
= od_version
;
3038 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3040 for (int i
= 0; i
< num_adl_adapters
; i
++)
3042 u32 adapter_index
= valid_adl_device_list
[i
];
3046 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3048 // store the iAdapterIndex in hm_device
3050 // unfortunately this doesn't work since bus id and dev id are not unique
3051 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3052 // if (opencl_device_index == -1) continue;
3054 int opencl_device_index
= i
;
3056 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3059 return num_adl_adapters
;
3062 int hm_get_temperature_with_device_id (const uint device_id
)
3064 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3066 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3068 if (data
.hm_dll_amd
)
3070 if (data
.hm_device
[device_id
].od_version
== 5)
3072 ADLTemperature Temperature
;
3074 Temperature
.iSize
= sizeof (ADLTemperature
);
3076 if (hc_ADL_Overdrive5_Temperature_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3078 return Temperature
.iTemperature
/ 1000;
3080 else if (data
.hm_device
[device_id
].od_version
== 6)
3082 int Temperature
= 0;
3084 if (hc_ADL_Overdrive6_Temperature_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3086 return Temperature
/ 1000;
3090 else if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3093 int temperature
= 0;
3095 hc_NVML_nvmlDeviceGetTemperature (data
.hm_dll_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (unsigned int *) &temperature
);
3101 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3103 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3104 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3105 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3106 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3108 if (hc_NvAPI_GPU_GetThermalSettings (data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3110 return pThermalSettings
.sensor
[0].currentTemp
;
3117 int hm_get_fanspeed_with_device_id (const uint device_id
)
3119 // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
3120 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3122 if (data
.hm_device
[device_id
].fan_supported
== 1)
3124 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3126 if (data
.hm_dll_amd
)
3128 if (data
.hm_device
[device_id
].od_version
== 5)
3130 ADLFanSpeedValue lpFanSpeedValue
;
3132 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3134 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3135 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3136 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3138 if (hc_ADL_Overdrive5_FanSpeed_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3140 return lpFanSpeedValue
.iFanSpeed
;
3142 else // od_version == 6
3144 ADLOD6FanSpeedInfo faninfo
;
3146 memset (&faninfo
, 0, sizeof (faninfo
));
3148 if (hc_ADL_Overdrive6_FanSpeed_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3150 return faninfo
.iFanSpeedPercent
;
3154 else if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3159 hc_NVML_nvmlDeviceGetFanSpeed (data
.hm_dll_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (unsigned int *) &speed
);
3167 hc_NvAPI_GPU_GetTachReading (data
.hm_device
[device_id
].adapter_index
.nv
, &speed
);
3177 int hm_get_utilization_with_device_id (const uint device_id
)
3179 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3181 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3183 if (data
.hm_dll_amd
)
3185 ADLPMActivity PMActivity
;
3187 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3189 if (hc_ADL_Overdrive_CurrentActivity_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3191 return PMActivity
.iActivityPercent
;
3194 else if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3197 nvmlUtilization_t utilization
;
3199 hc_NVML_nvmlDeviceGetUtilizationRates (data
.hm_dll_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3201 return utilization
.gpu
;
3205 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3207 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3209 if (hc_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3211 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3218 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3220 if (data
.hm_device
[device_id
].fan_supported
== 1)
3222 if (data
.hm_dll_amd
)
3224 if (data
.hm_device
[device_id
].od_version
== 5)
3226 ADLFanSpeedValue lpFanSpeedValue
;
3228 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3230 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3231 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3232 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3233 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3235 if (hc_ADL_Overdrive5_FanSpeed_Set (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3239 else // od_version == 6
3241 ADLOD6FanSpeedValue fan_speed_value
;
3243 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3245 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3246 fan_speed_value
.iFanSpeed
= fanspeed
;
3248 if (hc_ADL_Overdrive6_FanSpeed_Set (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3258 // helper function for status display
3260 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3262 #define VALUE_NOT_AVAILABLE "N/A"
3266 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3270 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3278 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3280 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3282 if (css_cnt
> SP_PW_MAX
)
3284 log_error ("ERROR: mask length is too long");
3289 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3291 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3293 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3294 uint cs_len
= css
[css_pos
].cs_len
;
3296 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3298 uint c
= cs_buf
[cs_pos
] & 0xff;
3305 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3307 cs_t
*cs
= &css
[css_cnt
];
3309 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3311 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3313 memset (css_uniq
, 0, css_uniq_sz
);
3317 for (i
= 0; i
< cs
->cs_len
; i
++)
3319 const uint u
= cs
->cs_buf
[i
];
3324 for (i
= 0; i
< in_len
; i
++)
3326 uint u
= in_buf
[i
] & 0xff;
3328 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3330 if (css_uniq
[u
] == 1) continue;
3334 cs
->cs_buf
[cs
->cs_len
] = u
;
3342 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3346 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3348 uint p0
= in_buf
[in_pos
] & 0xff;
3350 if (interpret
== 1 && p0
== '?')
3354 if (in_pos
== in_len
) break;
3356 uint p1
= in_buf
[in_pos
] & 0xff;
3360 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3362 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3364 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3366 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3368 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3370 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3372 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3373 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3375 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3376 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3378 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3379 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3381 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3382 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3384 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3386 default: log_error ("Syntax error: %s", in_buf
);
3392 if (data
.hex_charset
)
3396 if (in_pos
== in_len
)
3398 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3403 uint p1
= in_buf
[in_pos
] & 0xff;
3405 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3407 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3414 chr
= hex_convert (p1
) << 0;
3415 chr
|= hex_convert (p0
) << 4;
3417 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3423 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3429 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3433 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3435 sum
*= css
[css_pos
].cs_len
;
3441 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3443 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3448 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3450 char p0
= mask_buf
[mask_pos
];
3456 if (mask_pos
== mask_len
) break;
3458 char p1
= mask_buf
[mask_pos
];
3464 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3466 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3468 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3470 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3472 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3474 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3476 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3477 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3479 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3480 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3482 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3483 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3485 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3486 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3488 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3490 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3496 if (data
.hex_charset
)
3500 // if there is no 2nd hex character, show an error:
3502 if (mask_pos
== mask_len
)
3504 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3509 char p1
= mask_buf
[mask_pos
];
3511 // if they are not valid hex character, show an error:
3513 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3515 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3522 chr
|= hex_convert (p1
) << 0;
3523 chr
|= hex_convert (p0
) << 4;
3525 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3531 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3538 log_error ("ERROR: invalid mask length (0)");
3548 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3550 for (int i
= 0; i
< css_cnt
; i
++)
3552 uint len
= css
[i
].cs_len
;
3553 u64 next
= val
/ len
;
3554 uint pos
= val
% len
;
3555 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3560 void mp_cut_at (char *mask
, uint max
)
3564 uint mask_len
= strlen (mask
);
3566 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3568 if (mask
[i
] == '?') i
++;
3574 void mp_setup_sys (cs_t
*mp_sys
)
3578 uint donec
[CHARSIZ
];
3580 memset (donec
, 0, sizeof (donec
));
3582 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3583 mp_sys
[0].cs_buf
[pos
++] = chr
;
3584 mp_sys
[0].cs_len
= pos
; }
3586 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3587 mp_sys
[1].cs_buf
[pos
++] = chr
;
3588 mp_sys
[1].cs_len
= pos
; }
3590 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3591 mp_sys
[2].cs_buf
[pos
++] = chr
;
3592 mp_sys
[2].cs_len
= pos
; }
3594 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3595 mp_sys
[3].cs_buf
[pos
++] = chr
;
3596 mp_sys
[3].cs_len
= pos
; }
3598 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3599 mp_sys
[4].cs_len
= pos
; }
3601 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3602 mp_sys
[5].cs_len
= pos
; }
3605 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3607 FILE *fp
= fopen (buf
, "rb");
3609 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3611 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3617 memset (mp_file
, 0, sizeof (mp_file
));
3619 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3623 len
= in_superchop (mp_file
);
3627 log_info ("WARNING: charset file corrupted");
3629 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3633 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3638 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3640 mp_usr
[index
].cs_len
= 0;
3642 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3645 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3647 char *new_mask_buf
= (char *) mymalloc (256);
3653 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3655 if (css_pos
== len
) break;
3657 char p0
= mask_buf
[mask_pos
];
3659 new_mask_buf
[mask_pos
] = p0
;
3665 if (mask_pos
== mask_len
) break;
3667 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3671 if (data
.hex_charset
)
3675 if (mask_pos
== mask_len
)
3677 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3682 char p1
= mask_buf
[mask_pos
];
3684 // if they are not valid hex character, show an error:
3686 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3688 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3693 new_mask_buf
[mask_pos
] = p1
;
3698 if (css_pos
== len
) return (new_mask_buf
);
3700 myfree (new_mask_buf
);
3709 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3715 for (i
= start
; i
< stop
; i
++)
3717 sum
*= root_css_buf
[i
].cs_len
;
3723 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3727 cs_t
*cs
= &root_css_buf
[start
];
3731 for (i
= start
; i
< stop
; i
++)
3733 const u64 m
= v
% cs
->cs_len
;
3734 const u64 d
= v
/ cs
->cs_len
;
3738 const uint k
= cs
->cs_buf
[m
];
3740 pw_buf
[i
- start
] = (char) k
;
3742 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3746 int sp_comp_val (const void *p1
, const void *p2
)
3748 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3749 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3751 return b2
->val
- b1
->val
;
3754 void sp_setup_tbl (const char *shared_dir
, char *hcstat
, uint disable
, uint classic
, hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
)
3761 * Initialize hcstats
3764 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3766 u64
*root_stats_ptr
= root_stats_buf
;
3768 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3770 for (i
= 0; i
< SP_PW_MAX
; i
++)
3772 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3774 root_stats_ptr
+= CHARSIZ
;
3777 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3779 u64
*markov_stats_ptr
= markov_stats_buf
;
3781 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3783 for (i
= 0; i
< SP_PW_MAX
; i
++)
3785 for (j
= 0; j
< CHARSIZ
; j
++)
3787 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3789 markov_stats_ptr
+= CHARSIZ
;
3799 char hcstat_tmp
[256];
3801 memset (hcstat_tmp
, 0, sizeof (hcstat_tmp
));
3803 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3805 hcstat
= hcstat_tmp
;
3808 FILE *fd
= fopen (hcstat
, "rb");
3812 log_error ("%s: %s", hcstat
, strerror (errno
));
3817 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3819 log_error ("%s: Could not load data", hcstat
);
3824 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3826 log_error ("%s: Could not load data", hcstat
);
3834 * Markov modifier of hcstat_table on user request
3839 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
3840 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
3845 /* Add all stats to first position */
3847 for (i
= 1; i
< SP_PW_MAX
; i
++)
3849 u64
*out
= root_stats_buf_by_pos
[0];
3850 u64
*in
= root_stats_buf_by_pos
[i
];
3852 for (j
= 0; j
< CHARSIZ
; j
++)
3858 for (i
= 1; i
< SP_PW_MAX
; i
++)
3860 u64
*out
= markov_stats_buf_by_key
[0][0];
3861 u64
*in
= markov_stats_buf_by_key
[i
][0];
3863 for (j
= 0; j
< CHARSIZ
; j
++)
3865 for (k
= 0; k
< CHARSIZ
; k
++)
3872 /* copy them to all pw_positions */
3874 for (i
= 1; i
< SP_PW_MAX
; i
++)
3876 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
3879 for (i
= 1; i
< SP_PW_MAX
; i
++)
3881 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
3889 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3891 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3893 for (i
= 0; i
< SP_PW_MAX
; i
++)
3895 root_table_buf_by_pos
[i
] = root_table_ptr
;
3897 root_table_ptr
+= CHARSIZ
;
3900 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3902 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3904 for (i
= 0; i
< SP_PW_MAX
; i
++)
3906 for (j
= 0; j
< CHARSIZ
; j
++)
3908 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3910 markov_table_ptr
+= CHARSIZ
;
3915 * Convert hcstat to tables
3918 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3920 uint key
= i
% CHARSIZ
;
3922 root_table_buf
[i
].key
= key
;
3923 root_table_buf
[i
].val
= root_stats_buf
[i
];
3926 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3928 uint key
= i
% CHARSIZ
;
3930 markov_table_buf
[i
].key
= key
;
3931 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3934 myfree (root_stats_buf
);
3935 myfree (markov_stats_buf
);
3941 for (i
= 0; i
< SP_PW_MAX
; i
++)
3943 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3946 for (i
= 0; i
< SP_PW_MAX
; i
++)
3948 for (j
= 0; j
< CHARSIZ
; j
++)
3950 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3955 void sp_tbl_to_css (hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint threshold
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3958 * Convert tables to css
3961 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
3963 uint pw_pos
= i
/ CHARSIZ
;
3965 cs_t
*cs
= &root_css_buf
[pw_pos
];
3967 if (cs
->cs_len
== threshold
) continue;
3969 uint key
= root_table_buf
[i
].key
;
3971 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
3973 cs
->cs_buf
[cs
->cs_len
] = key
;
3979 * Convert table to css
3982 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
3984 uint c
= i
/ CHARSIZ
;
3986 cs_t
*cs
= &markov_css_buf
[c
];
3988 if (cs
->cs_len
== threshold
) continue;
3990 uint pw_pos
= c
/ CHARSIZ
;
3992 uint key
= markov_table_buf
[i
].key
;
3994 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
3996 cs
->cs_buf
[cs
->cs_len
] = key
;
4002 for (uint i = 0; i < 8; i++)
4004 for (uint j = 0x20; j < 0x80; j++)
4006 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4008 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4010 for (uint k = 0; k < 10; k++)
4012 printf (" %u\n", ptr->cs_buf[k]);
4019 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4021 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4023 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4033 for (uint j
= 1; j
< CHARSIZ
; j
++)
4043 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4045 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4047 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4049 out
+= CHARSIZ
* CHARSIZ
;
4050 in
+= CHARSIZ
* CHARSIZ
;
4052 for (uint j
= 0; j
< CHARSIZ
; j
++)
4059 for (uint k
= 1; k
< CHARSIZ
; k
++)
4071 * mixed shared functions
4074 void dump_hex (const u8
*s
, const int sz
)
4076 for (int i
= 0; i
< sz
; i
++)
4078 log_info_nn ("%02x ", s
[i
]);
4084 void usage_mini_print (const char *progname
)
4086 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4089 void usage_big_print (const char *progname
)
4091 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4094 char *get_exec_path ()
4096 int exec_path_len
= 1024;
4098 char *exec_path
= (char *) mymalloc (exec_path_len
);
4104 sprintf (tmp
, "/proc/%d/exe", getpid ());
4106 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4112 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4121 char *get_install_dir (const char *progname
)
4123 char *install_dir
= mystrdup (progname
);
4124 char *last_slash
= NULL
;
4126 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4130 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4136 install_dir
[0] = '.';
4140 return (install_dir
);
4143 char *get_profile_dir (const char *homedir
)
4145 #define DOT_HASHCAT ".hashcat"
4147 char *profile_dir
= (char *) mymalloc (strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1);
4149 sprintf (profile_dir
, "%s/%s", homedir
, DOT_HASHCAT
);
4154 char *get_session_dir (const char *profile_dir
)
4156 #define SESSIONS_FOLDER "sessions"
4158 char *session_dir
= (char *) mymalloc (strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1);
4160 sprintf (session_dir
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4165 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4169 FILE *fd
= fopen (filename
, "rb");
4173 log_error ("%s: %s", filename
, strerror (errno
));
4178 #define MAX_KEY_SIZE (1024 * 1024)
4180 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4182 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4188 for (int fpos
= 0; fpos
< nread
; fpos
++)
4190 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4192 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4193 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4194 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4195 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4197 if (kpos
>= 64) kpos
= 0;
4203 void set_cpu_affinity (char *cpu_affinity
)
4206 DWORD_PTR aff_mask
= 0;
4217 char *devices
= strdup (cpu_affinity
);
4219 char *next
= strtok (devices
, ",");
4223 uint cpu_id
= atoi (next
);
4240 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4246 aff_mask
|= 1 << (cpu_id
- 1);
4250 CPU_SET ((cpu_id
- 1), &cpuset
);
4253 } while ((next
= strtok (NULL
, ",")) != NULL
);
4259 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4260 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4264 pthread_t thread
= pthread_self ();
4265 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4269 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4271 char *element
, *end
;
4273 end
= (char *) base
+ nmemb
* size
;
4275 for (element
= (char *) base
; element
< end
; element
+= size
)
4276 if (!compar (element
, key
))
4282 int sort_by_salt (const void *v1
, const void *v2
)
4284 const salt_t
*s1
= (const salt_t
*) v1
;
4285 const salt_t
*s2
= (const salt_t
*) v2
;
4287 const int res1
= s1
->salt_len
- s2
->salt_len
;
4289 if (res1
!= 0) return (res1
);
4291 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4293 if (res2
!= 0) return (res2
);
4301 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4302 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4309 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4310 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4316 int sort_by_salt_buf (const void *v1
, const void *v2
)
4318 const pot_t
*p1
= (const pot_t
*) v1
;
4319 const pot_t
*p2
= (const pot_t
*) v2
;
4321 const hash_t
*h1
= &p1
->hash
;
4322 const hash_t
*h2
= &p2
->hash
;
4324 const salt_t
*s1
= h1
->salt
;
4325 const salt_t
*s2
= h2
->salt
;
4331 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4332 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4338 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4340 const hash_t
*h1
= (const hash_t
*) v1
;
4341 const hash_t
*h2
= (const hash_t
*) v2
;
4343 const salt_t
*s1
= h1
->salt
;
4344 const salt_t
*s2
= h2
->salt
;
4346 // testphase: this should work
4351 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4352 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4355 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4356 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4357 if (s1->salt_len > s2->salt_len) return ( 1);
4358 if (s1->salt_len < s2->salt_len) return (-1);
4360 uint n = s1->salt_len;
4364 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4365 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4372 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4374 const hash_t
*h1
= (const hash_t
*) v1
;
4375 const hash_t
*h2
= (const hash_t
*) v2
;
4377 const salt_t
*s1
= h1
->salt
;
4378 const salt_t
*s2
= h2
->salt
;
4380 // 12 - 2 (since last 2 uints contain the digest)
4385 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4386 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4392 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4394 const hash_t
*h1
= (const hash_t
*) v1
;
4395 const hash_t
*h2
= (const hash_t
*) v2
;
4397 const void *d1
= h1
->digest
;
4398 const void *d2
= h2
->digest
;
4400 return data
.sort_by_digest (d1
, d2
);
4403 int sort_by_hash (const void *v1
, const void *v2
)
4405 const hash_t
*h1
= (const hash_t
*) v1
;
4406 const hash_t
*h2
= (const hash_t
*) v2
;
4410 const salt_t
*s1
= h1
->salt
;
4411 const salt_t
*s2
= h2
->salt
;
4413 int res
= sort_by_salt (s1
, s2
);
4415 if (res
!= 0) return (res
);
4418 const void *d1
= h1
->digest
;
4419 const void *d2
= h2
->digest
;
4421 return data
.sort_by_digest (d1
, d2
);
4424 int sort_by_pot (const void *v1
, const void *v2
)
4426 const pot_t
*p1
= (const pot_t
*) v1
;
4427 const pot_t
*p2
= (const pot_t
*) v2
;
4429 const hash_t
*h1
= &p1
->hash
;
4430 const hash_t
*h2
= &p2
->hash
;
4432 return sort_by_hash (h1
, h2
);
4435 int sort_by_mtime (const void *p1
, const void *p2
)
4437 const char **f1
= (const char **) p1
;
4438 const char **f2
= (const char **) p2
;
4440 struct stat s1
; stat (*f1
, &s1
);
4441 struct stat s2
; stat (*f2
, &s2
);
4443 return s2
.st_mtime
- s1
.st_mtime
;
4446 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4448 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4449 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4451 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4454 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4456 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4457 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4459 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4462 int sort_by_stringptr (const void *p1
, const void *p2
)
4464 const char **s1
= (const char **) p1
;
4465 const char **s2
= (const char **) p2
;
4467 return strcmp (*s1
, *s2
);
4470 int sort_by_dictstat (const void *s1
, const void *s2
)
4472 dictstat_t
*d1
= (dictstat_t
*) s1
;
4473 dictstat_t
*d2
= (dictstat_t
*) s2
;
4476 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4478 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4481 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4484 int sort_by_bitmap (const void *p1
, const void *p2
)
4486 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4487 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4489 return b1
->collisions
- b2
->collisions
;
4492 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4494 const u32
*d1
= (const u32
*) v1
;
4495 const u32
*d2
= (const u32
*) v2
;
4501 if (d1
[n
] > d2
[n
]) return ( 1);
4502 if (d1
[n
] < d2
[n
]) return (-1);
4508 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4510 const u32
*d1
= (const u32
*) v1
;
4511 const u32
*d2
= (const u32
*) v2
;
4517 if (d1
[n
] > d2
[n
]) return ( 1);
4518 if (d1
[n
] < d2
[n
]) return (-1);
4524 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4526 const u32
*d1
= (const u32
*) v1
;
4527 const u32
*d2
= (const u32
*) v2
;
4533 if (d1
[n
] > d2
[n
]) return ( 1);
4534 if (d1
[n
] < d2
[n
]) return (-1);
4540 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4542 const u32
*d1
= (const u32
*) v1
;
4543 const u32
*d2
= (const u32
*) v2
;
4549 if (d1
[n
] > d2
[n
]) return ( 1);
4550 if (d1
[n
] < d2
[n
]) return (-1);
4556 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4558 const u32
*d1
= (const u32
*) v1
;
4559 const u32
*d2
= (const u32
*) v2
;
4565 if (d1
[n
] > d2
[n
]) return ( 1);
4566 if (d1
[n
] < d2
[n
]) return (-1);
4572 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4574 const u32
*d1
= (const u32
*) v1
;
4575 const u32
*d2
= (const u32
*) v2
;
4581 if (d1
[n
] > d2
[n
]) return ( 1);
4582 if (d1
[n
] < d2
[n
]) return (-1);
4588 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4590 const u32
*d1
= (const u32
*) v1
;
4591 const u32
*d2
= (const u32
*) v2
;
4597 if (d1
[n
] > d2
[n
]) return ( 1);
4598 if (d1
[n
] < d2
[n
]) return (-1);
4604 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4606 const u32
*d1
= (const u32
*) v1
;
4607 const u32
*d2
= (const u32
*) v2
;
4613 if (d1
[n
] > d2
[n
]) return ( 1);
4614 if (d1
[n
] < d2
[n
]) return (-1);
4620 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4622 const u64
*d1
= (const u64
*) v1
;
4623 const u64
*d2
= (const u64
*) v2
;
4629 if (d1
[n
] > d2
[n
]) return ( 1);
4630 if (d1
[n
] < d2
[n
]) return (-1);
4636 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4638 const u64
*d1
= (const u64
*) v1
;
4639 const u64
*d2
= (const u64
*) v2
;
4645 if (d1
[n
] > d2
[n
]) return ( 1);
4646 if (d1
[n
] < d2
[n
]) return (-1);
4652 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4654 const u64
*d1
= (const u64
*) v1
;
4655 const u64
*d2
= (const u64
*) v2
;
4661 if (d1
[n
] > d2
[n
]) return ( 1);
4662 if (d1
[n
] < d2
[n
]) return (-1);
4668 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4670 const u32
*d1
= (const u32
*) v1
;
4671 const u32
*d2
= (const u32
*) v2
;
4673 const uint dgst_pos0
= data
.dgst_pos0
;
4674 const uint dgst_pos1
= data
.dgst_pos1
;
4675 const uint dgst_pos2
= data
.dgst_pos2
;
4676 const uint dgst_pos3
= data
.dgst_pos3
;
4678 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4679 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4680 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4681 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4682 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4683 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4684 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4685 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4690 void format_debug (char *debug_file
, uint debug_mode
, unsigned char *orig_plain_ptr
, uint orig_plain_len
, unsigned char *mod_plain_ptr
, uint mod_plain_len
, char *rule_buf
, int rule_len
)
4692 uint outfile_autohex
= data
.outfile_autohex
;
4694 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4696 FILE *debug_fp
= NULL
;
4698 if (debug_file
!= NULL
)
4700 debug_fp
= fopen (debug_file
, "ab");
4707 if (debug_fp
== NULL
)
4709 log_info ("WARNING: Could not open debug-file for writing");
4713 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4715 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4717 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4720 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4722 if (debug_mode
== 4)
4724 fputc (':', debug_fp
);
4726 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4729 fputc ('\n', debug_fp
);
4731 if (debug_file
!= NULL
) fclose (debug_fp
);
4735 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4737 int needs_hexify
= 0;
4739 if (outfile_autohex
== 1)
4741 for (uint i
= 0; i
< plain_len
; i
++)
4743 if (plain_ptr
[i
] < 0x20)
4750 if (plain_ptr
[i
] > 0x7f)
4759 if (needs_hexify
== 1)
4761 fprintf (fp
, "$HEX[");
4763 for (uint i
= 0; i
< plain_len
; i
++)
4765 fprintf (fp
, "%02x", plain_ptr
[i
]);
4772 fwrite (plain_ptr
, plain_len
, 1, fp
);
4776 void format_output (FILE *out_fp
, char *out_buf
, unsigned char *plain_ptr
, const uint plain_len
, const u64 crackpos
, unsigned char *username
, const uint user_len
)
4778 uint outfile_format
= data
.outfile_format
;
4780 char separator
= data
.separator
;
4782 if (outfile_format
& OUTFILE_FMT_HASH
)
4784 fprintf (out_fp
, "%s", out_buf
);
4786 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4788 fputc (separator
, out_fp
);
4791 else if (data
.username
)
4793 if (username
!= NULL
)
4795 for (uint i
= 0; i
< user_len
; i
++)
4797 fprintf (out_fp
, "%c", username
[i
]);
4800 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4802 fputc (separator
, out_fp
);
4807 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4809 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4811 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4813 fputc (separator
, out_fp
);
4817 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4819 for (uint i
= 0; i
< plain_len
; i
++)
4821 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4824 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4826 fputc (separator
, out_fp
);
4830 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4833 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4838 fprintf (out_fp
, "%lu", crackpos
);
4840 fprintf (out_fp
, "%llu", crackpos
);
4845 fputc ('\n', out_fp
);
4848 void handle_show_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
4852 pot_key
.hash
.salt
= hashes_buf
->salt
;
4853 pot_key
.hash
.digest
= hashes_buf
->digest
;
4855 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4861 input_buf
[input_len
] = 0;
4864 unsigned char *username
= NULL
;
4869 user_t
*user
= hashes_buf
->hash_info
->user
;
4873 username
= (unsigned char *) (user
->user_name
);
4875 user_len
= user
->user_len
;
4879 // do output the line
4880 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
4884 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
4885 #define LM_MASKED_PLAIN "[notfound]"
4887 void handle_show_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
4893 pot_left_key
.hash
.salt
= hash_left
->salt
;
4894 pot_left_key
.hash
.digest
= hash_left
->digest
;
4896 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4900 uint weak_hash_found
= 0;
4902 pot_t pot_right_key
;
4904 pot_right_key
.hash
.salt
= hash_right
->salt
;
4905 pot_right_key
.hash
.digest
= hash_right
->digest
;
4907 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4909 if (pot_right_ptr
== NULL
)
4911 // special case, if "weak hash"
4913 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
4915 weak_hash_found
= 1;
4917 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4919 // in theory this is not needed, but we are paranoia:
4921 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4922 pot_right_ptr
->plain_len
= 0;
4926 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
4928 if (weak_hash_found
== 1) myfree (pot_right_ptr
); // this shouldn't happen at all: if weak_hash_found == 1, than pot_right_ptr is not NULL for sure
4933 // at least one half was found:
4937 input_buf
[input_len
] = 0;
4941 unsigned char *username
= NULL
;
4946 user_t
*user
= hash_left
->hash_info
->user
;
4950 username
= (unsigned char *) (user
->user_name
);
4952 user_len
= user
->user_len
;
4956 // mask the part which was not found
4958 uint left_part_masked
= 0;
4959 uint right_part_masked
= 0;
4961 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
4963 if (pot_left_ptr
== NULL
)
4965 left_part_masked
= 1;
4967 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4969 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
4971 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
4972 pot_left_ptr
->plain_len
= mask_plain_len
;
4975 if (pot_right_ptr
== NULL
)
4977 right_part_masked
= 1;
4979 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4981 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4983 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
4984 pot_right_ptr
->plain_len
= mask_plain_len
;
4987 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
4991 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
4993 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
4995 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
4997 // do output the line
4999 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5001 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5003 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5004 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5007 void handle_left_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5011 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5013 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5015 if (pot_ptr
== NULL
)
5019 input_buf
[input_len
] = 0;
5021 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5025 void handle_left_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5031 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5033 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5037 pot_t pot_right_key
;
5039 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5041 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5043 uint weak_hash_found
= 0;
5045 if (pot_right_ptr
== NULL
)
5047 // special case, if "weak hash"
5049 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5051 weak_hash_found
= 1;
5053 // we just need that pot_right_ptr is not a NULL pointer
5055 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5059 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5061 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5066 // ... at least one part was not cracked
5070 input_buf
[input_len
] = 0;
5072 // only show the hash part which is still not cracked
5074 uint user_len
= input_len
- 32;
5076 char hash_output
[user_len
+ 33];
5078 memset (hash_output
, 0, sizeof (hash_output
));
5080 memcpy (hash_output
, input_buf
, input_len
);
5082 if (pot_left_ptr
!= NULL
)
5084 // only show right part (because left part was already found)
5086 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5088 hash_output
[user_len
+ 16] = 0;
5091 if (pot_right_ptr
!= NULL
)
5093 // only show left part (because right part was already found)
5095 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5097 hash_output
[user_len
+ 16] = 0;
5100 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5102 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5105 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5107 uint opencl_platforms_filter
= 0;
5109 if (opencl_platforms
)
5111 char *platforms
= strdup (opencl_platforms
);
5113 char *next
= strtok (platforms
, ",");
5117 int platform
= atoi (next
);
5119 if (platform
< 1 || platform
> 32)
5121 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5126 opencl_platforms_filter
|= 1 << (platform
- 1);
5128 } while ((next
= strtok (NULL
, ",")) != NULL
);
5134 opencl_platforms_filter
= -1;
5137 return opencl_platforms_filter
;
5140 u32
setup_devices_filter (char *opencl_devices
)
5142 u32 devices_filter
= 0;
5146 char *devices
= strdup (opencl_devices
);
5148 char *next
= strtok (devices
, ",");
5152 int device_id
= atoi (next
);
5154 if (device_id
< 1 || device_id
> 32)
5156 log_error ("ERROR: invalid device_id %u specified", device_id
);
5161 devices_filter
|= 1 << (device_id
- 1);
5163 } while ((next
= strtok (NULL
, ",")) != NULL
);
5169 devices_filter
= -1;
5172 return devices_filter
;
5175 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5177 cl_device_type device_types_filter
= 0;
5179 if (opencl_device_types
)
5181 char *device_types
= strdup (opencl_device_types
);
5183 char *next
= strtok (device_types
, ",");
5187 int device_type
= atoi (next
);
5189 if (device_type
< 1 || device_type
> 3)
5191 log_error ("ERROR: invalid device_type %u specified", device_type
);
5196 device_types_filter
|= 1 << device_type
;
5198 } while ((next
= strtok (NULL
, ",")) != NULL
);
5200 free (device_types
);
5204 // Do not use CPU by default, this often reduces GPU performance because
5205 // the CPU is too busy to handle GPU synchronization
5207 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5210 return device_types_filter
;
5213 u32
get_random_num (const u32 min
, const u32 max
)
5215 if (min
== max
) return (min
);
5217 return ((rand () % (max
- min
)) + min
);
5220 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5222 u32 quotient
= dividend
/ divisor
;
5224 if (dividend
% divisor
) quotient
++;
5229 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5231 u64 quotient
= dividend
/ divisor
;
5233 if (dividend
% divisor
) quotient
++;
5238 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5240 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5241 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5243 if (tm
->tm_year
- 70)
5245 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5246 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5248 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5250 else if (tm
->tm_yday
)
5252 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5253 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5255 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5257 else if (tm
->tm_hour
)
5259 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5260 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5262 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5264 else if (tm
->tm_min
)
5266 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5267 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5269 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5273 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5275 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5279 void format_speed_display (float val
, char *buf
, size_t len
)
5290 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5301 /* generate output */
5305 snprintf (buf
, len
- 1, "%.0f ", val
);
5309 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5313 void lowercase (u8
*buf
, int len
)
5315 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5318 void uppercase (u8
*buf
, int len
)
5320 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5323 int fgetl (FILE *fp
, char *line_buf
)
5329 const int c
= fgetc (fp
);
5331 if (c
== EOF
) break;
5333 line_buf
[line_len
] = (char) c
;
5337 if (line_len
== BUFSIZ
) line_len
--;
5339 if (c
== '\n') break;
5342 if (line_len
== 0) return 0;
5344 if (line_buf
[line_len
- 1] == '\n')
5348 line_buf
[line_len
] = 0;
5351 if (line_len
== 0) return 0;
5353 if (line_buf
[line_len
- 1] == '\r')
5357 line_buf
[line_len
] = 0;
5363 int in_superchop (char *buf
)
5365 int len
= strlen (buf
);
5369 if (buf
[len
- 1] == '\n')
5376 if (buf
[len
- 1] == '\r')
5391 char **scan_directory (const char *path
)
5393 char *tmp_path
= mystrdup (path
);
5395 size_t tmp_path_len
= strlen (tmp_path
);
5397 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5399 tmp_path
[tmp_path_len
- 1] = 0;
5401 tmp_path_len
= strlen (tmp_path
);
5404 char **files
= NULL
;
5410 if ((d
= opendir (tmp_path
)) != NULL
)
5414 while ((de
= readdir (d
)) != NULL
)
5416 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5418 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5420 char *path_file
= (char *) mymalloc (path_size
+ 1);
5422 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5424 path_file
[path_size
] = 0;
5428 if ((d_test
= opendir (path_file
)) != NULL
)
5436 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5440 files
[num_files
- 1] = path_file
;
5446 else if (errno
== ENOTDIR
)
5448 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5452 files
[num_files
- 1] = mystrdup (path
);
5455 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5459 files
[num_files
- 1] = NULL
;
5466 int count_dictionaries (char **dictionary_files
)
5468 if (dictionary_files
== NULL
) return 0;
5472 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5480 char *stroptitype (const uint opti_type
)
5484 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5485 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5486 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5487 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5488 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5489 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5490 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5491 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5492 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5493 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5494 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5495 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5496 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5497 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5503 char *strparser (const uint parser_status
)
5505 switch (parser_status
)
5507 case PARSER_OK
: return ((char *) PA_000
); break;
5508 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5509 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5510 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5511 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5512 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5513 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5514 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5515 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5516 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5517 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5518 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5519 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5520 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5521 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5522 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5523 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5526 return ((char *) PA_255
);
5529 char *strhashtype (const uint hash_mode
)
5533 case 0: return ((char *) HT_00000
); break;
5534 case 10: return ((char *) HT_00010
); break;
5535 case 11: return ((char *) HT_00011
); break;
5536 case 12: return ((char *) HT_00012
); break;
5537 case 20: return ((char *) HT_00020
); break;
5538 case 21: return ((char *) HT_00021
); break;
5539 case 22: return ((char *) HT_00022
); break;
5540 case 23: return ((char *) HT_00023
); break;
5541 case 30: return ((char *) HT_00030
); break;
5542 case 40: return ((char *) HT_00040
); break;
5543 case 50: return ((char *) HT_00050
); break;
5544 case 60: return ((char *) HT_00060
); break;
5545 case 100: return ((char *) HT_00100
); break;
5546 case 101: return ((char *) HT_00101
); break;
5547 case 110: return ((char *) HT_00110
); break;
5548 case 111: return ((char *) HT_00111
); break;
5549 case 112: return ((char *) HT_00112
); break;
5550 case 120: return ((char *) HT_00120
); break;
5551 case 121: return ((char *) HT_00121
); break;
5552 case 122: return ((char *) HT_00122
); break;
5553 case 124: return ((char *) HT_00124
); break;
5554 case 130: return ((char *) HT_00130
); break;
5555 case 131: return ((char *) HT_00131
); break;
5556 case 132: return ((char *) HT_00132
); break;
5557 case 133: return ((char *) HT_00133
); break;
5558 case 140: return ((char *) HT_00140
); break;
5559 case 141: return ((char *) HT_00141
); break;
5560 case 150: return ((char *) HT_00150
); break;
5561 case 160: return ((char *) HT_00160
); break;
5562 case 190: return ((char *) HT_00190
); break;
5563 case 200: return ((char *) HT_00200
); break;
5564 case 300: return ((char *) HT_00300
); break;
5565 case 400: return ((char *) HT_00400
); break;
5566 case 500: return ((char *) HT_00500
); break;
5567 case 501: return ((char *) HT_00501
); break;
5568 case 900: return ((char *) HT_00900
); break;
5569 case 910: return ((char *) HT_00910
); break;
5570 case 1000: return ((char *) HT_01000
); break;
5571 case 1100: return ((char *) HT_01100
); break;
5572 case 1400: return ((char *) HT_01400
); break;
5573 case 1410: return ((char *) HT_01410
); break;
5574 case 1420: return ((char *) HT_01420
); break;
5575 case 1421: return ((char *) HT_01421
); break;
5576 case 1430: return ((char *) HT_01430
); break;
5577 case 1440: return ((char *) HT_01440
); break;
5578 case 1441: return ((char *) HT_01441
); break;
5579 case 1450: return ((char *) HT_01450
); break;
5580 case 1460: return ((char *) HT_01460
); break;
5581 case 1500: return ((char *) HT_01500
); break;
5582 case 1600: return ((char *) HT_01600
); break;
5583 case 1700: return ((char *) HT_01700
); break;
5584 case 1710: return ((char *) HT_01710
); break;
5585 case 1711: return ((char *) HT_01711
); break;
5586 case 1720: return ((char *) HT_01720
); break;
5587 case 1722: return ((char *) HT_01722
); break;
5588 case 1730: return ((char *) HT_01730
); break;
5589 case 1731: return ((char *) HT_01731
); break;
5590 case 1740: return ((char *) HT_01740
); break;
5591 case 1750: return ((char *) HT_01750
); break;
5592 case 1760: return ((char *) HT_01760
); break;
5593 case 1800: return ((char *) HT_01800
); break;
5594 case 2100: return ((char *) HT_02100
); break;
5595 case 2400: return ((char *) HT_02400
); break;
5596 case 2410: return ((char *) HT_02410
); break;
5597 case 2500: return ((char *) HT_02500
); break;
5598 case 2600: return ((char *) HT_02600
); break;
5599 case 2611: return ((char *) HT_02611
); break;
5600 case 2612: return ((char *) HT_02612
); break;
5601 case 2711: return ((char *) HT_02711
); break;
5602 case 2811: return ((char *) HT_02811
); break;
5603 case 3000: return ((char *) HT_03000
); break;
5604 case 3100: return ((char *) HT_03100
); break;
5605 case 3200: return ((char *) HT_03200
); break;
5606 case 3710: return ((char *) HT_03710
); break;
5607 case 3711: return ((char *) HT_03711
); break;
5608 case 3800: return ((char *) HT_03800
); break;
5609 case 4300: return ((char *) HT_04300
); break;
5610 case 4400: return ((char *) HT_04400
); break;
5611 case 4500: return ((char *) HT_04500
); break;
5612 case 4700: return ((char *) HT_04700
); break;
5613 case 4800: return ((char *) HT_04800
); break;
5614 case 4900: return ((char *) HT_04900
); break;
5615 case 5000: return ((char *) HT_05000
); break;
5616 case 5100: return ((char *) HT_05100
); break;
5617 case 5200: return ((char *) HT_05200
); break;
5618 case 5300: return ((char *) HT_05300
); break;
5619 case 5400: return ((char *) HT_05400
); break;
5620 case 5500: return ((char *) HT_05500
); break;
5621 case 5600: return ((char *) HT_05600
); break;
5622 case 5700: return ((char *) HT_05700
); break;
5623 case 5800: return ((char *) HT_05800
); break;
5624 case 6000: return ((char *) HT_06000
); break;
5625 case 6100: return ((char *) HT_06100
); break;
5626 case 6211: return ((char *) HT_06211
); break;
5627 case 6212: return ((char *) HT_06212
); break;
5628 case 6213: return ((char *) HT_06213
); break;
5629 case 6221: return ((char *) HT_06221
); break;
5630 case 6222: return ((char *) HT_06222
); break;
5631 case 6223: return ((char *) HT_06223
); break;
5632 case 6231: return ((char *) HT_06231
); break;
5633 case 6232: return ((char *) HT_06232
); break;
5634 case 6233: return ((char *) HT_06233
); break;
5635 case 6241: return ((char *) HT_06241
); break;
5636 case 6242: return ((char *) HT_06242
); break;
5637 case 6243: return ((char *) HT_06243
); break;
5638 case 6300: return ((char *) HT_06300
); break;
5639 case 6400: return ((char *) HT_06400
); break;
5640 case 6500: return ((char *) HT_06500
); break;
5641 case 6600: return ((char *) HT_06600
); break;
5642 case 6700: return ((char *) HT_06700
); break;
5643 case 6800: return ((char *) HT_06800
); break;
5644 case 6900: return ((char *) HT_06900
); break;
5645 case 7100: return ((char *) HT_07100
); break;
5646 case 7200: return ((char *) HT_07200
); break;
5647 case 7300: return ((char *) HT_07300
); break;
5648 case 7400: return ((char *) HT_07400
); break;
5649 case 7500: return ((char *) HT_07500
); break;
5650 case 7600: return ((char *) HT_07600
); break;
5651 case 7700: return ((char *) HT_07700
); break;
5652 case 7800: return ((char *) HT_07800
); break;
5653 case 7900: return ((char *) HT_07900
); break;
5654 case 8000: return ((char *) HT_08000
); break;
5655 case 8100: return ((char *) HT_08100
); break;
5656 case 8200: return ((char *) HT_08200
); break;
5657 case 8300: return ((char *) HT_08300
); break;
5658 case 8400: return ((char *) HT_08400
); break;
5659 case 8500: return ((char *) HT_08500
); break;
5660 case 8600: return ((char *) HT_08600
); break;
5661 case 8700: return ((char *) HT_08700
); break;
5662 case 8800: return ((char *) HT_08800
); break;
5663 case 8900: return ((char *) HT_08900
); break;
5664 case 9000: return ((char *) HT_09000
); break;
5665 case 9100: return ((char *) HT_09100
); break;
5666 case 9200: return ((char *) HT_09200
); break;
5667 case 9300: return ((char *) HT_09300
); break;
5668 case 9400: return ((char *) HT_09400
); break;
5669 case 9500: return ((char *) HT_09500
); break;
5670 case 9600: return ((char *) HT_09600
); break;
5671 case 9700: return ((char *) HT_09700
); break;
5672 case 9710: return ((char *) HT_09710
); break;
5673 case 9720: return ((char *) HT_09720
); break;
5674 case 9800: return ((char *) HT_09800
); break;
5675 case 9810: return ((char *) HT_09810
); break;
5676 case 9820: return ((char *) HT_09820
); break;
5677 case 9900: return ((char *) HT_09900
); break;
5678 case 10000: return ((char *) HT_10000
); break;
5679 case 10100: return ((char *) HT_10100
); break;
5680 case 10200: return ((char *) HT_10200
); break;
5681 case 10300: return ((char *) HT_10300
); break;
5682 case 10400: return ((char *) HT_10400
); break;
5683 case 10410: return ((char *) HT_10410
); break;
5684 case 10420: return ((char *) HT_10420
); break;
5685 case 10500: return ((char *) HT_10500
); break;
5686 case 10600: return ((char *) HT_10600
); break;
5687 case 10700: return ((char *) HT_10700
); break;
5688 case 10800: return ((char *) HT_10800
); break;
5689 case 10900: return ((char *) HT_10900
); break;
5690 case 11000: return ((char *) HT_11000
); break;
5691 case 11100: return ((char *) HT_11100
); break;
5692 case 11200: return ((char *) HT_11200
); break;
5693 case 11300: return ((char *) HT_11300
); break;
5694 case 11400: return ((char *) HT_11400
); break;
5695 case 11500: return ((char *) HT_11500
); break;
5696 case 11600: return ((char *) HT_11600
); break;
5697 case 11700: return ((char *) HT_11700
); break;
5698 case 11800: return ((char *) HT_11800
); break;
5699 case 11900: return ((char *) HT_11900
); break;
5700 case 12000: return ((char *) HT_12000
); break;
5701 case 12100: return ((char *) HT_12100
); break;
5702 case 12200: return ((char *) HT_12200
); break;
5703 case 12300: return ((char *) HT_12300
); break;
5704 case 12400: return ((char *) HT_12400
); break;
5705 case 12500: return ((char *) HT_12500
); break;
5706 case 12600: return ((char *) HT_12600
); break;
5707 case 12700: return ((char *) HT_12700
); break;
5708 case 12800: return ((char *) HT_12800
); break;
5709 case 12900: return ((char *) HT_12900
); break;
5710 case 13000: return ((char *) HT_13000
); break;
5713 return ((char *) "Unknown");
5716 char *strstatus (const uint devices_status
)
5718 switch (devices_status
)
5720 case STATUS_INIT
: return ((char *) ST_0000
); break;
5721 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5722 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5723 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5724 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5725 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5726 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5727 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5728 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5729 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5732 return ((char *) "Unknown");
5735 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5737 uint hash_type
= data
.hash_type
;
5738 uint hash_mode
= data
.hash_mode
;
5739 uint salt_type
= data
.salt_type
;
5740 uint opts_type
= data
.opts_type
;
5741 uint opti_type
= data
.opti_type
;
5742 uint dgst_size
= data
.dgst_size
;
5744 char *hashfile
= data
.hashfile
;
5748 uint digest_buf
[64];
5750 u64
*digest_buf64
= (u64
*) digest_buf
;
5752 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5754 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5756 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5762 case HASH_TYPE_DESCRYPT
:
5763 FP (digest_buf
[1], digest_buf
[0], tt
);
5766 case HASH_TYPE_DESRACF
:
5767 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5768 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5770 FP (digest_buf
[1], digest_buf
[0], tt
);
5774 FP (digest_buf
[1], digest_buf
[0], tt
);
5777 case HASH_TYPE_NETNTLM
:
5778 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5779 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5780 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5781 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5783 FP (digest_buf
[1], digest_buf
[0], tt
);
5784 FP (digest_buf
[3], digest_buf
[2], tt
);
5787 case HASH_TYPE_BSDICRYPT
:
5788 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5789 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5791 FP (digest_buf
[1], digest_buf
[0], tt
);
5796 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5801 digest_buf
[0] += MD4M_A
;
5802 digest_buf
[1] += MD4M_B
;
5803 digest_buf
[2] += MD4M_C
;
5804 digest_buf
[3] += MD4M_D
;
5808 digest_buf
[0] += MD5M_A
;
5809 digest_buf
[1] += MD5M_B
;
5810 digest_buf
[2] += MD5M_C
;
5811 digest_buf
[3] += MD5M_D
;
5814 case HASH_TYPE_SHA1
:
5815 digest_buf
[0] += SHA1M_A
;
5816 digest_buf
[1] += SHA1M_B
;
5817 digest_buf
[2] += SHA1M_C
;
5818 digest_buf
[3] += SHA1M_D
;
5819 digest_buf
[4] += SHA1M_E
;
5822 case HASH_TYPE_SHA256
:
5823 digest_buf
[0] += SHA256M_A
;
5824 digest_buf
[1] += SHA256M_B
;
5825 digest_buf
[2] += SHA256M_C
;
5826 digest_buf
[3] += SHA256M_D
;
5827 digest_buf
[4] += SHA256M_E
;
5828 digest_buf
[5] += SHA256M_F
;
5829 digest_buf
[6] += SHA256M_G
;
5830 digest_buf
[7] += SHA256M_H
;
5833 case HASH_TYPE_SHA384
:
5834 digest_buf64
[0] += SHA384M_A
;
5835 digest_buf64
[1] += SHA384M_B
;
5836 digest_buf64
[2] += SHA384M_C
;
5837 digest_buf64
[3] += SHA384M_D
;
5838 digest_buf64
[4] += SHA384M_E
;
5839 digest_buf64
[5] += SHA384M_F
;
5840 digest_buf64
[6] += 0;
5841 digest_buf64
[7] += 0;
5844 case HASH_TYPE_SHA512
:
5845 digest_buf64
[0] += SHA512M_A
;
5846 digest_buf64
[1] += SHA512M_B
;
5847 digest_buf64
[2] += SHA512M_C
;
5848 digest_buf64
[3] += SHA512M_D
;
5849 digest_buf64
[4] += SHA512M_E
;
5850 digest_buf64
[5] += SHA512M_F
;
5851 digest_buf64
[6] += SHA512M_G
;
5852 digest_buf64
[7] += SHA512M_H
;
5857 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
5859 if (dgst_size
== DGST_SIZE_4_2
)
5861 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5863 else if (dgst_size
== DGST_SIZE_4_4
)
5865 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5867 else if (dgst_size
== DGST_SIZE_4_5
)
5869 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5871 else if (dgst_size
== DGST_SIZE_4_6
)
5873 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5875 else if (dgst_size
== DGST_SIZE_4_8
)
5877 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5879 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
5881 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
5883 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5885 else if (hash_type
== HASH_TYPE_SHA384
)
5887 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5889 else if (hash_type
== HASH_TYPE_SHA512
)
5891 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5893 else if (hash_type
== HASH_TYPE_GOST
)
5895 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5898 else if (dgst_size
== DGST_SIZE_4_64
)
5900 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5902 else if (dgst_size
== DGST_SIZE_8_25
)
5904 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5908 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
5909 | (data
.salt_type
== SALT_TYPE_EXTERN
)
5910 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
5916 memset (&salt
, 0, sizeof (salt_t
));
5918 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
5920 char *ptr
= (char *) salt
.salt_buf
;
5922 uint len
= salt
.salt_len
;
5924 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5930 case HASH_TYPE_NETNTLM
:
5932 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
5933 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
5935 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
5941 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
5943 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
5951 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
5953 uint max
= salt
.salt_len
/ 4;
5957 for (uint i
= 0; i
< max
; i
++)
5959 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
5963 if (opts_type
& OPTS_TYPE_ST_HEX
)
5967 memset (tmp
, 0, sizeof (tmp
));
5969 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
5971 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
5976 memcpy (ptr
, tmp
, len
);
5979 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
5981 memset (ptr
+ len
, 0, memset_size
);
5983 salt
.salt_len
= len
;
5987 // some modes require special encoding
5990 uint out_buf_plain
[256];
5991 uint out_buf_salt
[256];
5995 memset (out_buf_plain
, 0, sizeof (out_buf_plain
));
5996 memset (out_buf_salt
, 0, sizeof (out_buf_salt
));
5998 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6000 char *ptr_plain
= (char *) out_buf_plain
;
6001 char *ptr_salt
= (char *) out_buf_salt
;
6003 if (hash_mode
== 22)
6007 memset (username
, 0, sizeof (username
));
6009 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6011 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6013 u16
*ptr
= (u16
*) digest_buf
;
6015 tmp_buf
[ 0] = sig
[0];
6016 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6017 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6018 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6019 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6020 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6021 tmp_buf
[ 6] = sig
[1];
6022 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6023 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6024 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6025 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6026 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6027 tmp_buf
[12] = sig
[2];
6028 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6029 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6030 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6031 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6032 tmp_buf
[17] = sig
[3];
6033 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6034 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6035 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6036 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6037 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6038 tmp_buf
[23] = sig
[4];
6039 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6040 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6041 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6042 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6043 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6044 tmp_buf
[29] = sig
[5];
6046 snprintf (out_buf
, len
-1, "%s:%s",
6050 else if (hash_mode
== 23)
6052 // do not show the \nskyper\n part in output
6054 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6056 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6058 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6065 else if (hash_mode
== 101)
6067 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6069 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6070 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6071 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6072 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6073 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6075 memcpy (tmp_buf
, digest_buf
, 20);
6077 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6079 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6081 else if (hash_mode
== 111)
6083 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6085 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6086 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6087 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6088 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6089 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6091 memcpy (tmp_buf
, digest_buf
, 20);
6092 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6094 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6096 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6098 else if (hash_mode
== 122)
6100 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6101 (char *) salt
.salt_buf
,
6108 else if (hash_mode
== 124)
6110 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6111 (char *) salt
.salt_buf
,
6118 else if (hash_mode
== 131)
6120 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6121 (char *) salt
.salt_buf
,
6129 else if (hash_mode
== 132)
6131 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6132 (char *) salt
.salt_buf
,
6139 else if (hash_mode
== 133)
6141 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6143 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6144 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6145 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6146 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6147 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6149 memcpy (tmp_buf
, digest_buf
, 20);
6151 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6153 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6155 else if (hash_mode
== 141)
6157 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6159 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6161 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6163 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6165 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6166 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6167 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6168 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6169 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6171 memcpy (tmp_buf
, digest_buf
, 20);
6173 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6177 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6179 else if (hash_mode
== 400)
6181 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6183 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6184 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6185 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6186 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6188 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6190 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6192 else if (hash_mode
== 500)
6194 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6196 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6197 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6198 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6199 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6201 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6203 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6205 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6209 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6212 else if (hash_mode
== 501)
6214 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6216 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6217 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6219 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6221 else if (hash_mode
== 1421)
6223 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6225 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6241 else if (hash_mode
== 1441)
6243 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6245 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6247 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6249 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6251 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6252 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6253 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6254 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6255 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6256 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6257 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6258 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6260 memcpy (tmp_buf
, digest_buf
, 32);
6262 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6266 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6268 else if (hash_mode
== 1500)
6270 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6271 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6272 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6273 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6274 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6276 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6278 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6280 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6281 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6283 memcpy (tmp_buf
, digest_buf
, 8);
6285 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6287 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6291 else if (hash_mode
== 1600)
6293 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6295 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6296 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6297 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6298 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6300 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6302 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6304 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6308 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6311 else if (hash_mode
== 1711)
6313 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6315 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6316 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6317 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6318 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6319 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6320 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6321 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6322 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6324 memcpy (tmp_buf
, digest_buf
, 64);
6325 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6327 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6329 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6331 else if (hash_mode
== 1722)
6333 uint
*ptr
= digest_buf
;
6335 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6336 (unsigned char *) salt
.salt_buf
,
6346 else if (hash_mode
== 1731)
6348 uint
*ptr
= digest_buf
;
6350 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6351 (unsigned char *) salt
.salt_buf
,
6361 else if (hash_mode
== 1800)
6365 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6366 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6367 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6368 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6369 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6370 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6371 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6372 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6374 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6376 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6378 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6382 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6385 else if (hash_mode
== 2100)
6389 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6391 salt
.salt_iter
+ 1);
6393 uint signature_len
= strlen (out_buf
);
6395 pos
+= signature_len
;
6396 len
-= signature_len
;
6398 char *salt_ptr
= (char *) salt
.salt_buf
;
6400 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6402 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6403 byte_swap_32 (digest_buf
[0]),
6404 byte_swap_32 (digest_buf
[1]),
6405 byte_swap_32 (digest_buf
[2]),
6406 byte_swap_32 (digest_buf
[3]));
6408 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6410 memcpy (tmp_buf
, digest_buf
, 16);
6412 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6414 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6415 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6416 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6417 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6419 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6420 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6421 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6422 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6424 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6425 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6426 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6427 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6429 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6430 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6431 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6432 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6434 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6435 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6436 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6437 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6441 else if (hash_mode
== 2500)
6443 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6445 wpa_t
*wpa
= &wpas
[salt_pos
];
6449 char *pke_ptr
= (char *) pke
;
6451 for (uint i
= 0; i
< 25; i
++)
6453 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6456 unsigned char mac1
[6];
6457 unsigned char mac2
[6];
6459 memcpy (mac1
, pke_ptr
+ 23, 6);
6460 memcpy (mac2
, pke_ptr
+ 29, 6);
6462 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6463 (char *) salt
.salt_buf
,
6477 else if (hash_mode
== 4400)
6479 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6480 byte_swap_32 (digest_buf
[0]),
6481 byte_swap_32 (digest_buf
[1]),
6482 byte_swap_32 (digest_buf
[2]),
6483 byte_swap_32 (digest_buf
[3]));
6485 else if (hash_mode
== 4700)
6487 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6488 byte_swap_32 (digest_buf
[0]),
6489 byte_swap_32 (digest_buf
[1]),
6490 byte_swap_32 (digest_buf
[2]),
6491 byte_swap_32 (digest_buf
[3]),
6492 byte_swap_32 (digest_buf
[4]));
6494 else if (hash_mode
== 4800)
6496 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6498 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6503 byte_swap_32 (salt
.salt_buf
[0]),
6504 byte_swap_32 (salt
.salt_buf
[1]),
6505 byte_swap_32 (salt
.salt_buf
[2]),
6506 byte_swap_32 (salt
.salt_buf
[3]),
6509 else if (hash_mode
== 4900)
6511 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6512 byte_swap_32 (digest_buf
[0]),
6513 byte_swap_32 (digest_buf
[1]),
6514 byte_swap_32 (digest_buf
[2]),
6515 byte_swap_32 (digest_buf
[3]),
6516 byte_swap_32 (digest_buf
[4]));
6518 else if (hash_mode
== 5100)
6520 snprintf (out_buf
, len
-1, "%08x%08x",
6524 else if (hash_mode
== 5200)
6526 snprintf (out_buf
, len
-1, "%s", hashfile
);
6528 else if (hash_mode
== 5300)
6530 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6532 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6534 int buf_len
= len
-1;
6538 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6540 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6542 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6544 snprintf (out_buf
, buf_len
, ":");
6550 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6558 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6560 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6562 if ((i
== 0) || (i
== 5))
6564 snprintf (out_buf
, buf_len
, ":");
6570 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6578 for (uint i
= 0; i
< 4; i
++)
6582 snprintf (out_buf
, buf_len
, ":");
6588 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6594 else if (hash_mode
== 5400)
6596 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6598 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6600 int buf_len
= len
-1;
6604 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6606 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6608 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6610 snprintf (out_buf
, buf_len
, ":");
6616 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6624 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6626 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6628 if ((i
== 0) || (i
== 5))
6630 snprintf (out_buf
, buf_len
, ":");
6636 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6644 for (uint i
= 0; i
< 5; i
++)
6648 snprintf (out_buf
, buf_len
, ":");
6654 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6660 else if (hash_mode
== 5500)
6662 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6664 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6667 char domain_buf
[64];
6668 char srvchall_buf
[1024];
6669 char clichall_buf
[1024];
6671 memset (user_buf
, 0, sizeof (user_buf
));
6672 memset (domain_buf
, 0, sizeof (domain_buf
));
6673 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6674 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6676 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6678 char *ptr
= (char *) netntlm
->userdomain_buf
;
6680 user_buf
[i
] = ptr
[j
];
6683 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6685 char *ptr
= (char *) netntlm
->userdomain_buf
;
6687 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6690 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6692 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6694 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6697 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6699 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6701 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6704 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6712 byte_swap_32 (salt
.salt_buf_pc
[0]),
6713 byte_swap_32 (salt
.salt_buf_pc
[1]),
6716 else if (hash_mode
== 5600)
6718 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6720 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6723 char domain_buf
[64];
6724 char srvchall_buf
[1024];
6725 char clichall_buf
[1024];
6727 memset (user_buf
, 0, sizeof (user_buf
));
6728 memset (domain_buf
, 0, sizeof (domain_buf
));
6729 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6730 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6732 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6734 char *ptr
= (char *) netntlm
->userdomain_buf
;
6736 user_buf
[i
] = ptr
[j
];
6739 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6741 char *ptr
= (char *) netntlm
->userdomain_buf
;
6743 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6746 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6748 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6750 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6753 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6755 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6757 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6760 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6770 else if (hash_mode
== 5700)
6772 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6774 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6775 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6776 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6777 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6778 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6779 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6780 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6781 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6783 memcpy (tmp_buf
, digest_buf
, 32);
6785 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6789 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6791 else if (hash_mode
== 5800)
6793 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6794 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6795 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6796 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6797 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6799 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6806 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6808 snprintf (out_buf
, len
-1, "%s", hashfile
);
6810 else if (hash_mode
== 6300)
6812 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6814 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6815 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6816 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6817 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6819 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6821 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6823 else if (hash_mode
== 6400)
6825 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6827 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6829 else if (hash_mode
== 6500)
6831 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6833 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6835 else if (hash_mode
== 6600)
6837 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6839 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6841 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6842 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6844 uint buf_len
= len
- 1;
6846 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6849 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6851 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6856 else if (hash_mode
== 6700)
6858 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6860 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6862 else if (hash_mode
== 6800)
6864 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6866 else if (hash_mode
== 7100)
6868 uint
*ptr
= digest_buf
;
6870 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6872 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6876 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6877 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6878 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6879 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6880 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6881 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6882 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6883 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6885 snprintf (out_buf
, len
-1, "%s%i$%08x%08x%08x%08x%08x%08x%08x%08x$%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6886 SIGNATURE_SHA512OSX
,
6888 esalt
[ 0], esalt
[ 1],
6889 esalt
[ 2], esalt
[ 3],
6890 esalt
[ 4], esalt
[ 5],
6891 esalt
[ 6], esalt
[ 7],
6899 ptr
[15], ptr
[14]);
6901 else if (hash_mode
== 7200)
6903 uint
*ptr
= digest_buf
;
6905 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6907 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6911 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
6913 len_used
= strlen (out_buf
);
6915 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
6917 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
6919 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
6922 snprintf (out_buf
+ len_used
, len
- len_used
- 1, ".%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6930 ptr
[15], ptr
[14]);
6932 else if (hash_mode
== 7300)
6934 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
6936 rakp_t
*rakp
= &rakps
[salt_pos
];
6938 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
6940 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
6943 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
6950 else if (hash_mode
== 7400)
6952 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6954 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6955 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6956 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6957 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6958 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6959 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6960 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6961 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6963 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6965 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
6967 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6971 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6974 else if (hash_mode
== 7500)
6976 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
6978 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
6980 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
6981 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
6985 char *ptr_data
= data
;
6987 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
6989 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
6992 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
6994 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
6999 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7001 (char *) krb5pa
->user
,
7002 (char *) krb5pa
->realm
,
7003 (char *) krb5pa
->salt
,
7006 else if (hash_mode
== 7700)
7008 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7009 (char *) salt
.salt_buf
,
7013 else if (hash_mode
== 7800)
7015 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7016 (char *) salt
.salt_buf
,
7023 else if (hash_mode
== 7900)
7025 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7029 char *tmp
= (char *) salt
.salt_buf_pc
;
7031 ptr_plain
[42] = tmp
[0];
7037 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7039 else if (hash_mode
== 8000)
7041 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7042 (unsigned char *) salt
.salt_buf
,
7052 else if (hash_mode
== 8100)
7054 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7055 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7057 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7058 (unsigned char *) salt
.salt_buf
,
7065 else if (hash_mode
== 8200)
7067 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7069 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7071 char data_buf
[4096];
7073 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7075 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7078 data_buf
[cloudkey
->data_len
* 2] = 0;
7080 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7081 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7082 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7083 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7084 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7085 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7086 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7087 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7089 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7090 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7091 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7092 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7094 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7110 else if (hash_mode
== 8300)
7112 char digest_buf_c
[34] = { 0 };
7114 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7116 digest_buf_c
[32] = 0;
7120 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7122 char domain_buf_c
[33] = { 0 };
7124 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7126 for (uint i
= 0; i
< salt_pc_len
; i
++)
7128 const char next
= domain_buf_c
[i
];
7130 domain_buf_c
[i
] = '.';
7135 domain_buf_c
[salt_pc_len
] = 0;
7139 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7141 else if (hash_mode
== 8500)
7143 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7145 else if (hash_mode
== 2612)
7147 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7149 (char *) salt
.salt_buf
,
7155 else if (hash_mode
== 3711)
7157 char *salt_ptr
= (char *) salt
.salt_buf
;
7159 salt_ptr
[salt
.salt_len
- 1] = 0;
7161 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7162 SIGNATURE_MEDIAWIKI_B
,
7169 else if (hash_mode
== 8800)
7171 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7173 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7177 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7179 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7184 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7185 SIGNATURE_ANDROIDFDE
,
7186 byte_swap_32 (salt
.salt_buf
[0]),
7187 byte_swap_32 (salt
.salt_buf
[1]),
7188 byte_swap_32 (salt
.salt_buf
[2]),
7189 byte_swap_32 (salt
.salt_buf
[3]),
7190 byte_swap_32 (digest_buf
[0]),
7191 byte_swap_32 (digest_buf
[1]),
7192 byte_swap_32 (digest_buf
[2]),
7193 byte_swap_32 (digest_buf
[3]),
7196 else if (hash_mode
== 8900)
7198 uint N
= salt
.scrypt_N
;
7199 uint r
= salt
.scrypt_r
;
7200 uint p
= salt
.scrypt_p
;
7202 char base64_salt
[32];
7204 memset (base64_salt
, 0, 32);
7206 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7208 memset (tmp_buf
, 0, 46);
7210 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7211 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7212 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7213 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7214 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7215 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7216 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7217 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7218 digest_buf
[8] = 0; // needed for base64_encode ()
7220 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7222 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7230 else if (hash_mode
== 9000)
7232 snprintf (out_buf
, len
-1, "%s", hashfile
);
7234 else if (hash_mode
== 9200)
7238 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7240 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7242 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7246 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7247 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7248 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7249 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7250 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7251 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7252 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7253 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7254 digest_buf
[8] = 0; // needed for base64_encode ()
7257 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7259 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7260 tmp_buf
[43] = 0; // cut it here
7264 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7266 else if (hash_mode
== 9300)
7268 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7269 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7270 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7271 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7272 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7273 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7274 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7275 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7276 digest_buf
[8] = 0; // needed for base64_encode ()
7279 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7281 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7282 tmp_buf
[43] = 0; // cut it here
7284 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7286 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7288 else if (hash_mode
== 9400)
7290 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7292 office2007_t
*office2007
= &office2007s
[salt_pos
];
7294 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7295 SIGNATURE_OFFICE2007
,
7298 office2007
->keySize
,
7304 office2007
->encryptedVerifier
[0],
7305 office2007
->encryptedVerifier
[1],
7306 office2007
->encryptedVerifier
[2],
7307 office2007
->encryptedVerifier
[3],
7308 office2007
->encryptedVerifierHash
[0],
7309 office2007
->encryptedVerifierHash
[1],
7310 office2007
->encryptedVerifierHash
[2],
7311 office2007
->encryptedVerifierHash
[3],
7312 office2007
->encryptedVerifierHash
[4]);
7314 else if (hash_mode
== 9500)
7316 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7318 office2010_t
*office2010
= &office2010s
[salt_pos
];
7320 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x%08x%08x", SIGNATURE_OFFICE2010
, 2010, 100000, 128, 16,
7326 office2010
->encryptedVerifier
[0],
7327 office2010
->encryptedVerifier
[1],
7328 office2010
->encryptedVerifier
[2],
7329 office2010
->encryptedVerifier
[3],
7330 office2010
->encryptedVerifierHash
[0],
7331 office2010
->encryptedVerifierHash
[1],
7332 office2010
->encryptedVerifierHash
[2],
7333 office2010
->encryptedVerifierHash
[3],
7334 office2010
->encryptedVerifierHash
[4],
7335 office2010
->encryptedVerifierHash
[5],
7336 office2010
->encryptedVerifierHash
[6],
7337 office2010
->encryptedVerifierHash
[7]);
7339 else if (hash_mode
== 9600)
7341 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7343 office2013_t
*office2013
= &office2013s
[salt_pos
];
7345 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,
7351 office2013
->encryptedVerifier
[0],
7352 office2013
->encryptedVerifier
[1],
7353 office2013
->encryptedVerifier
[2],
7354 office2013
->encryptedVerifier
[3],
7355 office2013
->encryptedVerifierHash
[0],
7356 office2013
->encryptedVerifierHash
[1],
7357 office2013
->encryptedVerifierHash
[2],
7358 office2013
->encryptedVerifierHash
[3],
7359 office2013
->encryptedVerifierHash
[4],
7360 office2013
->encryptedVerifierHash
[5],
7361 office2013
->encryptedVerifierHash
[6],
7362 office2013
->encryptedVerifierHash
[7]);
7364 else if (hash_mode
== 9700)
7366 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7368 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7370 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7371 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7372 byte_swap_32 (salt
.salt_buf
[0]),
7373 byte_swap_32 (salt
.salt_buf
[1]),
7374 byte_swap_32 (salt
.salt_buf
[2]),
7375 byte_swap_32 (salt
.salt_buf
[3]),
7376 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7377 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7378 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7379 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7380 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7381 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7382 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7383 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7385 else if (hash_mode
== 9710)
7387 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7389 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7391 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7392 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7393 byte_swap_32 (salt
.salt_buf
[0]),
7394 byte_swap_32 (salt
.salt_buf
[1]),
7395 byte_swap_32 (salt
.salt_buf
[2]),
7396 byte_swap_32 (salt
.salt_buf
[3]),
7397 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7398 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7399 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7400 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7401 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7402 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7403 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7404 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7406 else if (hash_mode
== 9720)
7408 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7410 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7412 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7414 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7415 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7416 byte_swap_32 (salt
.salt_buf
[0]),
7417 byte_swap_32 (salt
.salt_buf
[1]),
7418 byte_swap_32 (salt
.salt_buf
[2]),
7419 byte_swap_32 (salt
.salt_buf
[3]),
7420 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7421 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7422 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7423 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7424 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7425 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7426 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7427 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7434 else if (hash_mode
== 9800)
7436 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7438 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7440 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7441 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7446 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7447 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7448 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7449 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7450 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7451 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7452 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7453 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7454 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7456 else if (hash_mode
== 9810)
7458 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7460 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7462 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7463 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7468 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7469 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7470 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7471 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7472 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7473 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7474 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7475 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7476 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7478 else if (hash_mode
== 9820)
7480 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7482 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7484 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7486 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7487 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7492 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7493 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7494 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7495 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7496 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7497 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7498 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7499 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7500 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7507 else if (hash_mode
== 10000)
7511 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7513 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7515 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7519 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7520 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7521 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7522 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7523 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7524 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7525 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7526 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7527 digest_buf
[8] = 0; // needed for base64_encode ()
7530 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7532 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7536 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7538 else if (hash_mode
== 10100)
7540 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7545 byte_swap_32 (salt
.salt_buf
[0]),
7546 byte_swap_32 (salt
.salt_buf
[1]),
7547 byte_swap_32 (salt
.salt_buf
[2]),
7548 byte_swap_32 (salt
.salt_buf
[3]));
7550 else if (hash_mode
== 10200)
7552 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7554 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7558 char challenge
[100];
7560 memset (challenge
, 0, sizeof (challenge
));
7562 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7568 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7569 (char *) cram_md5
->user
,
7577 memset (response
, 0, sizeof (response
));
7579 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7581 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7583 else if (hash_mode
== 10300)
7587 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7589 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7590 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7592 uint tmp_len
= 20 + salt
.salt_len
;
7596 char base64_encoded
[100];
7598 memset (base64_encoded
, 0, sizeof (base64_encoded
));
7600 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7602 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7604 else if (hash_mode
== 10400)
7606 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7608 pdf_t
*pdf
= &pdfs
[salt_pos
];
7610 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",
7618 byte_swap_32 (pdf
->id_buf
[0]),
7619 byte_swap_32 (pdf
->id_buf
[1]),
7620 byte_swap_32 (pdf
->id_buf
[2]),
7621 byte_swap_32 (pdf
->id_buf
[3]),
7623 byte_swap_32 (pdf
->u_buf
[0]),
7624 byte_swap_32 (pdf
->u_buf
[1]),
7625 byte_swap_32 (pdf
->u_buf
[2]),
7626 byte_swap_32 (pdf
->u_buf
[3]),
7627 byte_swap_32 (pdf
->u_buf
[4]),
7628 byte_swap_32 (pdf
->u_buf
[5]),
7629 byte_swap_32 (pdf
->u_buf
[6]),
7630 byte_swap_32 (pdf
->u_buf
[7]),
7632 byte_swap_32 (pdf
->o_buf
[0]),
7633 byte_swap_32 (pdf
->o_buf
[1]),
7634 byte_swap_32 (pdf
->o_buf
[2]),
7635 byte_swap_32 (pdf
->o_buf
[3]),
7636 byte_swap_32 (pdf
->o_buf
[4]),
7637 byte_swap_32 (pdf
->o_buf
[5]),
7638 byte_swap_32 (pdf
->o_buf
[6]),
7639 byte_swap_32 (pdf
->o_buf
[7])
7642 else if (hash_mode
== 10410)
7644 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7646 pdf_t
*pdf
= &pdfs
[salt_pos
];
7648 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",
7656 byte_swap_32 (pdf
->id_buf
[0]),
7657 byte_swap_32 (pdf
->id_buf
[1]),
7658 byte_swap_32 (pdf
->id_buf
[2]),
7659 byte_swap_32 (pdf
->id_buf
[3]),
7661 byte_swap_32 (pdf
->u_buf
[0]),
7662 byte_swap_32 (pdf
->u_buf
[1]),
7663 byte_swap_32 (pdf
->u_buf
[2]),
7664 byte_swap_32 (pdf
->u_buf
[3]),
7665 byte_swap_32 (pdf
->u_buf
[4]),
7666 byte_swap_32 (pdf
->u_buf
[5]),
7667 byte_swap_32 (pdf
->u_buf
[6]),
7668 byte_swap_32 (pdf
->u_buf
[7]),
7670 byte_swap_32 (pdf
->o_buf
[0]),
7671 byte_swap_32 (pdf
->o_buf
[1]),
7672 byte_swap_32 (pdf
->o_buf
[2]),
7673 byte_swap_32 (pdf
->o_buf
[3]),
7674 byte_swap_32 (pdf
->o_buf
[4]),
7675 byte_swap_32 (pdf
->o_buf
[5]),
7676 byte_swap_32 (pdf
->o_buf
[6]),
7677 byte_swap_32 (pdf
->o_buf
[7])
7680 else if (hash_mode
== 10420)
7682 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7684 pdf_t
*pdf
= &pdfs
[salt_pos
];
7686 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7688 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",
7696 byte_swap_32 (pdf
->id_buf
[0]),
7697 byte_swap_32 (pdf
->id_buf
[1]),
7698 byte_swap_32 (pdf
->id_buf
[2]),
7699 byte_swap_32 (pdf
->id_buf
[3]),
7701 byte_swap_32 (pdf
->u_buf
[0]),
7702 byte_swap_32 (pdf
->u_buf
[1]),
7703 byte_swap_32 (pdf
->u_buf
[2]),
7704 byte_swap_32 (pdf
->u_buf
[3]),
7705 byte_swap_32 (pdf
->u_buf
[4]),
7706 byte_swap_32 (pdf
->u_buf
[5]),
7707 byte_swap_32 (pdf
->u_buf
[6]),
7708 byte_swap_32 (pdf
->u_buf
[7]),
7710 byte_swap_32 (pdf
->o_buf
[0]),
7711 byte_swap_32 (pdf
->o_buf
[1]),
7712 byte_swap_32 (pdf
->o_buf
[2]),
7713 byte_swap_32 (pdf
->o_buf
[3]),
7714 byte_swap_32 (pdf
->o_buf
[4]),
7715 byte_swap_32 (pdf
->o_buf
[5]),
7716 byte_swap_32 (pdf
->o_buf
[6]),
7717 byte_swap_32 (pdf
->o_buf
[7]),
7725 else if (hash_mode
== 10500)
7727 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7729 pdf_t
*pdf
= &pdfs
[salt_pos
];
7731 if (pdf
->id_len
== 32)
7733 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",
7741 byte_swap_32 (pdf
->id_buf
[0]),
7742 byte_swap_32 (pdf
->id_buf
[1]),
7743 byte_swap_32 (pdf
->id_buf
[2]),
7744 byte_swap_32 (pdf
->id_buf
[3]),
7745 byte_swap_32 (pdf
->id_buf
[4]),
7746 byte_swap_32 (pdf
->id_buf
[5]),
7747 byte_swap_32 (pdf
->id_buf
[6]),
7748 byte_swap_32 (pdf
->id_buf
[7]),
7750 byte_swap_32 (pdf
->u_buf
[0]),
7751 byte_swap_32 (pdf
->u_buf
[1]),
7752 byte_swap_32 (pdf
->u_buf
[2]),
7753 byte_swap_32 (pdf
->u_buf
[3]),
7754 byte_swap_32 (pdf
->u_buf
[4]),
7755 byte_swap_32 (pdf
->u_buf
[5]),
7756 byte_swap_32 (pdf
->u_buf
[6]),
7757 byte_swap_32 (pdf
->u_buf
[7]),
7759 byte_swap_32 (pdf
->o_buf
[0]),
7760 byte_swap_32 (pdf
->o_buf
[1]),
7761 byte_swap_32 (pdf
->o_buf
[2]),
7762 byte_swap_32 (pdf
->o_buf
[3]),
7763 byte_swap_32 (pdf
->o_buf
[4]),
7764 byte_swap_32 (pdf
->o_buf
[5]),
7765 byte_swap_32 (pdf
->o_buf
[6]),
7766 byte_swap_32 (pdf
->o_buf
[7])
7771 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",
7779 byte_swap_32 (pdf
->id_buf
[0]),
7780 byte_swap_32 (pdf
->id_buf
[1]),
7781 byte_swap_32 (pdf
->id_buf
[2]),
7782 byte_swap_32 (pdf
->id_buf
[3]),
7784 byte_swap_32 (pdf
->u_buf
[0]),
7785 byte_swap_32 (pdf
->u_buf
[1]),
7786 byte_swap_32 (pdf
->u_buf
[2]),
7787 byte_swap_32 (pdf
->u_buf
[3]),
7788 byte_swap_32 (pdf
->u_buf
[4]),
7789 byte_swap_32 (pdf
->u_buf
[5]),
7790 byte_swap_32 (pdf
->u_buf
[6]),
7791 byte_swap_32 (pdf
->u_buf
[7]),
7793 byte_swap_32 (pdf
->o_buf
[0]),
7794 byte_swap_32 (pdf
->o_buf
[1]),
7795 byte_swap_32 (pdf
->o_buf
[2]),
7796 byte_swap_32 (pdf
->o_buf
[3]),
7797 byte_swap_32 (pdf
->o_buf
[4]),
7798 byte_swap_32 (pdf
->o_buf
[5]),
7799 byte_swap_32 (pdf
->o_buf
[6]),
7800 byte_swap_32 (pdf
->o_buf
[7])
7804 else if (hash_mode
== 10600)
7806 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7808 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7809 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7811 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7813 else if (hash_mode
== 10700)
7815 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7817 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7818 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7820 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7822 else if (hash_mode
== 10900)
7824 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7826 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7827 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7829 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7831 else if (hash_mode
== 11100)
7833 u32 salt_challenge
= salt
.salt_buf
[0];
7835 salt_challenge
= byte_swap_32 (salt_challenge
);
7837 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7839 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7840 SIGNATURE_POSTGRESQL_AUTH
,
7848 else if (hash_mode
== 11200)
7850 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7851 SIGNATURE_MYSQL_AUTH
,
7852 (unsigned char *) salt
.salt_buf
,
7859 else if (hash_mode
== 11300)
7861 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7863 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7865 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7866 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7867 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7869 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7870 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7871 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7873 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7875 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7877 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7880 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7882 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7884 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7887 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7889 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
7891 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7894 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
7895 SIGNATURE_BITCOIN_WALLET
,
7899 (unsigned char *) salt
.salt_buf
,
7907 free (cry_master_buf
);
7909 free (public_key_buf
);
7911 else if (hash_mode
== 11400)
7913 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7915 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7916 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7918 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7920 else if (hash_mode
== 11600)
7922 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
7924 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
7926 const uint data_len
= seven_zip
->data_len
;
7928 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
7930 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
7932 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
7934 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
7937 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
7938 SIGNATURE_SEVEN_ZIP
,
7942 (char *) seven_zip
->salt_buf
,
7944 seven_zip
->iv_buf
[0],
7945 seven_zip
->iv_buf
[1],
7946 seven_zip
->iv_buf
[2],
7947 seven_zip
->iv_buf
[3],
7949 seven_zip
->data_len
,
7950 seven_zip
->unpack_size
,
7955 else if (hash_mode
== 11700)
7957 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
7967 else if (hash_mode
== 11800)
7969 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
7987 else if (hash_mode
== 11900)
7989 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7991 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7992 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7994 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7996 else if (hash_mode
== 12000)
7998 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8000 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8001 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8003 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8005 else if (hash_mode
== 12100)
8007 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8009 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8010 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8012 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8014 else if (hash_mode
== 12200)
8016 uint
*ptr_digest
= digest_buf
;
8017 uint
*ptr_salt
= salt
.salt_buf
;
8019 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8026 else if (hash_mode
== 12300)
8028 uint
*ptr_digest
= digest_buf
;
8029 uint
*ptr_salt
= salt
.salt_buf
;
8031 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",
8032 ptr_digest
[ 0], ptr_digest
[ 1],
8033 ptr_digest
[ 2], ptr_digest
[ 3],
8034 ptr_digest
[ 4], ptr_digest
[ 5],
8035 ptr_digest
[ 6], ptr_digest
[ 7],
8036 ptr_digest
[ 8], ptr_digest
[ 9],
8037 ptr_digest
[10], ptr_digest
[11],
8038 ptr_digest
[12], ptr_digest
[13],
8039 ptr_digest
[14], ptr_digest
[15],
8045 else if (hash_mode
== 12400)
8047 // encode iteration count
8051 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8052 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8053 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8054 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8059 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8060 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8061 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8062 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8067 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8069 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8070 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8072 memcpy (tmp_buf
, digest_buf
, 8);
8074 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8078 // fill the resulting buffer
8080 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8082 else if (hash_mode
== 12500)
8084 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8086 byte_swap_32 (salt
.salt_buf
[0]),
8087 byte_swap_32 (salt
.salt_buf
[1]),
8093 else if (hash_mode
== 12600)
8095 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8096 digest_buf
[0] + salt
.salt_buf_pc
[0],
8097 digest_buf
[1] + salt
.salt_buf_pc
[1],
8098 digest_buf
[2] + salt
.salt_buf_pc
[2],
8099 digest_buf
[3] + salt
.salt_buf_pc
[3],
8100 digest_buf
[4] + salt
.salt_buf_pc
[4],
8101 digest_buf
[5] + salt
.salt_buf_pc
[5],
8102 digest_buf
[6] + salt
.salt_buf_pc
[6],
8103 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8105 else if (hash_mode
== 12700)
8107 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8109 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8110 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8112 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8114 else if (hash_mode
== 12800)
8116 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8118 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",
8131 byte_swap_32 (digest_buf
[0]),
8132 byte_swap_32 (digest_buf
[1]),
8133 byte_swap_32 (digest_buf
[2]),
8134 byte_swap_32 (digest_buf
[3]),
8135 byte_swap_32 (digest_buf
[4]),
8136 byte_swap_32 (digest_buf
[5]),
8137 byte_swap_32 (digest_buf
[6]),
8138 byte_swap_32 (digest_buf
[7])
8141 else if (hash_mode
== 12900)
8143 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",
8152 byte_swap_32 (digest_buf
[0]),
8153 byte_swap_32 (digest_buf
[1]),
8154 byte_swap_32 (digest_buf
[2]),
8155 byte_swap_32 (digest_buf
[3]),
8156 byte_swap_32 (digest_buf
[4]),
8157 byte_swap_32 (digest_buf
[5]),
8158 byte_swap_32 (digest_buf
[6]),
8159 byte_swap_32 (digest_buf
[7]),
8166 else if (hash_mode
== 13000)
8168 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8170 rar5_t
*rar5
= &rar5s
[salt_pos
];
8172 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8182 byte_swap_32 (digest_buf
[0]),
8183 byte_swap_32 (digest_buf
[1])
8188 if (hash_type
== HASH_TYPE_MD4
)
8190 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8196 else if (hash_type
== HASH_TYPE_MD5
)
8198 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8204 else if (hash_type
== HASH_TYPE_SHA1
)
8206 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8213 else if (hash_type
== HASH_TYPE_SHA256
)
8215 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8225 else if (hash_type
== HASH_TYPE_SHA384
)
8227 uint
*ptr
= digest_buf
;
8229 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8237 else if (hash_type
== HASH_TYPE_SHA512
)
8239 uint
*ptr
= digest_buf
;
8241 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8251 else if (hash_type
== HASH_TYPE_LM
)
8253 snprintf (out_buf
, len
-1, "%08x%08x",
8257 else if (hash_type
== HASH_TYPE_ORACLEH
)
8259 snprintf (out_buf
, len
-1, "%08X%08X",
8263 else if (hash_type
== HASH_TYPE_BCRYPT
)
8265 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8266 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8268 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8270 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8272 else if (hash_type
== HASH_TYPE_KECCAK
)
8274 uint
*ptr
= digest_buf
;
8276 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",
8304 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8306 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8308 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8315 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8317 digest_buf
[ 0] = digest_buf
[ 0];
8318 digest_buf
[ 1] = digest_buf
[ 1];
8319 digest_buf
[ 2] = digest_buf
[ 2];
8320 digest_buf
[ 3] = digest_buf
[ 3];
8321 digest_buf
[ 4] = digest_buf
[ 4];
8322 digest_buf
[ 5] = digest_buf
[ 5];
8323 digest_buf
[ 6] = digest_buf
[ 6];
8324 digest_buf
[ 7] = digest_buf
[ 7];
8325 digest_buf
[ 8] = digest_buf
[ 8];
8326 digest_buf
[ 9] = digest_buf
[ 9];
8327 digest_buf
[10] = digest_buf
[10];
8328 digest_buf
[11] = digest_buf
[11];
8329 digest_buf
[12] = digest_buf
[12];
8330 digest_buf
[13] = digest_buf
[13];
8331 digest_buf
[14] = digest_buf
[14];
8332 digest_buf
[15] = digest_buf
[15];
8334 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8352 else if (hash_type
== HASH_TYPE_GOST
)
8354 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8364 else if (hash_type
== HASH_TYPE_MYSQL
)
8366 snprintf (out_buf
, len
-1, "%08x%08x",
8370 else if (hash_type
== HASH_TYPE_LOTUS5
)
8372 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8378 else if (hash_type
== HASH_TYPE_LOTUS6
)
8380 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8381 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8382 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8383 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8387 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8388 memcpy (buf
+ 5, digest_buf
, 9);
8392 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8394 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8397 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8399 else if (hash_type
== HASH_TYPE_LOTUS8
)
8403 memset (buf
, 0, sizeof (buf
));
8407 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8413 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8417 buf
[26] = salt
.salt_buf_pc
[0];
8418 buf
[27] = salt
.salt_buf_pc
[1];
8422 memcpy (buf
+ 28, digest_buf
, 8);
8424 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8428 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8430 else if (hash_type
== HASH_TYPE_CRC32
)
8432 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8436 if (salt_type
== SALT_TYPE_INTERN
)
8438 size_t pos
= strlen (out_buf
);
8440 out_buf
[pos
] = data
.separator
;
8442 char *ptr
= (char *) salt
.salt_buf
;
8444 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8446 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8450 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8452 memset (hccap
, 0, sizeof (hccap_t
));
8454 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8456 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8458 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8459 wpa_t
*wpa
= &wpas
[salt_pos
];
8461 hccap
->keyver
= wpa
->keyver
;
8463 hccap
->eapol_size
= wpa
->eapol_size
;
8465 if (wpa
->keyver
!= 1)
8469 for (uint i
= 0; i
< 64; i
++)
8471 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8474 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8478 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8483 for (int i
= 5; i
< 25; i
++)
8485 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8488 char *pke_ptr
= (char *) pke_tmp
;
8490 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8491 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8492 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8493 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8495 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8497 uint dgst_size
= data
.dgst_size
;
8499 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8501 if (wpa
->keyver
!= 1)
8505 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8506 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8507 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8508 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8510 memcpy (hccap
->keymic
, digest_tmp
, 16);
8514 memcpy (hccap
->keymic
, digest_ptr
, 16);
8518 void SuspendThreads ()
8520 if (data
.devices_status
== STATUS_RUNNING
)
8522 hc_timer_set (&data
.timer_paused
);
8524 data
.devices_status
= STATUS_PAUSED
;
8526 log_info ("Paused");
8530 void ResumeThreads ()
8532 if (data
.devices_status
== STATUS_PAUSED
)
8536 hc_timer_get (data
.timer_paused
, ms_paused
);
8538 data
.ms_paused
+= ms_paused
;
8540 data
.devices_status
= STATUS_RUNNING
;
8542 log_info ("Resumed");
8548 if (data
.devices_status
!= STATUS_RUNNING
) return;
8550 data
.devices_status
= STATUS_BYPASS
;
8552 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8555 void stop_at_checkpoint ()
8557 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8559 if (data
.devices_status
!= STATUS_RUNNING
) return;
8562 // this feature only makes sense if --restore-disable was not specified
8564 if (data
.restore_disable
== 1)
8566 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8571 // check if monitoring of Restore Point updates should be enabled or disabled
8573 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8575 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8577 // save the current restore point value
8579 data
.checkpoint_cur_words
= get_lowest_words_done ();
8581 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8585 data
.devices_status
= STATUS_RUNNING
;
8587 // reset the global value for checkpoint checks
8589 data
.checkpoint_cur_words
= 0;
8591 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8597 if (data
.devices_status
== STATUS_INIT
) return;
8598 if (data
.devices_status
== STATUS_STARTING
) return;
8600 data
.devices_status
= STATUS_ABORTED
;
8605 if (data
.devices_status
== STATUS_INIT
) return;
8606 if (data
.devices_status
== STATUS_STARTING
) return;
8608 data
.devices_status
= STATUS_QUIT
;
8611 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8615 if ((fp
= fopen (kernel_file
, "rb")) != NULL
)
8619 memset (&st
, 0, sizeof (st
));
8621 stat (kernel_file
, &st
);
8623 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8625 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8627 if (num_read
!= (size_t) st
.st_size
)
8629 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8636 buf
[st
.st_size
] = 0;
8638 for (int i
= 0; i
< num_devices
; i
++)
8640 kernel_lengths
[i
] = (size_t) st
.st_size
;
8642 kernel_sources
[i
] = buf
;
8647 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8655 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8657 FILE *fp
= fopen (dst
, "wb");
8659 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8669 restore_data_t
*init_restore (int argc
, char **argv
)
8671 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8673 if (data
.restore_disable
== 0)
8675 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8679 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8683 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8692 char pidbin
[BUFSIZ
];
8697 memset (pidbin
, 0, sizeof (pidbin
));
8699 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8701 FILE *fd
= fopen (pidbin
, "rb");
8705 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8707 pidbin
[pidbin_len
] = 0;
8711 char *argv0_r
= strrchr (argv
[0], '/');
8713 char *pidbin_r
= strrchr (pidbin
, '/');
8715 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8717 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8719 if (strcmp (argv0_r
, pidbin_r
) == 0)
8721 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8728 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8730 char pidbin2
[BUFSIZ
];
8734 memset (pidbin2
, 0, sizeof (pidbin2
));
8736 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8737 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8739 pidbin
[pidbin_len
] = 0;
8740 pidbin2
[pidbin2_len
] = 0;
8744 if (strcmp (pidbin
, pidbin2
) == 0)
8746 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8754 if (rd
->version_bin
< RESTORE_MIN
)
8756 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8763 memset (rd
, 0, sizeof (restore_data_t
));
8765 rd
->version_bin
= VERSION_BIN
;
8768 rd
->pid
= getpid ();
8770 rd
->pid
= GetCurrentProcessId ();
8773 if (getcwd (rd
->cwd
, 255) == NULL
)
8786 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8788 FILE *fp
= fopen (eff_restore_file
, "rb");
8792 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8797 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8799 log_error ("ERROR: cannot read %s", eff_restore_file
);
8804 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8806 for (uint i
= 0; i
< rd
->argc
; i
++)
8810 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8812 log_error ("ERROR: cannot read %s", eff_restore_file
);
8817 size_t len
= strlen (buf
);
8819 if (len
) buf
[len
- 1] = 0;
8821 rd
->argv
[i
] = mystrdup (buf
);
8828 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8832 log_error ("Restore file is corrupted");
8835 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8837 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8839 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8844 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8848 if (chdir (rd
->cwd
))
8850 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8856 u64
get_lowest_words_done ()
8860 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8862 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8864 if (device_param
->skipped
) continue;
8866 const u64 words_done
= device_param
->words_done
;
8868 if (words_done
< words_cur
) words_cur
= words_done
;
8871 // It's possible that a device's workload isn't finished right after a restore-case.
8872 // In that case, this function would return 0 and overwrite the real restore point
8873 // There's also data.words_cur which is set to rd->words_cur but it changes while
8874 // the attack is running therefore we should stick to rd->words_cur.
8875 // Note that -s influences rd->words_cur we should keep a close look on that.
8877 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
8882 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
8884 u64 words_cur
= get_lowest_words_done ();
8886 rd
->words_cur
= words_cur
;
8888 FILE *fp
= fopen (new_restore_file
, "wb");
8892 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
8897 if (setvbuf (fp
, NULL
, _IONBF
, 0))
8899 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
8904 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
8906 for (uint i
= 0; i
< rd
->argc
; i
++)
8908 fprintf (fp
, "%s", rd
->argv
[i
]);
8914 fsync (fileno (fp
));
8919 void cycle_restore ()
8921 const char *eff_restore_file
= data
.eff_restore_file
;
8922 const char *new_restore_file
= data
.new_restore_file
;
8924 restore_data_t
*rd
= data
.rd
;
8926 write_restore (new_restore_file
, rd
);
8930 memset (&st
, 0, sizeof(st
));
8932 if (stat (eff_restore_file
, &st
) == 0)
8934 if (unlink (eff_restore_file
))
8936 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
8940 if (rename (new_restore_file
, eff_restore_file
))
8942 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
8946 void check_checkpoint ()
8948 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
8950 u64 words_cur
= get_lowest_words_done ();
8952 if (words_cur
!= data
.checkpoint_cur_words
)
8962 uint
set_kernel_accel (uint hash_mode
)
8966 case 0: return GET_ACCEL (0);
8967 case 10: return GET_ACCEL (10);
8968 case 11: return GET_ACCEL (11);
8969 case 12: return GET_ACCEL (12);
8970 case 20: return GET_ACCEL (20);
8971 case 21: return GET_ACCEL (21);
8972 case 22: return GET_ACCEL (22);
8973 case 23: return GET_ACCEL (23);
8974 case 30: return GET_ACCEL (30);
8975 case 40: return GET_ACCEL (40);
8976 case 50: return GET_ACCEL (50);
8977 case 60: return GET_ACCEL (60);
8978 case 100: return GET_ACCEL (100);
8979 case 101: return GET_ACCEL (101);
8980 case 110: return GET_ACCEL (110);
8981 case 111: return GET_ACCEL (111);
8982 case 112: return GET_ACCEL (112);
8983 case 120: return GET_ACCEL (120);
8984 case 121: return GET_ACCEL (121);
8985 case 122: return GET_ACCEL (122);
8986 case 124: return GET_ACCEL (124);
8987 case 130: return GET_ACCEL (130);
8988 case 131: return GET_ACCEL (131);
8989 case 132: return GET_ACCEL (132);
8990 case 133: return GET_ACCEL (133);
8991 case 140: return GET_ACCEL (140);
8992 case 141: return GET_ACCEL (141);
8993 case 150: return GET_ACCEL (150);
8994 case 160: return GET_ACCEL (160);
8995 case 190: return GET_ACCEL (190);
8996 case 200: return GET_ACCEL (200);
8997 case 300: return GET_ACCEL (300);
8998 case 400: return GET_ACCEL (400);
8999 case 500: return GET_ACCEL (500);
9000 case 501: return GET_ACCEL (501);
9001 case 900: return GET_ACCEL (900);
9002 case 910: return GET_ACCEL (910);
9003 case 1000: return GET_ACCEL (1000);
9004 case 1100: return GET_ACCEL (1100);
9005 case 1400: return GET_ACCEL (1400);
9006 case 1410: return GET_ACCEL (1410);
9007 case 1420: return GET_ACCEL (1420);
9008 case 1421: return GET_ACCEL (1421);
9009 case 1430: return GET_ACCEL (1430);
9010 case 1440: return GET_ACCEL (1440);
9011 case 1441: return GET_ACCEL (1441);
9012 case 1450: return GET_ACCEL (1450);
9013 case 1460: return GET_ACCEL (1460);
9014 case 1500: return GET_ACCEL (1500);
9015 case 1600: return GET_ACCEL (1600);
9016 case 1700: return GET_ACCEL (1700);
9017 case 1710: return GET_ACCEL (1710);
9018 case 1711: return GET_ACCEL (1711);
9019 case 1720: return GET_ACCEL (1720);
9020 case 1722: return GET_ACCEL (1722);
9021 case 1730: return GET_ACCEL (1730);
9022 case 1731: return GET_ACCEL (1731);
9023 case 1740: return GET_ACCEL (1740);
9024 case 1750: return GET_ACCEL (1750);
9025 case 1760: return GET_ACCEL (1760);
9026 case 1800: return GET_ACCEL (1800);
9027 case 2100: return GET_ACCEL (2100);
9028 case 2400: return GET_ACCEL (2400);
9029 case 2410: return GET_ACCEL (2410);
9030 case 2500: return GET_ACCEL (2500);
9031 case 2600: return GET_ACCEL (2600);
9032 case 2611: return GET_ACCEL (2611);
9033 case 2612: return GET_ACCEL (2612);
9034 case 2711: return GET_ACCEL (2711);
9035 case 2811: return GET_ACCEL (2811);
9036 case 3000: return GET_ACCEL (3000);
9037 case 3100: return GET_ACCEL (3100);
9038 case 3200: return GET_ACCEL (3200);
9039 case 3710: return GET_ACCEL (3710);
9040 case 3711: return GET_ACCEL (3711);
9041 case 3800: return GET_ACCEL (3800);
9042 case 4300: return GET_ACCEL (4300);
9043 case 4400: return GET_ACCEL (4400);
9044 case 4500: return GET_ACCEL (4500);
9045 case 4700: return GET_ACCEL (4700);
9046 case 4800: return GET_ACCEL (4800);
9047 case 4900: return GET_ACCEL (4900);
9048 case 5000: return GET_ACCEL (5000);
9049 case 5100: return GET_ACCEL (5100);
9050 case 5200: return GET_ACCEL (5200);
9051 case 5300: return GET_ACCEL (5300);
9052 case 5400: return GET_ACCEL (5400);
9053 case 5500: return GET_ACCEL (5500);
9054 case 5600: return GET_ACCEL (5600);
9055 case 5700: return GET_ACCEL (5700);
9056 case 5800: return GET_ACCEL (5800);
9057 case 6000: return GET_ACCEL (6000);
9058 case 6100: return GET_ACCEL (6100);
9059 case 6211: return GET_ACCEL (6211);
9060 case 6212: return GET_ACCEL (6212);
9061 case 6213: return GET_ACCEL (6213);
9062 case 6221: return GET_ACCEL (6221);
9063 case 6222: return GET_ACCEL (6222);
9064 case 6223: return GET_ACCEL (6223);
9065 case 6231: return GET_ACCEL (6231);
9066 case 6232: return GET_ACCEL (6232);
9067 case 6233: return GET_ACCEL (6233);
9068 case 6241: return GET_ACCEL (6241);
9069 case 6242: return GET_ACCEL (6242);
9070 case 6243: return GET_ACCEL (6243);
9071 case 6300: return GET_ACCEL (6300);
9072 case 6400: return GET_ACCEL (6400);
9073 case 6500: return GET_ACCEL (6500);
9074 case 6600: return GET_ACCEL (6600);
9075 case 6700: return GET_ACCEL (6700);
9076 case 6800: return GET_ACCEL (6800);
9077 case 6900: return GET_ACCEL (6900);
9078 case 7100: return GET_ACCEL (7100);
9079 case 7200: return GET_ACCEL (7200);
9080 case 7300: return GET_ACCEL (7300);
9081 case 7400: return GET_ACCEL (7400);
9082 case 7500: return GET_ACCEL (7500);
9083 case 7600: return GET_ACCEL (7600);
9084 case 7700: return GET_ACCEL (7700);
9085 case 7800: return GET_ACCEL (7800);
9086 case 7900: return GET_ACCEL (7900);
9087 case 8000: return GET_ACCEL (8000);
9088 case 8100: return GET_ACCEL (8100);
9089 case 8200: return GET_ACCEL (8200);
9090 case 8300: return GET_ACCEL (8300);
9091 case 8400: return GET_ACCEL (8400);
9092 case 8500: return GET_ACCEL (8500);
9093 case 8600: return GET_ACCEL (8600);
9094 case 8700: return GET_ACCEL (8700);
9095 case 8800: return GET_ACCEL (8800);
9096 case 8900: return GET_ACCEL (8900);
9097 case 9000: return GET_ACCEL (9000);
9098 case 9100: return GET_ACCEL (9100);
9099 case 9200: return GET_ACCEL (9200);
9100 case 9300: return GET_ACCEL (9300);
9101 case 9400: return GET_ACCEL (9400);
9102 case 9500: return GET_ACCEL (9500);
9103 case 9600: return GET_ACCEL (9600);
9104 case 9700: return GET_ACCEL (9700);
9105 case 9710: return GET_ACCEL (9710);
9106 case 9720: return GET_ACCEL (9720);
9107 case 9800: return GET_ACCEL (9800);
9108 case 9810: return GET_ACCEL (9810);
9109 case 9820: return GET_ACCEL (9820);
9110 case 9900: return GET_ACCEL (9900);
9111 case 10000: return GET_ACCEL (10000);
9112 case 10100: return GET_ACCEL (10100);
9113 case 10200: return GET_ACCEL (10200);
9114 case 10300: return GET_ACCEL (10300);
9115 case 10400: return GET_ACCEL (10400);
9116 case 10410: return GET_ACCEL (10410);
9117 case 10420: return GET_ACCEL (10420);
9118 case 10500: return GET_ACCEL (10500);
9119 case 10600: return GET_ACCEL (10600);
9120 case 10700: return GET_ACCEL (10700);
9121 case 10800: return GET_ACCEL (10800);
9122 case 10900: return GET_ACCEL (10900);
9123 case 11000: return GET_ACCEL (11000);
9124 case 11100: return GET_ACCEL (11100);
9125 case 11200: return GET_ACCEL (11200);
9126 case 11300: return GET_ACCEL (11300);
9127 case 11400: return GET_ACCEL (11400);
9128 case 11500: return GET_ACCEL (11500);
9129 case 11600: return GET_ACCEL (11600);
9130 case 11700: return GET_ACCEL (11700);
9131 case 11800: return GET_ACCEL (11800);
9132 case 11900: return GET_ACCEL (11900);
9133 case 12000: return GET_ACCEL (12000);
9134 case 12100: return GET_ACCEL (12100);
9135 case 12200: return GET_ACCEL (12200);
9136 case 12300: return GET_ACCEL (12300);
9137 case 12400: return GET_ACCEL (12400);
9138 case 12500: return GET_ACCEL (12500);
9139 case 12600: return GET_ACCEL (12600);
9140 case 12700: return GET_ACCEL (12700);
9141 case 12800: return GET_ACCEL (12800);
9142 case 12900: return GET_ACCEL (12900);
9143 case 13000: return GET_ACCEL (13000);
9149 uint
set_kernel_loops (uint hash_mode
)
9153 case 0: return GET_LOOPS (0);
9154 case 10: return GET_LOOPS (10);
9155 case 11: return GET_LOOPS (11);
9156 case 12: return GET_LOOPS (12);
9157 case 20: return GET_LOOPS (20);
9158 case 21: return GET_LOOPS (21);
9159 case 22: return GET_LOOPS (22);
9160 case 23: return GET_LOOPS (23);
9161 case 30: return GET_LOOPS (30);
9162 case 40: return GET_LOOPS (40);
9163 case 50: return GET_LOOPS (50);
9164 case 60: return GET_LOOPS (60);
9165 case 100: return GET_LOOPS (100);
9166 case 101: return GET_LOOPS (101);
9167 case 110: return GET_LOOPS (110);
9168 case 111: return GET_LOOPS (111);
9169 case 112: return GET_LOOPS (112);
9170 case 120: return GET_LOOPS (120);
9171 case 121: return GET_LOOPS (121);
9172 case 122: return GET_LOOPS (122);
9173 case 124: return GET_LOOPS (124);
9174 case 130: return GET_LOOPS (130);
9175 case 131: return GET_LOOPS (131);
9176 case 132: return GET_LOOPS (132);
9177 case 133: return GET_LOOPS (133);
9178 case 140: return GET_LOOPS (140);
9179 case 141: return GET_LOOPS (141);
9180 case 150: return GET_LOOPS (150);
9181 case 160: return GET_LOOPS (160);
9182 case 190: return GET_LOOPS (190);
9183 case 200: return GET_LOOPS (200);
9184 case 300: return GET_LOOPS (300);
9185 case 400: return GET_LOOPS (400);
9186 case 500: return GET_LOOPS (500);
9187 case 501: return GET_LOOPS (501);
9188 case 900: return GET_LOOPS (900);
9189 case 910: return GET_LOOPS (910);
9190 case 1000: return GET_LOOPS (1000);
9191 case 1100: return GET_LOOPS (1100);
9192 case 1400: return GET_LOOPS (1400);
9193 case 1410: return GET_LOOPS (1410);
9194 case 1420: return GET_LOOPS (1420);
9195 case 1421: return GET_LOOPS (1421);
9196 case 1430: return GET_LOOPS (1430);
9197 case 1440: return GET_LOOPS (1440);
9198 case 1441: return GET_LOOPS (1441);
9199 case 1450: return GET_LOOPS (1450);
9200 case 1460: return GET_LOOPS (1460);
9201 case 1500: return GET_LOOPS (1500);
9202 case 1600: return GET_LOOPS (1600);
9203 case 1700: return GET_LOOPS (1700);
9204 case 1710: return GET_LOOPS (1710);
9205 case 1711: return GET_LOOPS (1711);
9206 case 1720: return GET_LOOPS (1720);
9207 case 1722: return GET_LOOPS (1722);
9208 case 1730: return GET_LOOPS (1730);
9209 case 1731: return GET_LOOPS (1731);
9210 case 1740: return GET_LOOPS (1740);
9211 case 1750: return GET_LOOPS (1750);
9212 case 1760: return GET_LOOPS (1760);
9213 case 1800: return GET_LOOPS (1800);
9214 case 2100: return GET_LOOPS (2100);
9215 case 2400: return GET_LOOPS (2400);
9216 case 2410: return GET_LOOPS (2410);
9217 case 2500: return GET_LOOPS (2500);
9218 case 2600: return GET_LOOPS (2600);
9219 case 2611: return GET_LOOPS (2611);
9220 case 2612: return GET_LOOPS (2612);
9221 case 2711: return GET_LOOPS (2711);
9222 case 2811: return GET_LOOPS (2811);
9223 case 3000: return GET_LOOPS (3000);
9224 case 3100: return GET_LOOPS (3100);
9225 case 3200: return GET_LOOPS (3200);
9226 case 3710: return GET_LOOPS (3710);
9227 case 3711: return GET_LOOPS (3711);
9228 case 3800: return GET_LOOPS (3800);
9229 case 4300: return GET_LOOPS (4300);
9230 case 4400: return GET_LOOPS (4400);
9231 case 4500: return GET_LOOPS (4500);
9232 case 4700: return GET_LOOPS (4700);
9233 case 4800: return GET_LOOPS (4800);
9234 case 4900: return GET_LOOPS (4900);
9235 case 5000: return GET_LOOPS (5000);
9236 case 5100: return GET_LOOPS (5100);
9237 case 5200: return GET_LOOPS (5200);
9238 case 5300: return GET_LOOPS (5300);
9239 case 5400: return GET_LOOPS (5400);
9240 case 5500: return GET_LOOPS (5500);
9241 case 5600: return GET_LOOPS (5600);
9242 case 5700: return GET_LOOPS (5700);
9243 case 5800: return GET_LOOPS (5800);
9244 case 6000: return GET_LOOPS (6000);
9245 case 6100: return GET_LOOPS (6100);
9246 case 6211: return GET_LOOPS (6211);
9247 case 6212: return GET_LOOPS (6212);
9248 case 6213: return GET_LOOPS (6213);
9249 case 6221: return GET_LOOPS (6221);
9250 case 6222: return GET_LOOPS (6222);
9251 case 6223: return GET_LOOPS (6223);
9252 case 6231: return GET_LOOPS (6231);
9253 case 6232: return GET_LOOPS (6232);
9254 case 6233: return GET_LOOPS (6233);
9255 case 6241: return GET_LOOPS (6241);
9256 case 6242: return GET_LOOPS (6242);
9257 case 6243: return GET_LOOPS (6243);
9258 case 6300: return GET_LOOPS (6300);
9259 case 6400: return GET_LOOPS (6400);
9260 case 6500: return GET_LOOPS (6500);
9261 case 6600: return GET_LOOPS (6600);
9262 case 6700: return GET_LOOPS (6700);
9263 case 6800: return GET_LOOPS (6800);
9264 case 6900: return GET_LOOPS (6900);
9265 case 7100: return GET_LOOPS (7100);
9266 case 7200: return GET_LOOPS (7200);
9267 case 7300: return GET_LOOPS (7300);
9268 case 7400: return GET_LOOPS (7400);
9269 case 7500: return GET_LOOPS (7500);
9270 case 7600: return GET_LOOPS (7600);
9271 case 7700: return GET_LOOPS (7700);
9272 case 7800: return GET_LOOPS (7800);
9273 case 7900: return GET_LOOPS (7900);
9274 case 8000: return GET_LOOPS (8000);
9275 case 8100: return GET_LOOPS (8100);
9276 case 8200: return GET_LOOPS (8200);
9277 case 8300: return GET_LOOPS (8300);
9278 case 8400: return GET_LOOPS (8400);
9279 case 8500: return GET_LOOPS (8500);
9280 case 8600: return GET_LOOPS (8600);
9281 case 8700: return GET_LOOPS (8700);
9282 case 8800: return GET_LOOPS (8800);
9283 case 8900: return GET_LOOPS (8900);
9284 case 9000: return GET_LOOPS (9000);
9285 case 9100: return GET_LOOPS (9100);
9286 case 9200: return GET_LOOPS (9200);
9287 case 9300: return GET_LOOPS (9300);
9288 case 9400: return GET_LOOPS (9400);
9289 case 9500: return GET_LOOPS (9500);
9290 case 9600: return GET_LOOPS (9600);
9291 case 9700: return GET_LOOPS (9700);
9292 case 9710: return GET_LOOPS (9710);
9293 case 9720: return GET_LOOPS (9720);
9294 case 9800: return GET_LOOPS (9800);
9295 case 9810: return GET_LOOPS (9810);
9296 case 9820: return GET_LOOPS (9820);
9297 case 9900: return GET_LOOPS (9900);
9298 case 10000: return GET_LOOPS (10000);
9299 case 10100: return GET_LOOPS (10100);
9300 case 10200: return GET_LOOPS (10200);
9301 case 10300: return GET_LOOPS (10300);
9302 case 10400: return GET_LOOPS (10400);
9303 case 10410: return GET_LOOPS (10410);
9304 case 10420: return GET_LOOPS (10420);
9305 case 10500: return GET_LOOPS (10500);
9306 case 10600: return GET_LOOPS (10600);
9307 case 10700: return GET_LOOPS (10700);
9308 case 10800: return GET_LOOPS (10800);
9309 case 10900: return GET_LOOPS (10900);
9310 case 11000: return GET_LOOPS (11000);
9311 case 11100: return GET_LOOPS (11100);
9312 case 11200: return GET_LOOPS (11200);
9313 case 11300: return GET_LOOPS (11300);
9314 case 11400: return GET_LOOPS (11400);
9315 case 11500: return GET_LOOPS (11500);
9316 case 11600: return GET_LOOPS (11600);
9317 case 11700: return GET_LOOPS (11700);
9318 case 11800: return GET_LOOPS (11800);
9319 case 11900: return GET_LOOPS (11900);
9320 case 12000: return GET_LOOPS (12000);
9321 case 12100: return GET_LOOPS (12100);
9322 case 12200: return GET_LOOPS (12200);
9323 case 12300: return GET_LOOPS (12300);
9324 case 12400: return GET_LOOPS (12400);
9325 case 12500: return GET_LOOPS (12500);
9326 case 12600: return GET_LOOPS (12600);
9327 case 12700: return GET_LOOPS (12700);
9328 case 12800: return GET_LOOPS (12800);
9329 case 12900: return GET_LOOPS (12900);
9330 case 13000: return GET_LOOPS (13000);
9340 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9344 if (salt_len
> sizeof (tmp
))
9349 memset (tmp
, 0, sizeof (tmp
));
9350 memcpy (tmp
, in
, salt_len
);
9352 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9354 if ((salt_len
% 2) == 0)
9356 u32 new_salt_len
= salt_len
/ 2;
9358 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9363 tmp
[i
] = hex_convert (p1
) << 0;
9364 tmp
[i
] |= hex_convert (p0
) << 4;
9367 salt_len
= new_salt_len
;
9374 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9376 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9379 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9381 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9385 u32
*tmp_uint
= (u32
*) tmp
;
9387 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9388 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9389 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9390 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9391 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9392 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9393 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9394 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9395 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9396 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9398 salt_len
= salt_len
* 2;
9406 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9408 lowercase (tmp
, salt_len
);
9411 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9413 uppercase (tmp
, salt_len
);
9418 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9423 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9428 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9430 u32
*tmp_uint
= (uint
*) tmp
;
9436 for (u32 i
= 0; i
< max
; i
++)
9438 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9441 // Important: we may need to increase the length of memcpy since
9442 // we don't want to "loose" some swapped bytes (could happen if
9443 // they do not perfectly fit in the 4-byte blocks)
9444 // Memcpy does always copy the bytes in the BE order, but since
9445 // we swapped them, some important bytes could be in positions
9446 // we normally skip with the original len
9448 if (len
% 4) len
+= 4 - (len
% 4);
9451 memcpy (out
, tmp
, len
);
9456 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9458 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9460 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9462 u32
*digest
= (u32
*) hash_buf
->digest
;
9464 salt_t
*salt
= hash_buf
->salt
;
9466 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9468 char *iter_pos
= input_buf
+ 4;
9470 salt
->salt_iter
= 1 << atoi (iter_pos
);
9472 char *salt_pos
= strchr (iter_pos
, '$');
9474 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9480 salt
->salt_len
= salt_len
;
9484 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9486 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9488 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9490 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9492 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9493 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9494 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9495 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9497 char *hash_pos
= salt_pos
+ 22;
9499 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9501 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9503 memcpy (digest
, tmp_buf
, 24);
9505 digest
[0] = byte_swap_32 (digest
[0]);
9506 digest
[1] = byte_swap_32 (digest
[1]);
9507 digest
[2] = byte_swap_32 (digest
[2]);
9508 digest
[3] = byte_swap_32 (digest
[3]);
9509 digest
[4] = byte_swap_32 (digest
[4]);
9510 digest
[5] = byte_swap_32 (digest
[5]);
9512 digest
[5] &= ~0xff; // its just 23 not 24 !
9517 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9519 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9521 u32
*digest
= (u32
*) hash_buf
->digest
;
9525 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9527 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9529 memcpy (digest
, tmp_buf
, 32);
9531 digest
[0] = byte_swap_32 (digest
[0]);
9532 digest
[1] = byte_swap_32 (digest
[1]);
9533 digest
[2] = byte_swap_32 (digest
[2]);
9534 digest
[3] = byte_swap_32 (digest
[3]);
9535 digest
[4] = byte_swap_32 (digest
[4]);
9536 digest
[5] = byte_swap_32 (digest
[5]);
9537 digest
[6] = byte_swap_32 (digest
[6]);
9538 digest
[7] = byte_swap_32 (digest
[7]);
9540 digest
[0] -= SHA256M_A
;
9541 digest
[1] -= SHA256M_B
;
9542 digest
[2] -= SHA256M_C
;
9543 digest
[3] -= SHA256M_D
;
9544 digest
[4] -= SHA256M_E
;
9545 digest
[5] -= SHA256M_F
;
9546 digest
[6] -= SHA256M_G
;
9547 digest
[7] -= SHA256M_H
;
9552 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9554 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9556 u32
*digest
= (u32
*) hash_buf
->digest
;
9558 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9559 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9561 digest
[0] = byte_swap_32 (digest
[0]);
9562 digest
[1] = byte_swap_32 (digest
[1]);
9566 IP (digest
[0], digest
[1], tt
);
9568 digest
[0] = digest
[0];
9569 digest
[1] = digest
[1];
9576 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9578 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9580 u32
*digest
= (u32
*) hash_buf
->digest
;
9582 salt_t
*salt
= hash_buf
->salt
;
9584 char *hash_pos
= input_buf
+ 8;
9586 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9587 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9588 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9589 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9590 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9592 digest
[0] -= SHA1M_A
;
9593 digest
[1] -= SHA1M_B
;
9594 digest
[2] -= SHA1M_C
;
9595 digest
[3] -= SHA1M_D
;
9596 digest
[4] -= SHA1M_E
;
9600 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9602 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9604 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9606 salt
->salt_len
= salt_len
;
9611 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9613 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9615 u64
*digest
= (u64
*) hash_buf
->digest
;
9617 salt_t
*salt
= hash_buf
->salt
;
9619 char *hash_pos
= input_buf
+ 8;
9621 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9622 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9623 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9624 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9625 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9626 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9627 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9628 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9630 digest
[0] -= SHA512M_A
;
9631 digest
[1] -= SHA512M_B
;
9632 digest
[2] -= SHA512M_C
;
9633 digest
[3] -= SHA512M_D
;
9634 digest
[4] -= SHA512M_E
;
9635 digest
[5] -= SHA512M_F
;
9636 digest
[6] -= SHA512M_G
;
9637 digest
[7] -= SHA512M_H
;
9641 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9643 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9645 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9647 salt
->salt_len
= salt_len
;
9652 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9654 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9656 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9660 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9663 u32
*digest
= (u32
*) hash_buf
->digest
;
9665 salt_t
*salt
= hash_buf
->salt
;
9667 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9668 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9669 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9670 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9672 digest
[0] = byte_swap_32 (digest
[0]);
9673 digest
[1] = byte_swap_32 (digest
[1]);
9674 digest
[2] = byte_swap_32 (digest
[2]);
9675 digest
[3] = byte_swap_32 (digest
[3]);
9677 digest
[0] -= MD5M_A
;
9678 digest
[1] -= MD5M_B
;
9679 digest
[2] -= MD5M_C
;
9680 digest
[3] -= MD5M_D
;
9682 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9684 uint salt_len
= input_len
- 32 - 1;
9686 char *salt_buf
= input_buf
+ 32 + 1;
9688 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9690 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9692 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9694 salt
->salt_len
= salt_len
;
9699 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9701 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9703 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9707 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9712 char clean_input_buf
[32];
9714 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9715 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9717 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9721 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9727 clean_input_buf
[k
] = input_buf
[i
];
9735 u32
*digest
= (u32
*) hash_buf
->digest
;
9737 salt_t
*salt
= hash_buf
->salt
;
9739 u32 a
, b
, c
, d
, e
, f
;
9741 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9742 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9743 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9744 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9745 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9746 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9748 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9749 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9751 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9752 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9753 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9754 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9755 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9756 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9758 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9759 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9761 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9762 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9763 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9764 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9765 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9766 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9768 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9769 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9771 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9772 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9773 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9774 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9775 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9776 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9778 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9779 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9781 digest
[0] = byte_swap_32 (digest
[0]);
9782 digest
[1] = byte_swap_32 (digest
[1]);
9783 digest
[2] = byte_swap_32 (digest
[2]);
9784 digest
[3] = byte_swap_32 (digest
[3]);
9786 digest
[0] -= MD5M_A
;
9787 digest
[1] -= MD5M_B
;
9788 digest
[2] -= MD5M_C
;
9789 digest
[3] -= MD5M_D
;
9791 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9793 uint salt_len
= input_len
- 30 - 1;
9795 char *salt_buf
= input_buf
+ 30 + 1;
9797 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9799 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9801 // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
9802 if (salt_len
> 10) return (PARSER_SALT_LENGTH
);
9804 salt
->salt_len
= salt_len
;
9806 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9808 salt
->salt_len
+= 22;
9813 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9815 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9817 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9821 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9824 u32
*digest
= (u32
*) hash_buf
->digest
;
9826 salt_t
*salt
= hash_buf
->salt
;
9828 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9829 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9830 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9831 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9832 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
9834 digest
[0] -= SHA1M_A
;
9835 digest
[1] -= SHA1M_B
;
9836 digest
[2] -= SHA1M_C
;
9837 digest
[3] -= SHA1M_D
;
9838 digest
[4] -= SHA1M_E
;
9840 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9842 uint salt_len
= input_len
- 40 - 1;
9844 char *salt_buf
= input_buf
+ 40 + 1;
9846 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9848 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9850 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9852 salt
->salt_len
= salt_len
;
9857 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9859 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9861 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9865 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9868 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9870 char *iter_pos
= input_buf
+ 6;
9872 salt_t
*salt
= hash_buf
->salt
;
9874 uint iter
= atoi (iter_pos
);
9881 salt
->salt_iter
= iter
- 1;
9883 char *salt_pos
= strchr (iter_pos
, '#');
9885 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9889 char *digest_pos
= strchr (salt_pos
, '#');
9891 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9895 uint salt_len
= digest_pos
- salt_pos
- 1;
9897 u32
*digest
= (u32
*) hash_buf
->digest
;
9899 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
9900 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
9901 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
9902 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
9904 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9906 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9908 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9910 salt
->salt_len
= salt_len
;
9915 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9917 u32
*digest
= (u32
*) hash_buf
->digest
;
9919 salt_t
*salt
= hash_buf
->salt
;
9921 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
9925 memcpy (&in
, input_buf
, input_len
);
9927 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
9929 memcpy (digest
, in
.keymic
, 16);
9932 http://www.one-net.eu/jsw/j_sec/m_ptype.html
9933 The phrase "Pairwise key expansion"
9934 Access Point Address (referred to as Authenticator Address AA)
9935 Supplicant Address (referred to as Supplicant Address SA)
9936 Access Point Nonce (referred to as Authenticator Anonce)
9937 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
9940 uint salt_len
= strlen (in
.essid
);
9942 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
9944 salt
->salt_len
= salt_len
;
9946 salt
->salt_iter
= ROUNDS_WPA2
- 1;
9948 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
9950 memcpy (pke_ptr
, "Pairwise key expansion", 23);
9952 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
9954 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
9955 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
9959 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
9960 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
9963 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
9965 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
9966 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
9970 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
9971 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
9974 for (int i
= 0; i
< 25; i
++)
9976 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
9979 wpa
->keyver
= in
.keyver
;
9981 if (wpa
->keyver
> 255)
9983 log_info ("ATTENTION!");
9984 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
9985 log_info (" This could be due to a recent aircrack-ng bug.");
9986 log_info (" The key version was automatically reset to a reasonable value.");
9989 wpa
->keyver
&= 0xff;
9992 wpa
->eapol_size
= in
.eapol_size
;
9994 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
9996 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
9998 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10000 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10002 if (wpa
->keyver
== 1)
10008 digest
[0] = byte_swap_32 (digest
[0]);
10009 digest
[1] = byte_swap_32 (digest
[1]);
10010 digest
[2] = byte_swap_32 (digest
[2]);
10011 digest
[3] = byte_swap_32 (digest
[3]);
10013 for (int i
= 0; i
< 64; i
++)
10015 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10019 salt
->salt_buf
[10] = digest
[1];
10020 salt
->salt_buf
[11] = digest
[2];
10022 return (PARSER_OK
);
10025 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10027 u32
*digest
= (u32
*) hash_buf
->digest
;
10029 salt_t
*salt
= hash_buf
->salt
;
10031 if (input_len
== 0)
10033 log_error ("Password Safe v2 container not specified");
10038 FILE *fp
= fopen (input_buf
, "rb");
10042 log_error ("%s: %s", input_buf
, strerror (errno
));
10051 u32 salt
[5]; // unused, but makes better valid check
10052 u32 iv
[2]; // unused, but makes better valid check
10058 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10062 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10064 salt
->salt_buf
[0] = buf
.random
[0];
10065 salt
->salt_buf
[1] = buf
.random
[1];
10067 salt
->salt_len
= 8;
10068 salt
->salt_iter
= 1000;
10070 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10071 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10072 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10073 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10074 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10076 return (PARSER_OK
);
10079 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10081 u32
*digest
= (u32
*) hash_buf
->digest
;
10083 salt_t
*salt
= hash_buf
->salt
;
10085 if (input_len
== 0)
10087 log_error (".psafe3 not specified");
10092 FILE *fp
= fopen (input_buf
, "rb");
10096 log_error ("%s: %s", input_buf
, strerror (errno
));
10103 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10107 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10109 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10111 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10113 salt
->salt_iter
= in
.iterations
+ 1;
10115 salt
->salt_buf
[0] = in
.salt_buf
[0];
10116 salt
->salt_buf
[1] = in
.salt_buf
[1];
10117 salt
->salt_buf
[2] = in
.salt_buf
[2];
10118 salt
->salt_buf
[3] = in
.salt_buf
[3];
10119 salt
->salt_buf
[4] = in
.salt_buf
[4];
10120 salt
->salt_buf
[5] = in
.salt_buf
[5];
10121 salt
->salt_buf
[6] = in
.salt_buf
[6];
10122 salt
->salt_buf
[7] = in
.salt_buf
[7];
10124 salt
->salt_len
= 32;
10126 digest
[0] = in
.hash_buf
[0];
10127 digest
[1] = in
.hash_buf
[1];
10128 digest
[2] = in
.hash_buf
[2];
10129 digest
[3] = in
.hash_buf
[3];
10130 digest
[4] = in
.hash_buf
[4];
10131 digest
[5] = in
.hash_buf
[5];
10132 digest
[6] = in
.hash_buf
[6];
10133 digest
[7] = in
.hash_buf
[7];
10135 digest
[0] = byte_swap_32 (digest
[0]);
10136 digest
[1] = byte_swap_32 (digest
[1]);
10137 digest
[2] = byte_swap_32 (digest
[2]);
10138 digest
[3] = byte_swap_32 (digest
[3]);
10139 digest
[4] = byte_swap_32 (digest
[4]);
10140 digest
[5] = byte_swap_32 (digest
[5]);
10141 digest
[6] = byte_swap_32 (digest
[6]);
10142 digest
[7] = byte_swap_32 (digest
[7]);
10144 return (PARSER_OK
);
10147 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10149 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10151 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10153 u32
*digest
= (u32
*) hash_buf
->digest
;
10155 salt_t
*salt
= hash_buf
->salt
;
10157 char *iter_pos
= input_buf
+ 3;
10159 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10161 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10163 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10165 salt
->salt_iter
= salt_iter
;
10167 char *salt_pos
= iter_pos
+ 1;
10171 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10173 salt
->salt_len
= salt_len
;
10175 char *hash_pos
= salt_pos
+ salt_len
;
10177 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10179 return (PARSER_OK
);
10182 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10184 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10186 u32
*digest
= (u32
*) hash_buf
->digest
;
10188 salt_t
*salt
= hash_buf
->salt
;
10190 char *salt_pos
= input_buf
+ 3;
10192 uint iterations_len
= 0;
10194 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10198 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10200 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10201 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10205 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10209 iterations_len
+= 8;
10213 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10216 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10218 char *hash_pos
= strchr (salt_pos
, '$');
10220 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10222 uint salt_len
= hash_pos
- salt_pos
;
10224 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10226 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10228 salt
->salt_len
= salt_len
;
10232 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10234 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10236 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10238 return (PARSER_OK
);
10241 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10243 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10245 u32
*digest
= (u32
*) hash_buf
->digest
;
10247 salt_t
*salt
= hash_buf
->salt
;
10249 char *salt_pos
= input_buf
+ 6;
10251 uint iterations_len
= 0;
10253 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10257 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10259 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10260 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10264 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10268 iterations_len
+= 8;
10272 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10275 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10277 char *hash_pos
= strchr (salt_pos
, '$');
10279 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10281 uint salt_len
= hash_pos
- salt_pos
;
10283 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10285 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10287 salt
->salt_len
= salt_len
;
10291 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10293 return (PARSER_OK
);
10296 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10298 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10300 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10302 u32
*digest
= (u32
*) hash_buf
->digest
;
10304 salt_t
*salt
= hash_buf
->salt
;
10306 char *salt_pos
= input_buf
+ 14;
10308 char *hash_pos
= strchr (salt_pos
, '*');
10310 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10314 uint salt_len
= hash_pos
- salt_pos
- 1;
10316 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10318 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10320 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10322 salt
->salt_len
= salt_len
;
10326 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10328 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10330 memcpy (digest
, tmp_buf
, 20);
10332 digest
[0] = byte_swap_32 (digest
[0]);
10333 digest
[1] = byte_swap_32 (digest
[1]);
10334 digest
[2] = byte_swap_32 (digest
[2]);
10335 digest
[3] = byte_swap_32 (digest
[3]);
10336 digest
[4] = byte_swap_32 (digest
[4]);
10338 digest
[0] -= SHA1M_A
;
10339 digest
[1] -= SHA1M_B
;
10340 digest
[2] -= SHA1M_C
;
10341 digest
[3] -= SHA1M_D
;
10342 digest
[4] -= SHA1M_E
;
10344 return (PARSER_OK
);
10347 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10349 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10351 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10353 if (c12
& 3) return (PARSER_HASH_VALUE
);
10355 u32
*digest
= (u32
*) hash_buf
->digest
;
10357 salt_t
*salt
= hash_buf
->salt
;
10359 // for ascii_digest
10360 salt
->salt_sign
[0] = input_buf
[0];
10361 salt
->salt_sign
[1] = input_buf
[1];
10363 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10364 | itoa64_to_int (input_buf
[1]) << 6;
10366 salt
->salt_len
= 2;
10370 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10372 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10374 memcpy (digest
, tmp_buf
, 8);
10378 IP (digest
[0], digest
[1], tt
);
10383 return (PARSER_OK
);
10386 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10388 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10390 u32
*digest
= (u32
*) hash_buf
->digest
;
10392 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10393 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10394 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10395 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10397 digest
[0] = byte_swap_32 (digest
[0]);
10398 digest
[1] = byte_swap_32 (digest
[1]);
10399 digest
[2] = byte_swap_32 (digest
[2]);
10400 digest
[3] = byte_swap_32 (digest
[3]);
10402 digest
[0] -= MD4M_A
;
10403 digest
[1] -= MD4M_B
;
10404 digest
[2] -= MD4M_C
;
10405 digest
[3] -= MD4M_D
;
10407 return (PARSER_OK
);
10410 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10412 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10414 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10418 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10421 u32
*digest
= (u32
*) hash_buf
->digest
;
10423 salt_t
*salt
= hash_buf
->salt
;
10425 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10426 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10427 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10428 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10430 digest
[0] = byte_swap_32 (digest
[0]);
10431 digest
[1] = byte_swap_32 (digest
[1]);
10432 digest
[2] = byte_swap_32 (digest
[2]);
10433 digest
[3] = byte_swap_32 (digest
[3]);
10435 digest
[0] -= MD4M_A
;
10436 digest
[1] -= MD4M_B
;
10437 digest
[2] -= MD4M_C
;
10438 digest
[3] -= MD4M_D
;
10440 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10442 uint salt_len
= input_len
- 32 - 1;
10444 char *salt_buf
= input_buf
+ 32 + 1;
10446 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10448 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10450 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10452 salt
->salt_len
= salt_len
;
10454 return (PARSER_OK
);
10457 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10459 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10461 u32
*digest
= (u32
*) hash_buf
->digest
;
10463 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10464 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10465 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10466 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10468 digest
[0] = byte_swap_32 (digest
[0]);
10469 digest
[1] = byte_swap_32 (digest
[1]);
10470 digest
[2] = byte_swap_32 (digest
[2]);
10471 digest
[3] = byte_swap_32 (digest
[3]);
10473 digest
[0] -= MD5M_A
;
10474 digest
[1] -= MD5M_B
;
10475 digest
[2] -= MD5M_C
;
10476 digest
[3] -= MD5M_D
;
10478 return (PARSER_OK
);
10481 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10483 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10485 u32
*digest
= (u32
*) hash_buf
->digest
;
10487 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10488 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10492 digest
[0] = byte_swap_32 (digest
[0]);
10493 digest
[1] = byte_swap_32 (digest
[1]);
10495 return (PARSER_OK
);
10498 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10500 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10502 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10506 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10509 u32
*digest
= (u32
*) hash_buf
->digest
;
10511 salt_t
*salt
= hash_buf
->salt
;
10513 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10514 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10515 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10516 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10518 digest
[0] = byte_swap_32 (digest
[0]);
10519 digest
[1] = byte_swap_32 (digest
[1]);
10520 digest
[2] = byte_swap_32 (digest
[2]);
10521 digest
[3] = byte_swap_32 (digest
[3]);
10523 digest
[0] -= MD5M_A
;
10524 digest
[1] -= MD5M_B
;
10525 digest
[2] -= MD5M_C
;
10526 digest
[3] -= MD5M_D
;
10528 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10530 uint salt_len
= input_len
- 32 - 1;
10532 char *salt_buf
= input_buf
+ 32 + 1;
10534 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10536 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10538 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10540 salt
->salt_len
= salt_len
;
10542 return (PARSER_OK
);
10545 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10547 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10549 u32
*digest
= (u32
*) hash_buf
->digest
;
10551 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10552 | itoa64_to_int (input_buf
[ 1]) << 6
10553 | itoa64_to_int (input_buf
[ 2]) << 12
10554 | itoa64_to_int (input_buf
[ 3]) << 18;
10555 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10556 | itoa64_to_int (input_buf
[ 5]) << 6
10557 | itoa64_to_int (input_buf
[ 6]) << 12
10558 | itoa64_to_int (input_buf
[ 7]) << 18;
10559 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10560 | itoa64_to_int (input_buf
[ 9]) << 6
10561 | itoa64_to_int (input_buf
[10]) << 12
10562 | itoa64_to_int (input_buf
[11]) << 18;
10563 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10564 | itoa64_to_int (input_buf
[13]) << 6
10565 | itoa64_to_int (input_buf
[14]) << 12
10566 | itoa64_to_int (input_buf
[15]) << 18;
10568 digest
[0] -= MD5M_A
;
10569 digest
[1] -= MD5M_B
;
10570 digest
[2] -= MD5M_C
;
10571 digest
[3] -= MD5M_D
;
10573 digest
[0] &= 0x00ffffff;
10574 digest
[1] &= 0x00ffffff;
10575 digest
[2] &= 0x00ffffff;
10576 digest
[3] &= 0x00ffffff;
10578 return (PARSER_OK
);
10581 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10583 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10585 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10589 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10592 u32
*digest
= (u32
*) hash_buf
->digest
;
10594 salt_t
*salt
= hash_buf
->salt
;
10596 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10597 | itoa64_to_int (input_buf
[ 1]) << 6
10598 | itoa64_to_int (input_buf
[ 2]) << 12
10599 | itoa64_to_int (input_buf
[ 3]) << 18;
10600 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10601 | itoa64_to_int (input_buf
[ 5]) << 6
10602 | itoa64_to_int (input_buf
[ 6]) << 12
10603 | itoa64_to_int (input_buf
[ 7]) << 18;
10604 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10605 | itoa64_to_int (input_buf
[ 9]) << 6
10606 | itoa64_to_int (input_buf
[10]) << 12
10607 | itoa64_to_int (input_buf
[11]) << 18;
10608 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10609 | itoa64_to_int (input_buf
[13]) << 6
10610 | itoa64_to_int (input_buf
[14]) << 12
10611 | itoa64_to_int (input_buf
[15]) << 18;
10613 digest
[0] -= MD5M_A
;
10614 digest
[1] -= MD5M_B
;
10615 digest
[2] -= MD5M_C
;
10616 digest
[3] -= MD5M_D
;
10618 digest
[0] &= 0x00ffffff;
10619 digest
[1] &= 0x00ffffff;
10620 digest
[2] &= 0x00ffffff;
10621 digest
[3] &= 0x00ffffff;
10623 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10625 uint salt_len
= input_len
- 16 - 1;
10627 char *salt_buf
= input_buf
+ 16 + 1;
10629 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10631 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10633 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10635 salt
->salt_len
= salt_len
;
10637 return (PARSER_OK
);
10640 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10642 key
[0] = (nthash
[0] >> 0);
10643 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10644 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10645 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10646 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10647 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10648 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10649 key
[7] = (nthash
[6] << 1);
10661 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10663 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10665 u32
*digest
= (u32
*) hash_buf
->digest
;
10667 salt_t
*salt
= hash_buf
->salt
;
10669 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10675 char *user_pos
= input_buf
;
10677 char *unused_pos
= strchr (user_pos
, ':');
10679 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10681 uint user_len
= unused_pos
- user_pos
;
10683 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10687 char *domain_pos
= strchr (unused_pos
, ':');
10689 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10691 uint unused_len
= domain_pos
- unused_pos
;
10693 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10697 char *srvchall_pos
= strchr (domain_pos
, ':');
10699 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10701 uint domain_len
= srvchall_pos
- domain_pos
;
10703 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10707 char *hash_pos
= strchr (srvchall_pos
, ':');
10709 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10711 uint srvchall_len
= hash_pos
- srvchall_pos
;
10713 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10717 char *clichall_pos
= strchr (hash_pos
, ':');
10719 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10721 uint hash_len
= clichall_pos
- hash_pos
;
10723 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10727 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10729 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10732 * store some data for later use
10735 netntlm
->user_len
= user_len
* 2;
10736 netntlm
->domain_len
= domain_len
* 2;
10737 netntlm
->srvchall_len
= srvchall_len
/ 2;
10738 netntlm
->clichall_len
= clichall_len
/ 2;
10740 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10741 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10744 * handle username and domainname
10747 for (uint i
= 0; i
< user_len
; i
++)
10749 *userdomain_ptr
++ = user_pos
[i
];
10750 *userdomain_ptr
++ = 0;
10753 for (uint i
= 0; i
< domain_len
; i
++)
10755 *userdomain_ptr
++ = domain_pos
[i
];
10756 *userdomain_ptr
++ = 0;
10760 * handle server challenge encoding
10763 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10765 const char p0
= srvchall_pos
[i
+ 0];
10766 const char p1
= srvchall_pos
[i
+ 1];
10768 *chall_ptr
++ = hex_convert (p1
) << 0
10769 | hex_convert (p0
) << 4;
10773 * handle client challenge encoding
10776 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10778 const char p0
= clichall_pos
[i
+ 0];
10779 const char p1
= clichall_pos
[i
+ 1];
10781 *chall_ptr
++ = hex_convert (p1
) << 0
10782 | hex_convert (p0
) << 4;
10789 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10791 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10793 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10795 salt
->salt_len
= salt_len
;
10797 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10798 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10799 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10800 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10802 digest
[0] = byte_swap_32 (digest
[0]);
10803 digest
[1] = byte_swap_32 (digest
[1]);
10804 digest
[2] = byte_swap_32 (digest
[2]);
10805 digest
[3] = byte_swap_32 (digest
[3]);
10807 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10809 uint digest_tmp
[2];
10811 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10812 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
10814 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10815 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10817 /* special case 2: ESS */
10819 if (srvchall_len
== 48)
10821 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10825 w
[ 0] = netntlm
->chall_buf
[6];
10826 w
[ 1] = netntlm
->chall_buf
[7];
10827 w
[ 2] = netntlm
->chall_buf
[0];
10828 w
[ 3] = netntlm
->chall_buf
[1];
10851 salt
->salt_buf
[0] = dgst
[0];
10852 salt
->salt_buf
[1] = dgst
[1];
10856 /* precompute netntlmv1 exploit start */
10858 for (uint i
= 0; i
< 0x10000; i
++)
10860 uint key_md4
[2] = { i
, 0 };
10861 uint key_des
[2] = { 0, 0 };
10863 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
10868 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10870 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10872 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10874 if (data3
[0] != digest_tmp
[0]) continue;
10875 if (data3
[1] != digest_tmp
[1]) continue;
10877 salt
->salt_buf
[2] = i
;
10879 salt
->salt_len
= 24;
10884 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10885 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10887 /* precompute netntlmv1 exploit stop */
10891 IP (digest
[0], digest
[1], tt
);
10892 IP (digest
[2], digest
[3], tt
);
10894 digest
[0] = rotr32 (digest
[0], 29);
10895 digest
[1] = rotr32 (digest
[1], 29);
10896 digest
[2] = rotr32 (digest
[2], 29);
10897 digest
[3] = rotr32 (digest
[3], 29);
10899 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10901 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
10902 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
10904 return (PARSER_OK
);
10907 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10909 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10911 u32
*digest
= (u32
*) hash_buf
->digest
;
10913 salt_t
*salt
= hash_buf
->salt
;
10915 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10921 char *user_pos
= input_buf
;
10923 char *unused_pos
= strchr (user_pos
, ':');
10925 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10927 uint user_len
= unused_pos
- user_pos
;
10929 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10933 char *domain_pos
= strchr (unused_pos
, ':');
10935 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10937 uint unused_len
= domain_pos
- unused_pos
;
10939 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10943 char *srvchall_pos
= strchr (domain_pos
, ':');
10945 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10947 uint domain_len
= srvchall_pos
- domain_pos
;
10949 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10953 char *hash_pos
= strchr (srvchall_pos
, ':');
10955 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10957 uint srvchall_len
= hash_pos
- srvchall_pos
;
10959 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
10963 char *clichall_pos
= strchr (hash_pos
, ':');
10965 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10967 uint hash_len
= clichall_pos
- hash_pos
;
10969 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
10973 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10975 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
10977 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
10980 * store some data for later use
10983 netntlm
->user_len
= user_len
* 2;
10984 netntlm
->domain_len
= domain_len
* 2;
10985 netntlm
->srvchall_len
= srvchall_len
/ 2;
10986 netntlm
->clichall_len
= clichall_len
/ 2;
10988 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10989 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10992 * handle username and domainname
10995 for (uint i
= 0; i
< user_len
; i
++)
10997 *userdomain_ptr
++ = toupper (user_pos
[i
]);
10998 *userdomain_ptr
++ = 0;
11001 for (uint i
= 0; i
< domain_len
; i
++)
11003 *userdomain_ptr
++ = domain_pos
[i
];
11004 *userdomain_ptr
++ = 0;
11007 *userdomain_ptr
++ = 0x80;
11010 * handle server challenge encoding
11013 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11015 const char p0
= srvchall_pos
[i
+ 0];
11016 const char p1
= srvchall_pos
[i
+ 1];
11018 *chall_ptr
++ = hex_convert (p1
) << 0
11019 | hex_convert (p0
) << 4;
11023 * handle client challenge encoding
11026 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11028 const char p0
= clichall_pos
[i
+ 0];
11029 const char p1
= clichall_pos
[i
+ 1];
11031 *chall_ptr
++ = hex_convert (p1
) << 0
11032 | hex_convert (p0
) << 4;
11035 *chall_ptr
++ = 0x80;
11038 * handle hash itself
11041 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11042 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11043 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11044 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11046 digest
[0] = byte_swap_32 (digest
[0]);
11047 digest
[1] = byte_swap_32 (digest
[1]);
11048 digest
[2] = byte_swap_32 (digest
[2]);
11049 digest
[3] = byte_swap_32 (digest
[3]);
11052 * reuse challange data as salt_buf, its the buffer that is most likely unique
11055 salt
->salt_buf
[0] = 0;
11056 salt
->salt_buf
[1] = 0;
11057 salt
->salt_buf
[2] = 0;
11058 salt
->salt_buf
[3] = 0;
11059 salt
->salt_buf
[4] = 0;
11060 salt
->salt_buf
[5] = 0;
11061 salt
->salt_buf
[6] = 0;
11062 salt
->salt_buf
[7] = 0;
11066 uptr
= (uint
*) netntlm
->userdomain_buf
;
11068 for (uint i
= 0; i
< 16; i
+= 16)
11070 md5_64 (uptr
, salt
->salt_buf
);
11073 uptr
= (uint
*) netntlm
->chall_buf
;
11075 for (uint i
= 0; i
< 256; i
+= 16)
11077 md5_64 (uptr
, salt
->salt_buf
);
11080 salt
->salt_len
= 16;
11082 return (PARSER_OK
);
11085 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11087 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11089 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11093 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11096 u32
*digest
= (u32
*) hash_buf
->digest
;
11098 salt_t
*salt
= hash_buf
->salt
;
11100 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11101 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11102 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11103 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11105 digest
[0] = byte_swap_32 (digest
[0]);
11106 digest
[1] = byte_swap_32 (digest
[1]);
11107 digest
[2] = byte_swap_32 (digest
[2]);
11108 digest
[3] = byte_swap_32 (digest
[3]);
11110 digest
[0] -= MD5M_A
;
11111 digest
[1] -= MD5M_B
;
11112 digest
[2] -= MD5M_C
;
11113 digest
[3] -= MD5M_D
;
11115 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11117 uint salt_len
= input_len
- 32 - 1;
11119 char *salt_buf
= input_buf
+ 32 + 1;
11121 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11123 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11125 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11127 salt
->salt_len
= salt_len
;
11129 return (PARSER_OK
);
11132 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11134 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11136 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11140 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11143 u32
*digest
= (u32
*) hash_buf
->digest
;
11145 salt_t
*salt
= hash_buf
->salt
;
11147 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11148 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11149 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11150 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11152 digest
[0] = byte_swap_32 (digest
[0]);
11153 digest
[1] = byte_swap_32 (digest
[1]);
11154 digest
[2] = byte_swap_32 (digest
[2]);
11155 digest
[3] = byte_swap_32 (digest
[3]);
11157 digest
[0] -= MD5M_A
;
11158 digest
[1] -= MD5M_B
;
11159 digest
[2] -= MD5M_C
;
11160 digest
[3] -= MD5M_D
;
11162 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11164 uint salt_len
= input_len
- 32 - 1;
11166 char *salt_buf
= input_buf
+ 32 + 1;
11168 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11170 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11172 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11174 salt
->salt_len
= salt_len
;
11176 return (PARSER_OK
);
11179 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11181 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11183 u32
*digest
= (u32
*) hash_buf
->digest
;
11185 salt_t
*salt
= hash_buf
->salt
;
11187 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11188 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11189 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11190 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11192 digest
[0] = byte_swap_32 (digest
[0]);
11193 digest
[1] = byte_swap_32 (digest
[1]);
11194 digest
[2] = byte_swap_32 (digest
[2]);
11195 digest
[3] = byte_swap_32 (digest
[3]);
11197 digest
[0] -= MD5M_A
;
11198 digest
[1] -= MD5M_B
;
11199 digest
[2] -= MD5M_C
;
11200 digest
[3] -= MD5M_D
;
11203 * This is a virtual salt. While the algorithm is basically not salted
11204 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11205 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11208 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11210 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11212 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11214 salt
->salt_len
= salt_len
;
11216 return (PARSER_OK
);
11219 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11221 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11223 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11227 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11230 u32
*digest
= (u32
*) hash_buf
->digest
;
11232 salt_t
*salt
= hash_buf
->salt
;
11234 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11235 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11236 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11237 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11239 digest
[0] = byte_swap_32 (digest
[0]);
11240 digest
[1] = byte_swap_32 (digest
[1]);
11241 digest
[2] = byte_swap_32 (digest
[2]);
11242 digest
[3] = byte_swap_32 (digest
[3]);
11244 digest
[0] -= MD5M_A
;
11245 digest
[1] -= MD5M_B
;
11246 digest
[2] -= MD5M_C
;
11247 digest
[3] -= MD5M_D
;
11249 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11251 uint salt_len
= input_len
- 32 - 1;
11253 char *salt_buf
= input_buf
+ 32 + 1;
11255 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11257 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11259 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11261 salt
->salt_len
= salt_len
;
11263 return (PARSER_OK
);
11266 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11268 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11270 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11274 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11277 u32
*digest
= (u32
*) hash_buf
->digest
;
11279 salt_t
*salt
= hash_buf
->salt
;
11281 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11282 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11283 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11284 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11286 digest
[0] = byte_swap_32 (digest
[0]);
11287 digest
[1] = byte_swap_32 (digest
[1]);
11288 digest
[2] = byte_swap_32 (digest
[2]);
11289 digest
[3] = byte_swap_32 (digest
[3]);
11291 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11293 uint salt_len
= input_len
- 32 - 1;
11295 char *salt_buf
= input_buf
+ 32 + 1;
11297 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11299 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11301 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11303 salt
->salt_len
= salt_len
;
11305 return (PARSER_OK
);
11308 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11310 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11312 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11316 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11319 u32
*digest
= (u32
*) hash_buf
->digest
;
11321 salt_t
*salt
= hash_buf
->salt
;
11323 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11324 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11325 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11326 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11328 digest
[0] = byte_swap_32 (digest
[0]);
11329 digest
[1] = byte_swap_32 (digest
[1]);
11330 digest
[2] = byte_swap_32 (digest
[2]);
11331 digest
[3] = byte_swap_32 (digest
[3]);
11333 digest
[0] -= MD4M_A
;
11334 digest
[1] -= MD4M_B
;
11335 digest
[2] -= MD4M_C
;
11336 digest
[3] -= MD4M_D
;
11338 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11340 uint salt_len
= input_len
- 32 - 1;
11342 char *salt_buf
= input_buf
+ 32 + 1;
11344 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11346 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11348 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11350 salt
->salt_len
= salt_len
;
11352 return (PARSER_OK
);
11355 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11357 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11359 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11363 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11366 u32
*digest
= (u32
*) hash_buf
->digest
;
11368 salt_t
*salt
= hash_buf
->salt
;
11370 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11371 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11372 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11373 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11375 digest
[0] = byte_swap_32 (digest
[0]);
11376 digest
[1] = byte_swap_32 (digest
[1]);
11377 digest
[2] = byte_swap_32 (digest
[2]);
11378 digest
[3] = byte_swap_32 (digest
[3]);
11380 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11382 uint salt_len
= input_len
- 32 - 1;
11384 char *salt_buf
= input_buf
+ 32 + 1;
11386 uint salt_pc_block
[16];
11388 memset (salt_pc_block
, 0, sizeof (salt_pc_block
));
11390 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11392 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11394 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11396 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11398 salt_pc_block
[14] = salt_len
* 8;
11400 uint salt_pc_digest
[4];
11402 salt_pc_digest
[0] = MAGIC_A
;
11403 salt_pc_digest
[1] = MAGIC_B
;
11404 salt_pc_digest
[2] = MAGIC_C
;
11405 salt_pc_digest
[3] = MAGIC_D
;
11407 md5_64 (salt_pc_block
, salt_pc_digest
);
11409 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11410 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11411 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11412 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11414 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11416 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11418 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11420 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11421 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11422 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11423 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11425 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11427 return (PARSER_OK
);
11430 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11432 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11434 u32
*digest
= (u32
*) hash_buf
->digest
;
11436 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11437 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11438 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11439 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11440 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11442 digest
[0] -= SHA1M_A
;
11443 digest
[1] -= SHA1M_B
;
11444 digest
[2] -= SHA1M_C
;
11445 digest
[3] -= SHA1M_D
;
11446 digest
[4] -= SHA1M_E
;
11448 return (PARSER_OK
);
11451 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11453 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11455 u32
*digest
= (u32
*) hash_buf
->digest
;
11457 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11458 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11459 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11460 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11461 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11463 return (PARSER_OK
);
11466 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11468 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11470 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11474 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11477 u32
*digest
= (u32
*) hash_buf
->digest
;
11479 salt_t
*salt
= hash_buf
->salt
;
11481 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11482 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11483 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11484 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11485 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11487 digest
[0] -= SHA1M_A
;
11488 digest
[1] -= SHA1M_B
;
11489 digest
[2] -= SHA1M_C
;
11490 digest
[3] -= SHA1M_D
;
11491 digest
[4] -= SHA1M_E
;
11493 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11495 uint salt_len
= input_len
- 40 - 1;
11497 char *salt_buf
= input_buf
+ 40 + 1;
11499 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11501 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11503 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11505 salt
->salt_len
= salt_len
;
11507 return (PARSER_OK
);
11510 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11512 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11514 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11516 u32
*digest
= (u32
*) hash_buf
->digest
;
11520 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11522 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11524 memcpy (digest
, tmp_buf
, 20);
11526 digest
[0] = byte_swap_32 (digest
[0]);
11527 digest
[1] = byte_swap_32 (digest
[1]);
11528 digest
[2] = byte_swap_32 (digest
[2]);
11529 digest
[3] = byte_swap_32 (digest
[3]);
11530 digest
[4] = byte_swap_32 (digest
[4]);
11532 digest
[0] -= SHA1M_A
;
11533 digest
[1] -= SHA1M_B
;
11534 digest
[2] -= SHA1M_C
;
11535 digest
[3] -= SHA1M_D
;
11536 digest
[4] -= SHA1M_E
;
11538 return (PARSER_OK
);
11541 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11543 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11545 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11547 u32
*digest
= (u32
*) hash_buf
->digest
;
11549 salt_t
*salt
= hash_buf
->salt
;
11553 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11555 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11557 memcpy (digest
, tmp_buf
, 20);
11559 salt
->salt_len
= tmp_len
- 20;
11561 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11563 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11565 char *ptr
= (char *) salt
->salt_buf
;
11567 ptr
[salt
->salt_len
] = 0x80;
11570 digest
[0] = byte_swap_32 (digest
[0]);
11571 digest
[1] = byte_swap_32 (digest
[1]);
11572 digest
[2] = byte_swap_32 (digest
[2]);
11573 digest
[3] = byte_swap_32 (digest
[3]);
11574 digest
[4] = byte_swap_32 (digest
[4]);
11576 digest
[0] -= SHA1M_A
;
11577 digest
[1] -= SHA1M_B
;
11578 digest
[2] -= SHA1M_C
;
11579 digest
[3] -= SHA1M_D
;
11580 digest
[4] -= SHA1M_E
;
11582 return (PARSER_OK
);
11585 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11587 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11589 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11591 u32
*digest
= (u32
*) hash_buf
->digest
;
11593 salt_t
*salt
= hash_buf
->salt
;
11595 char *salt_buf
= input_buf
+ 6;
11599 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11601 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11603 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11605 salt
->salt_len
= salt_len
;
11607 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11609 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11610 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11611 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11612 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11613 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11615 digest
[0] -= SHA1M_A
;
11616 digest
[1] -= SHA1M_B
;
11617 digest
[2] -= SHA1M_C
;
11618 digest
[3] -= SHA1M_D
;
11619 digest
[4] -= SHA1M_E
;
11621 return (PARSER_OK
);
11624 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11626 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11628 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11630 u32
*digest
= (u32
*) hash_buf
->digest
;
11632 salt_t
*salt
= hash_buf
->salt
;
11634 char *salt_buf
= input_buf
+ 6;
11638 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11640 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11642 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11644 salt
->salt_len
= salt_len
;
11646 char *hash_pos
= input_buf
+ 6 + 8;
11648 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11649 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11650 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11651 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11652 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11654 digest
[0] -= SHA1M_A
;
11655 digest
[1] -= SHA1M_B
;
11656 digest
[2] -= SHA1M_C
;
11657 digest
[3] -= SHA1M_D
;
11658 digest
[4] -= SHA1M_E
;
11660 return (PARSER_OK
);
11663 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11665 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11667 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11669 u64
*digest
= (u64
*) hash_buf
->digest
;
11671 salt_t
*salt
= hash_buf
->salt
;
11673 char *salt_buf
= input_buf
+ 6;
11677 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11679 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11681 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11683 salt
->salt_len
= salt_len
;
11685 char *hash_pos
= input_buf
+ 6 + 8;
11687 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11688 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11689 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11690 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11691 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11692 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11693 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11694 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11696 digest
[0] -= SHA512M_A
;
11697 digest
[1] -= SHA512M_B
;
11698 digest
[2] -= SHA512M_C
;
11699 digest
[3] -= SHA512M_D
;
11700 digest
[4] -= SHA512M_E
;
11701 digest
[5] -= SHA512M_F
;
11702 digest
[6] -= SHA512M_G
;
11703 digest
[7] -= SHA512M_H
;
11705 return (PARSER_OK
);
11708 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11710 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11712 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11716 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11719 u32
*digest
= (u32
*) hash_buf
->digest
;
11721 salt_t
*salt
= hash_buf
->salt
;
11723 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11724 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11728 digest
[0] = byte_swap_32 (digest
[0]);
11729 digest
[1] = byte_swap_32 (digest
[1]);
11731 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11733 uint salt_len
= input_len
- 16 - 1;
11735 char *salt_buf
= input_buf
+ 16 + 1;
11737 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11739 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11741 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11743 salt
->salt_len
= salt_len
;
11745 return (PARSER_OK
);
11748 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11750 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11752 u32
*digest
= (u32
*) hash_buf
->digest
;
11754 salt_t
*salt
= hash_buf
->salt
;
11756 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11757 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11758 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11759 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11760 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11762 digest
[0] -= SHA1M_A
;
11763 digest
[1] -= SHA1M_B
;
11764 digest
[2] -= SHA1M_C
;
11765 digest
[3] -= SHA1M_D
;
11766 digest
[4] -= SHA1M_E
;
11768 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11770 uint salt_len
= input_len
- 40 - 1;
11772 char *salt_buf
= input_buf
+ 40 + 1;
11774 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11776 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11778 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11780 salt
->salt_len
= salt_len
;
11782 return (PARSER_OK
);
11785 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11787 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11789 u32
*digest
= (u32
*) hash_buf
->digest
;
11791 salt_t
*salt
= hash_buf
->salt
;
11793 char *hash_pos
= input_buf
;
11795 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11796 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11797 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
11798 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
11799 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
11800 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
11801 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
11802 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
11803 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
11804 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
11805 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
11806 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
11807 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
11808 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
11809 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
11810 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
11812 char *salt_pos
= input_buf
+ 128;
11814 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
11815 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
11816 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
11817 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
11819 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11820 salt
->salt_len
= 16;
11822 return (PARSER_OK
);
11825 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11827 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11829 u32
*digest
= (u32
*) hash_buf
->digest
;
11831 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11832 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11833 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11834 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11835 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11836 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11837 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11838 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11840 digest
[0] -= SHA256M_A
;
11841 digest
[1] -= SHA256M_B
;
11842 digest
[2] -= SHA256M_C
;
11843 digest
[3] -= SHA256M_D
;
11844 digest
[4] -= SHA256M_E
;
11845 digest
[5] -= SHA256M_F
;
11846 digest
[6] -= SHA256M_G
;
11847 digest
[7] -= SHA256M_H
;
11849 return (PARSER_OK
);
11852 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11854 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11856 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11860 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11863 u32
*digest
= (u32
*) hash_buf
->digest
;
11865 salt_t
*salt
= hash_buf
->salt
;
11867 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11868 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11869 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11870 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11871 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11872 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11873 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11874 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11876 digest
[0] -= SHA256M_A
;
11877 digest
[1] -= SHA256M_B
;
11878 digest
[2] -= SHA256M_C
;
11879 digest
[3] -= SHA256M_D
;
11880 digest
[4] -= SHA256M_E
;
11881 digest
[5] -= SHA256M_F
;
11882 digest
[6] -= SHA256M_G
;
11883 digest
[7] -= SHA256M_H
;
11885 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11887 uint salt_len
= input_len
- 64 - 1;
11889 char *salt_buf
= input_buf
+ 64 + 1;
11891 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11893 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11895 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11897 salt
->salt_len
= salt_len
;
11899 return (PARSER_OK
);
11902 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11904 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11906 u64
*digest
= (u64
*) hash_buf
->digest
;
11908 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11909 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11910 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11911 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11912 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11913 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11917 digest
[0] -= SHA384M_A
;
11918 digest
[1] -= SHA384M_B
;
11919 digest
[2] -= SHA384M_C
;
11920 digest
[3] -= SHA384M_D
;
11921 digest
[4] -= SHA384M_E
;
11922 digest
[5] -= SHA384M_F
;
11926 return (PARSER_OK
);
11929 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11931 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
11933 u64
*digest
= (u64
*) hash_buf
->digest
;
11935 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11936 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11937 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11938 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11939 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11940 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11941 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11942 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11944 digest
[0] -= SHA512M_A
;
11945 digest
[1] -= SHA512M_B
;
11946 digest
[2] -= SHA512M_C
;
11947 digest
[3] -= SHA512M_D
;
11948 digest
[4] -= SHA512M_E
;
11949 digest
[5] -= SHA512M_F
;
11950 digest
[6] -= SHA512M_G
;
11951 digest
[7] -= SHA512M_H
;
11953 return (PARSER_OK
);
11956 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11958 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11960 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
11964 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
11967 u64
*digest
= (u64
*) hash_buf
->digest
;
11969 salt_t
*salt
= hash_buf
->salt
;
11971 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11972 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11973 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11974 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11975 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11976 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11977 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11978 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11980 digest
[0] -= SHA512M_A
;
11981 digest
[1] -= SHA512M_B
;
11982 digest
[2] -= SHA512M_C
;
11983 digest
[3] -= SHA512M_D
;
11984 digest
[4] -= SHA512M_E
;
11985 digest
[5] -= SHA512M_F
;
11986 digest
[6] -= SHA512M_G
;
11987 digest
[7] -= SHA512M_H
;
11989 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11991 uint salt_len
= input_len
- 128 - 1;
11993 char *salt_buf
= input_buf
+ 128 + 1;
11995 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11997 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11999 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12001 salt
->salt_len
= salt_len
;
12003 return (PARSER_OK
);
12006 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12008 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12010 u64
*digest
= (u64
*) hash_buf
->digest
;
12012 salt_t
*salt
= hash_buf
->salt
;
12014 char *salt_pos
= input_buf
+ 3;
12016 uint iterations_len
= 0;
12018 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12022 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12024 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12025 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12029 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12033 iterations_len
+= 8;
12037 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12040 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12042 char *hash_pos
= strchr (salt_pos
, '$');
12044 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12046 uint salt_len
= hash_pos
- salt_pos
;
12048 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12050 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12052 salt
->salt_len
= salt_len
;
12056 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12058 return (PARSER_OK
);
12061 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12063 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12065 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12067 u64
*digest
= (u64
*) hash_buf
->digest
;
12069 salt_t
*salt
= hash_buf
->salt
;
12071 uint keccak_mdlen
= input_len
/ 2;
12073 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12075 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12077 digest
[i
] = byte_swap_64 (digest
[i
]);
12080 salt
->keccak_mdlen
= keccak_mdlen
;
12082 return (PARSER_OK
);
12085 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12087 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12089 u32
*digest
= (u32
*) hash_buf
->digest
;
12091 salt_t
*salt
= hash_buf
->salt
;
12093 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12096 * Parse that strange long line
12103 in_off
[0] = strtok (input_buf
, ":");
12105 in_len
[0] = strlen (in_off
[0]);
12109 for (i
= 1; i
< 9; i
++)
12111 in_off
[i
] = strtok (NULL
, ":");
12113 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12115 in_len
[i
] = strlen (in_off
[i
]);
12120 ptr
= (char *) ikepsk
->msg_buf
;
12122 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12123 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12124 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12125 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12126 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12127 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12131 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12133 ptr
= (char *) ikepsk
->nr_buf
;
12135 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12136 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12140 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12143 * Store to database
12148 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12149 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12150 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12151 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12153 digest
[0] = byte_swap_32 (digest
[0]);
12154 digest
[1] = byte_swap_32 (digest
[1]);
12155 digest
[2] = byte_swap_32 (digest
[2]);
12156 digest
[3] = byte_swap_32 (digest
[3]);
12158 salt
->salt_len
= 32;
12160 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12161 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12162 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12163 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12164 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12165 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12166 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12167 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12169 return (PARSER_OK
);
12172 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12174 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12176 u32
*digest
= (u32
*) hash_buf
->digest
;
12178 salt_t
*salt
= hash_buf
->salt
;
12180 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12183 * Parse that strange long line
12190 in_off
[0] = strtok (input_buf
, ":");
12192 in_len
[0] = strlen (in_off
[0]);
12196 for (i
= 1; i
< 9; i
++)
12198 in_off
[i
] = strtok (NULL
, ":");
12200 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12202 in_len
[i
] = strlen (in_off
[i
]);
12207 ptr
= (char *) ikepsk
->msg_buf
;
12209 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12210 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12211 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12212 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12213 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12214 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12218 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12220 ptr
= (char *) ikepsk
->nr_buf
;
12222 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12223 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12227 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12230 * Store to database
12235 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12236 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12237 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12238 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12239 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12241 salt
->salt_len
= 32;
12243 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12244 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12245 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12246 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12247 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12248 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12249 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12250 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12252 return (PARSER_OK
);
12255 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12257 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12259 u32
*digest
= (u32
*) hash_buf
->digest
;
12261 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12262 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12263 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12264 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12265 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12267 digest
[0] = byte_swap_32 (digest
[0]);
12268 digest
[1] = byte_swap_32 (digest
[1]);
12269 digest
[2] = byte_swap_32 (digest
[2]);
12270 digest
[3] = byte_swap_32 (digest
[3]);
12271 digest
[4] = byte_swap_32 (digest
[4]);
12273 return (PARSER_OK
);
12276 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12278 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12280 u32
*digest
= (u32
*) hash_buf
->digest
;
12282 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12283 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12284 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12285 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12286 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12287 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12288 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12289 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12290 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12291 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12292 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12293 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12294 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12295 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12296 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12297 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12299 return (PARSER_OK
);
12302 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12304 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12306 u32
*digest
= (u32
*) hash_buf
->digest
;
12308 salt_t
*salt
= hash_buf
->salt
;
12310 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12311 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12312 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12313 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12314 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12316 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12318 uint salt_len
= input_len
- 40 - 1;
12320 char *salt_buf
= input_buf
+ 40 + 1;
12322 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12324 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12326 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12328 salt
->salt_len
= salt_len
;
12330 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12332 return (PARSER_OK
);
12335 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12337 u32
*digest
= (u32
*) hash_buf
->digest
;
12339 salt_t
*salt
= hash_buf
->salt
;
12341 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12343 if (input_len
== 0)
12345 log_error ("TrueCrypt container not specified");
12350 FILE *fp
= fopen (input_buf
, "rb");
12354 log_error ("%s: %s", input_buf
, strerror (errno
));
12361 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12365 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12367 memcpy (tc
->salt_buf
, buf
, 64);
12369 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12371 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12373 salt
->salt_len
= 4;
12375 salt
->salt_iter
= 1000 - 1;
12377 digest
[0] = tc
->data_buf
[0];
12379 return (PARSER_OK
);
12382 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12384 u32
*digest
= (u32
*) hash_buf
->digest
;
12386 salt_t
*salt
= hash_buf
->salt
;
12388 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12390 if (input_len
== 0)
12392 log_error ("TrueCrypt container not specified");
12397 FILE *fp
= fopen (input_buf
, "rb");
12401 log_error ("%s: %s", input_buf
, strerror (errno
));
12408 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12412 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12414 memcpy (tc
->salt_buf
, buf
, 64);
12416 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12418 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12420 salt
->salt_len
= 4;
12422 salt
->salt_iter
= 2000 - 1;
12424 digest
[0] = tc
->data_buf
[0];
12426 return (PARSER_OK
);
12429 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12431 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12433 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12435 u32
*digest
= (u32
*) hash_buf
->digest
;
12437 salt_t
*salt
= hash_buf
->salt
;
12439 char *salt_pos
= input_buf
+ 6;
12441 char *hash_pos
= strchr (salt_pos
, '$');
12443 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12445 uint salt_len
= hash_pos
- salt_pos
;
12447 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12449 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12451 salt
->salt_len
= salt_len
;
12453 salt
->salt_iter
= 1000;
12457 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12459 return (PARSER_OK
);
12462 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12464 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12466 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12468 u32
*digest
= (u32
*) hash_buf
->digest
;
12470 salt_t
*salt
= hash_buf
->salt
;
12472 char *iter_pos
= input_buf
+ 7;
12474 char *salt_pos
= strchr (iter_pos
, '$');
12476 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12480 char *hash_pos
= strchr (salt_pos
, '$');
12482 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12484 uint salt_len
= hash_pos
- salt_pos
;
12486 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12488 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12490 salt
->salt_len
= salt_len
;
12492 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12494 salt
->salt_sign
[0] = atoi (salt_iter
);
12496 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12500 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12502 digest
[0] = byte_swap_32 (digest
[0]);
12503 digest
[1] = byte_swap_32 (digest
[1]);
12504 digest
[2] = byte_swap_32 (digest
[2]);
12505 digest
[3] = byte_swap_32 (digest
[3]);
12506 digest
[4] = byte_swap_32 (digest
[4]);
12508 return (PARSER_OK
);
12511 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12513 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12515 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12517 u32
*digest
= (u32
*) hash_buf
->digest
;
12519 salt_t
*salt
= hash_buf
->salt
;
12521 char *iter_pos
= input_buf
+ 9;
12523 char *salt_pos
= strchr (iter_pos
, '$');
12525 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12529 char *hash_pos
= strchr (salt_pos
, '$');
12531 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12533 uint salt_len
= hash_pos
- salt_pos
;
12535 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12537 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12539 salt
->salt_len
= salt_len
;
12541 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12543 salt
->salt_sign
[0] = atoi (salt_iter
);
12545 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12549 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12551 digest
[0] = byte_swap_32 (digest
[0]);
12552 digest
[1] = byte_swap_32 (digest
[1]);
12553 digest
[2] = byte_swap_32 (digest
[2]);
12554 digest
[3] = byte_swap_32 (digest
[3]);
12555 digest
[4] = byte_swap_32 (digest
[4]);
12556 digest
[5] = byte_swap_32 (digest
[5]);
12557 digest
[6] = byte_swap_32 (digest
[6]);
12558 digest
[7] = byte_swap_32 (digest
[7]);
12560 return (PARSER_OK
);
12563 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12565 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12567 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12569 u64
*digest
= (u64
*) hash_buf
->digest
;
12571 salt_t
*salt
= hash_buf
->salt
;
12573 char *iter_pos
= input_buf
+ 9;
12575 char *salt_pos
= strchr (iter_pos
, '$');
12577 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12581 char *hash_pos
= strchr (salt_pos
, '$');
12583 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12585 uint salt_len
= hash_pos
- salt_pos
;
12587 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12589 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12591 salt
->salt_len
= salt_len
;
12593 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12595 salt
->salt_sign
[0] = atoi (salt_iter
);
12597 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12601 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12603 digest
[0] = byte_swap_64 (digest
[0]);
12604 digest
[1] = byte_swap_64 (digest
[1]);
12605 digest
[2] = byte_swap_64 (digest
[2]);
12606 digest
[3] = byte_swap_64 (digest
[3]);
12607 digest
[4] = byte_swap_64 (digest
[4]);
12608 digest
[5] = byte_swap_64 (digest
[5]);
12609 digest
[6] = byte_swap_64 (digest
[6]);
12610 digest
[7] = byte_swap_64 (digest
[7]);
12612 return (PARSER_OK
);
12615 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12617 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12619 u32
*digest
= (u32
*) hash_buf
->digest
;
12621 salt_t
*salt
= hash_buf
->salt
;
12623 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12629 char *iterations_pos
= input_buf
;
12631 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12633 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12635 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12637 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12641 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12643 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12645 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12647 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12649 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12651 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12656 * pbkdf2 iterations
12659 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12662 * handle salt encoding
12665 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12667 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12669 const char p0
= saltbuf_pos
[i
+ 0];
12670 const char p1
= saltbuf_pos
[i
+ 1];
12672 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12673 | hex_convert (p0
) << 4;
12676 salt
->salt_len
= saltbuf_len
/ 2;
12679 * handle cipher encoding
12682 uint
*tmp
= (uint
*) mymalloc (32);
12684 char *cipherbuf_ptr
= (char *) tmp
;
12686 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12688 const char p0
= cipherbuf_pos
[i
+ 0];
12689 const char p1
= cipherbuf_pos
[i
+ 1];
12691 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12692 | hex_convert (p0
) << 4;
12695 // iv is stored at salt_buf 4 (length 16)
12696 // data is stored at salt_buf 8 (length 16)
12698 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12699 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12700 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12701 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12703 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12704 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12705 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12706 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12710 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12712 const char p0
= cipherbuf_pos
[j
+ 0];
12713 const char p1
= cipherbuf_pos
[j
+ 1];
12715 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12716 | hex_convert (p0
) << 4;
12723 digest
[0] = 0x10101010;
12724 digest
[1] = 0x10101010;
12725 digest
[2] = 0x10101010;
12726 digest
[3] = 0x10101010;
12728 return (PARSER_OK
);
12731 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12733 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12735 u32
*digest
= (u32
*) hash_buf
->digest
;
12737 salt_t
*salt
= hash_buf
->salt
;
12739 char *hashbuf_pos
= input_buf
;
12741 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12743 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12745 uint hash_len
= iterations_pos
- hashbuf_pos
;
12747 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12751 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12753 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12755 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12759 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12761 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12763 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12765 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12767 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12769 salt
->salt_len
= salt_len
;
12771 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12773 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
12774 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
12775 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
12776 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
12778 return (PARSER_OK
);
12781 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12783 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12785 u32
*digest
= (u32
*) hash_buf
->digest
;
12787 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12788 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12789 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12790 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12791 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12792 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12793 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12794 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12796 digest
[0] = byte_swap_32 (digest
[0]);
12797 digest
[1] = byte_swap_32 (digest
[1]);
12798 digest
[2] = byte_swap_32 (digest
[2]);
12799 digest
[3] = byte_swap_32 (digest
[3]);
12800 digest
[4] = byte_swap_32 (digest
[4]);
12801 digest
[5] = byte_swap_32 (digest
[5]);
12802 digest
[6] = byte_swap_32 (digest
[6]);
12803 digest
[7] = byte_swap_32 (digest
[7]);
12805 return (PARSER_OK
);
12808 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12810 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12812 u32
*digest
= (u32
*) hash_buf
->digest
;
12814 salt_t
*salt
= hash_buf
->salt
;
12816 char *salt_pos
= input_buf
+ 3;
12818 uint iterations_len
= 0;
12820 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12824 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12826 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12827 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12831 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12835 iterations_len
+= 8;
12839 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12842 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12844 char *hash_pos
= strchr (salt_pos
, '$');
12846 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12848 uint salt_len
= hash_pos
- salt_pos
;
12850 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12852 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12854 salt
->salt_len
= salt_len
;
12858 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12860 return (PARSER_OK
);
12863 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12865 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12867 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12869 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12871 u64
*digest
= (u64
*) hash_buf
->digest
;
12873 salt_t
*salt
= hash_buf
->salt
;
12875 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12877 char *iter_pos
= input_buf
+ 4;
12879 char *salt_pos
= strchr (iter_pos
, '$');
12881 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12885 char *hash_pos
= strchr (salt_pos
, '$');
12887 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12889 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12893 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12894 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12895 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12896 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12897 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12898 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12899 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12900 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12902 uint salt_len
= hash_pos
- salt_pos
- 1;
12904 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12906 salt
->salt_len
= salt_len
/ 2;
12908 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12909 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12910 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12911 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12912 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
12913 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
12914 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
12915 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
12917 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12918 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12919 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12920 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12921 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12922 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12923 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12924 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12925 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12926 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12928 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12930 salt
->salt_iter
= atoi (iter_pos
) - 1;
12932 return (PARSER_OK
);
12935 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12937 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12939 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12941 u32
*digest
= (u32
*) hash_buf
->digest
;
12943 salt_t
*salt
= hash_buf
->salt
;
12945 char *salt_pos
= input_buf
+ 14;
12947 char *hash_pos
= strchr (salt_pos
, '*');
12949 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12953 uint salt_len
= hash_pos
- salt_pos
- 1;
12955 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12957 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
12959 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12961 salt
->salt_len
= salt_len
;
12965 memset (tmp_buf
, 0, sizeof (tmp_buf
));
12967 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
12969 memcpy (digest
, tmp_buf
, 32);
12971 digest
[0] = byte_swap_32 (digest
[0]);
12972 digest
[1] = byte_swap_32 (digest
[1]);
12973 digest
[2] = byte_swap_32 (digest
[2]);
12974 digest
[3] = byte_swap_32 (digest
[3]);
12975 digest
[4] = byte_swap_32 (digest
[4]);
12976 digest
[5] = byte_swap_32 (digest
[5]);
12977 digest
[6] = byte_swap_32 (digest
[6]);
12978 digest
[7] = byte_swap_32 (digest
[7]);
12980 digest
[0] -= SHA256M_A
;
12981 digest
[1] -= SHA256M_B
;
12982 digest
[2] -= SHA256M_C
;
12983 digest
[3] -= SHA256M_D
;
12984 digest
[4] -= SHA256M_E
;
12985 digest
[5] -= SHA256M_F
;
12986 digest
[6] -= SHA256M_G
;
12987 digest
[7] -= SHA256M_H
;
12989 return (PARSER_OK
);
12992 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12994 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
12996 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12998 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13000 u64
*digest
= (u64
*) hash_buf
->digest
;
13002 salt_t
*salt
= hash_buf
->salt
;
13004 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13006 char *iter_pos
= input_buf
+ 19;
13008 char *salt_pos
= strchr (iter_pos
, '.');
13010 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13014 char *hash_pos
= strchr (salt_pos
, '.');
13016 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13018 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13022 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13023 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13024 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13025 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13026 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13027 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13028 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13029 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13031 uint salt_len
= hash_pos
- salt_pos
- 1;
13035 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13039 for (i
= 0; i
< salt_len
; i
++)
13041 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13044 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13045 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13047 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13049 salt
->salt_len
= salt_len
;
13051 salt
->salt_iter
= atoi (iter_pos
) - 1;
13053 return (PARSER_OK
);
13056 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13058 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13060 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13062 u64
*digest
= (u64
*) hash_buf
->digest
;
13064 salt_t
*salt
= hash_buf
->salt
;
13068 memset (tmp_buf
, 0, sizeof (tmp_buf
));
13070 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13072 memcpy (digest
, tmp_buf
, 64);
13074 digest
[0] = byte_swap_64 (digest
[0]);
13075 digest
[1] = byte_swap_64 (digest
[1]);
13076 digest
[2] = byte_swap_64 (digest
[2]);
13077 digest
[3] = byte_swap_64 (digest
[3]);
13078 digest
[4] = byte_swap_64 (digest
[4]);
13079 digest
[5] = byte_swap_64 (digest
[5]);
13080 digest
[6] = byte_swap_64 (digest
[6]);
13081 digest
[7] = byte_swap_64 (digest
[7]);
13083 digest
[0] -= SHA512M_A
;
13084 digest
[1] -= SHA512M_B
;
13085 digest
[2] -= SHA512M_C
;
13086 digest
[3] -= SHA512M_D
;
13087 digest
[4] -= SHA512M_E
;
13088 digest
[5] -= SHA512M_F
;
13089 digest
[6] -= SHA512M_G
;
13090 digest
[7] -= SHA512M_H
;
13092 salt
->salt_len
= tmp_len
- 64;
13094 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13096 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13098 char *ptr
= (char *) salt
->salt_buf
;
13100 ptr
[salt
->salt_len
] = 0x80;
13103 return (PARSER_OK
);
13106 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13108 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13110 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13114 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13117 u32
*digest
= (u32
*) hash_buf
->digest
;
13119 salt_t
*salt
= hash_buf
->salt
;
13121 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13122 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13123 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13124 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13126 digest
[0] = byte_swap_32 (digest
[0]);
13127 digest
[1] = byte_swap_32 (digest
[1]);
13128 digest
[2] = byte_swap_32 (digest
[2]);
13129 digest
[3] = byte_swap_32 (digest
[3]);
13131 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13133 uint salt_len
= input_len
- 32 - 1;
13135 char *salt_buf
= input_buf
+ 32 + 1;
13137 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13139 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13141 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13143 salt
->salt_len
= salt_len
;
13145 return (PARSER_OK
);
13148 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13150 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13152 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13156 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13159 u32
*digest
= (u32
*) hash_buf
->digest
;
13161 salt_t
*salt
= hash_buf
->salt
;
13163 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13164 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13165 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13166 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13167 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13169 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13171 uint salt_len
= input_len
- 40 - 1;
13173 char *salt_buf
= input_buf
+ 40 + 1;
13175 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13177 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13179 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13181 salt
->salt_len
= salt_len
;
13183 return (PARSER_OK
);
13186 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13188 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13190 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13194 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13197 u32
*digest
= (u32
*) hash_buf
->digest
;
13199 salt_t
*salt
= hash_buf
->salt
;
13201 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13202 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13203 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13204 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13205 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13206 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13207 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13208 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13210 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13212 uint salt_len
= input_len
- 64 - 1;
13214 char *salt_buf
= input_buf
+ 64 + 1;
13216 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13218 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13220 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13222 salt
->salt_len
= salt_len
;
13224 return (PARSER_OK
);
13227 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13229 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13231 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13235 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13238 u64
*digest
= (u64
*) hash_buf
->digest
;
13240 salt_t
*salt
= hash_buf
->salt
;
13242 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13243 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13244 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13245 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13246 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13247 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13248 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13249 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13251 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13253 uint salt_len
= input_len
- 128 - 1;
13255 char *salt_buf
= input_buf
+ 128 + 1;
13257 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13259 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13261 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13263 salt
->salt_len
= salt_len
;
13265 return (PARSER_OK
);
13268 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13270 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13272 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13274 u32
*digest
= (u32
*) hash_buf
->digest
;
13276 salt_t
*salt
= hash_buf
->salt
;
13278 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13284 char *user_pos
= input_buf
+ 10 + 1;
13286 char *realm_pos
= strchr (user_pos
, '$');
13288 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13290 uint user_len
= realm_pos
- user_pos
;
13292 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13296 char *salt_pos
= strchr (realm_pos
, '$');
13298 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13300 uint realm_len
= salt_pos
- realm_pos
;
13302 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13306 char *data_pos
= strchr (salt_pos
, '$');
13308 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13310 uint salt_len
= data_pos
- salt_pos
;
13312 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13316 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13318 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13324 memcpy (krb5pa
->user
, user_pos
, user_len
);
13325 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13326 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13328 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13330 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13332 const char p0
= data_pos
[i
+ 0];
13333 const char p1
= data_pos
[i
+ 1];
13335 *timestamp_ptr
++ = hex_convert (p1
) << 0
13336 | hex_convert (p0
) << 4;
13339 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13341 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13343 const char p0
= data_pos
[i
+ 0];
13344 const char p1
= data_pos
[i
+ 1];
13346 *checksum_ptr
++ = hex_convert (p1
) << 0
13347 | hex_convert (p0
) << 4;
13351 * copy some data to generic buffers to make sorting happy
13354 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13355 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13356 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13357 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13358 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13359 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13360 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13361 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13362 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13364 salt
->salt_len
= 36;
13366 digest
[0] = krb5pa
->checksum
[0];
13367 digest
[1] = krb5pa
->checksum
[1];
13368 digest
[2] = krb5pa
->checksum
[2];
13369 digest
[3] = krb5pa
->checksum
[3];
13371 return (PARSER_OK
);
13374 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13376 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13378 u32
*digest
= (u32
*) hash_buf
->digest
;
13380 salt_t
*salt
= hash_buf
->salt
;
13386 char *salt_pos
= input_buf
;
13388 char *hash_pos
= strchr (salt_pos
, '$');
13390 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13392 uint salt_len
= hash_pos
- salt_pos
;
13394 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13398 uint hash_len
= input_len
- 1 - salt_len
;
13400 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13408 for (uint i
= 0; i
< salt_len
; i
++)
13410 if (salt_pos
[i
] == ' ') continue;
13415 // SAP user names cannot be longer than 12 characters
13416 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13418 // SAP user name cannot start with ! or ?
13419 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13425 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13427 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13429 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13431 salt
->salt_len
= salt_len
;
13433 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13434 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13438 digest
[0] = byte_swap_32 (digest
[0]);
13439 digest
[1] = byte_swap_32 (digest
[1]);
13441 return (PARSER_OK
);
13444 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13446 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13448 u32
*digest
= (u32
*) hash_buf
->digest
;
13450 salt_t
*salt
= hash_buf
->salt
;
13456 char *salt_pos
= input_buf
;
13458 char *hash_pos
= strchr (salt_pos
, '$');
13460 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13462 uint salt_len
= hash_pos
- salt_pos
;
13464 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13468 uint hash_len
= input_len
- 1 - salt_len
;
13470 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13478 for (uint i
= 0; i
< salt_len
; i
++)
13480 if (salt_pos
[i
] == ' ') continue;
13485 // SAP user names cannot be longer than 12 characters
13486 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13487 // so far nobody complained so we stay with this because it helps in optimization
13488 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13490 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13492 // SAP user name cannot start with ! or ?
13493 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13499 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13501 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13503 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13505 salt
->salt_len
= salt_len
;
13507 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13508 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13509 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13510 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13511 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13513 return (PARSER_OK
);
13516 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13518 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13520 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13522 u64
*digest
= (u64
*) hash_buf
->digest
;
13524 salt_t
*salt
= hash_buf
->salt
;
13526 char *iter_pos
= input_buf
+ 3;
13528 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13530 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13532 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13534 salt
->salt_iter
= salt_iter
;
13536 char *salt_pos
= iter_pos
+ 1;
13540 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13542 salt
->salt_len
= salt_len
;
13544 char *hash_pos
= salt_pos
+ salt_len
;
13546 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13550 char *tmp
= (char *) salt
->salt_buf_pc
;
13552 tmp
[0] = hash_pos
[42];
13556 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13557 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13558 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13559 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13565 return (PARSER_OK
);
13568 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13570 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13572 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13574 u32
*digest
= (u32
*) hash_buf
->digest
;
13576 salt_t
*salt
= hash_buf
->salt
;
13578 char *salt_buf
= input_buf
+ 6;
13580 uint salt_len
= 16;
13582 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13584 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13586 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13588 salt
->salt_len
= salt_len
;
13590 char *hash_pos
= input_buf
+ 6 + 16;
13592 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13593 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13594 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13595 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13596 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13597 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13598 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13599 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13601 return (PARSER_OK
);
13604 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13606 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13608 u32
*digest
= (u32
*) hash_buf
->digest
;
13610 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13611 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13615 return (PARSER_OK
);
13618 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13620 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13622 u32
*digest
= (u32
*) hash_buf
->digest
;
13624 salt_t
*salt
= hash_buf
->salt
;
13626 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13628 char *saltbuf_pos
= input_buf
;
13630 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13632 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13634 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13636 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13637 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13639 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13643 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13645 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13647 char *salt_ptr
= (char *) saltbuf_pos
;
13648 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13653 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13655 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13658 rakp_ptr
[j
] = 0x80;
13660 rakp
->salt_len
= j
;
13662 for (i
= 0; i
< 64; i
++)
13664 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13667 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13668 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13669 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13670 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13671 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13672 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13673 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13674 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13676 salt
->salt_len
= 32; // muss min. 32 haben
13678 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13679 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13680 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13681 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13682 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13684 return (PARSER_OK
);
13687 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13689 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13691 u32
*digest
= (u32
*) hash_buf
->digest
;
13693 salt_t
*salt
= hash_buf
->salt
;
13695 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13697 char *salt_pos
= input_buf
+ 1;
13699 memcpy (salt
->salt_buf
, salt_pos
, 8);
13701 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13702 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13704 salt
->salt_len
= 8;
13706 char *hash_pos
= salt_pos
+ 8;
13708 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13709 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13710 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13711 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13712 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13714 digest
[0] -= SHA1M_A
;
13715 digest
[1] -= SHA1M_B
;
13716 digest
[2] -= SHA1M_C
;
13717 digest
[3] -= SHA1M_D
;
13718 digest
[4] -= SHA1M_E
;
13720 return (PARSER_OK
);
13723 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13725 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13727 u32
*digest
= (u32
*) hash_buf
->digest
;
13729 salt_t
*salt
= hash_buf
->salt
;
13731 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13732 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13733 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13734 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13736 digest
[0] = byte_swap_32 (digest
[0]);
13737 digest
[1] = byte_swap_32 (digest
[1]);
13738 digest
[2] = byte_swap_32 (digest
[2]);
13739 digest
[3] = byte_swap_32 (digest
[3]);
13741 digest
[0] -= MD5M_A
;
13742 digest
[1] -= MD5M_B
;
13743 digest
[2] -= MD5M_C
;
13744 digest
[3] -= MD5M_D
;
13746 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13748 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13750 u32
*salt_buf
= salt
->salt_buf
;
13752 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
13753 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
13754 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
13755 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
13757 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13758 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13759 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13760 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13762 salt
->salt_len
= 16 + 1;
13764 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13766 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13768 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
13770 return (PARSER_OK
);
13773 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13775 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13777 u32
*digest
= (u32
*) hash_buf
->digest
;
13779 salt_t
*salt
= hash_buf
->salt
;
13781 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13787 char *hashbuf_pos
= input_buf
;
13789 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13791 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13793 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13795 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13799 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13801 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13803 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13805 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13809 char *databuf_pos
= strchr (iteration_pos
, ':');
13811 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13813 const uint iteration_len
= databuf_pos
- iteration_pos
;
13815 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13816 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13818 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13820 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13821 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13827 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13828 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13829 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13830 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13831 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13832 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
13833 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
13834 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
13838 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13840 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13842 const char p0
= saltbuf_pos
[i
+ 0];
13843 const char p1
= saltbuf_pos
[i
+ 1];
13845 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13846 | hex_convert (p0
) << 4;
13849 salt
->salt_buf
[4] = 0x01000000;
13850 salt
->salt_buf
[5] = 0x80;
13852 salt
->salt_len
= saltbuf_len
/ 2;
13856 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13860 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13862 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13864 const char p0
= databuf_pos
[i
+ 0];
13865 const char p1
= databuf_pos
[i
+ 1];
13867 *databuf_ptr
++ = hex_convert (p1
) << 0
13868 | hex_convert (p0
) << 4;
13871 *databuf_ptr
++ = 0x80;
13873 for (uint i
= 0; i
< 512; i
++)
13875 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13878 cloudkey
->data_len
= databuf_len
/ 2;
13880 return (PARSER_OK
);
13883 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13885 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13887 u32
*digest
= (u32
*) hash_buf
->digest
;
13889 salt_t
*salt
= hash_buf
->salt
;
13895 char *hashbuf_pos
= input_buf
;
13897 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13899 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13901 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13903 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13907 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13909 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13911 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13913 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13915 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13919 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13921 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13923 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13925 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13927 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13931 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13933 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13934 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13936 // ok, the plan for this algorithm is the following:
13937 // we have 2 salts here, the domain-name and a random salt
13938 // while both are used in the initial transformation,
13939 // only the random salt is used in the following iterations
13940 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13941 // and one that includes only the real salt (stored into salt_buf[]).
13942 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13946 memset (tmp_buf
, 0, sizeof (tmp_buf
));
13948 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
13950 memcpy (digest
, tmp_buf
, 20);
13952 digest
[0] = byte_swap_32 (digest
[0]);
13953 digest
[1] = byte_swap_32 (digest
[1]);
13954 digest
[2] = byte_swap_32 (digest
[2]);
13955 digest
[3] = byte_swap_32 (digest
[3]);
13956 digest
[4] = byte_swap_32 (digest
[4]);
13960 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13962 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
13964 char *len_ptr
= NULL
;
13966 for (uint i
= 0; i
< domainbuf_len
; i
++)
13968 if (salt_buf_pc_ptr
[i
] == '.')
13970 len_ptr
= &salt_buf_pc_ptr
[i
];
13980 salt
->salt_buf_pc
[7] = domainbuf_len
;
13984 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13986 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
13988 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13990 salt
->salt_len
= salt_len
;
13994 salt
->salt_iter
= atoi (iteration_pos
);
13996 return (PARSER_OK
);
13999 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14001 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14003 u32
*digest
= (u32
*) hash_buf
->digest
;
14005 salt_t
*salt
= hash_buf
->salt
;
14007 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14008 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14009 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14010 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14011 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14013 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14015 uint salt_len
= input_len
- 40 - 1;
14017 char *salt_buf
= input_buf
+ 40 + 1;
14019 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14021 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14023 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14025 salt
->salt_len
= salt_len
;
14027 return (PARSER_OK
);
14030 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14032 const u8 ascii_to_ebcdic
[] =
14034 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14035 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14036 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14037 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14038 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14039 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14040 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14041 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14042 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14043 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14044 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14045 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14046 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14047 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14048 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14049 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14052 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14054 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14056 u32
*digest
= (u32
*) hash_buf
->digest
;
14058 salt_t
*salt
= hash_buf
->salt
;
14060 char *salt_pos
= input_buf
+ 6 + 1;
14062 char *digest_pos
= strchr (salt_pos
, '*');
14064 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14066 uint salt_len
= digest_pos
- salt_pos
;
14068 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14070 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14072 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14076 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14077 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14079 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14081 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14083 salt
->salt_len
= salt_len
;
14085 for (uint i
= 0; i
< salt_len
; i
++)
14087 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14089 for (uint i
= salt_len
; i
< 8; i
++)
14091 salt_buf_pc_ptr
[i
] = 0x40;
14096 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14098 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14099 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14101 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14102 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14104 digest
[0] = byte_swap_32 (digest
[0]);
14105 digest
[1] = byte_swap_32 (digest
[1]);
14107 IP (digest
[0], digest
[1], tt
);
14109 digest
[0] = rotr32 (digest
[0], 29);
14110 digest
[1] = rotr32 (digest
[1], 29);
14114 return (PARSER_OK
);
14117 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14119 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14121 u32
*digest
= (u32
*) hash_buf
->digest
;
14123 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14124 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14125 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14126 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14128 digest
[0] = byte_swap_32 (digest
[0]);
14129 digest
[1] = byte_swap_32 (digest
[1]);
14130 digest
[2] = byte_swap_32 (digest
[2]);
14131 digest
[3] = byte_swap_32 (digest
[3]);
14133 return (PARSER_OK
);
14136 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14138 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14140 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14142 u32
*digest
= (u32
*) hash_buf
->digest
;
14144 salt_t
*salt
= hash_buf
->salt
;
14148 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14150 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14152 tmp_buf
[3] += -4; // dont ask!
14154 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14156 salt
->salt_len
= 5;
14158 memcpy (digest
, tmp_buf
+ 5, 9);
14160 // yes, only 9 byte are needed to crack, but 10 to display
14162 salt
->salt_buf_pc
[7] = input_buf
[20];
14164 return (PARSER_OK
);
14167 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14169 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14171 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14173 u32
*digest
= (u32
*) hash_buf
->digest
;
14175 salt_t
*salt
= hash_buf
->salt
;
14179 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14181 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14183 tmp_buf
[3] += -4; // dont ask!
14187 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14189 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)
14193 char tmp_iter_buf
[11];
14195 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14197 tmp_iter_buf
[10] = 0;
14199 salt
->salt_iter
= atoi (tmp_iter_buf
);
14201 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14203 return (PARSER_SALT_ITERATION
);
14206 salt
->salt_iter
--; // first round in init
14208 // 2 additional bytes for display only
14210 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14211 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14215 memcpy (digest
, tmp_buf
+ 28, 8);
14217 digest
[0] = byte_swap_32 (digest
[0]);
14218 digest
[1] = byte_swap_32 (digest
[1]);
14222 return (PARSER_OK
);
14225 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14227 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14229 u32
*digest
= (u32
*) hash_buf
->digest
;
14231 salt_t
*salt
= hash_buf
->salt
;
14233 char *salt_buf_pos
= input_buf
;
14235 char *hash_buf_pos
= salt_buf_pos
+ 6;
14237 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14238 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14239 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14240 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14241 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14242 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14243 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14244 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14246 digest
[0] -= SHA256M_A
;
14247 digest
[1] -= SHA256M_B
;
14248 digest
[2] -= SHA256M_C
;
14249 digest
[3] -= SHA256M_D
;
14250 digest
[4] -= SHA256M_E
;
14251 digest
[5] -= SHA256M_F
;
14252 digest
[6] -= SHA256M_G
;
14253 digest
[7] -= SHA256M_H
;
14255 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14257 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14259 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14261 salt
->salt_len
= salt_len
;
14263 return (PARSER_OK
);
14266 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14268 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14270 u32
*digest
= (u32
*) hash_buf
->digest
;
14272 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14274 salt_t
*salt
= hash_buf
->salt
;
14276 char *salt_buf
= input_buf
+ 6;
14278 char *digest_buf
= strchr (salt_buf
, '$');
14280 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14282 uint salt_len
= digest_buf
- salt_buf
;
14284 digest_buf
++; // skip the '$' symbol
14286 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14288 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14290 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14292 salt
->salt_len
= salt_len
;
14294 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14295 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14296 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14297 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14299 digest
[0] = byte_swap_32 (digest
[0]);
14300 digest
[1] = byte_swap_32 (digest
[1]);
14301 digest
[2] = byte_swap_32 (digest
[2]);
14302 digest
[3] = byte_swap_32 (digest
[3]);
14304 digest
[0] -= MD5M_A
;
14305 digest
[1] -= MD5M_B
;
14306 digest
[2] -= MD5M_C
;
14307 digest
[3] -= MD5M_D
;
14309 return (PARSER_OK
);
14312 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14314 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14316 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14318 u32
*digest
= (u32
*) hash_buf
->digest
;
14320 salt_t
*salt
= hash_buf
->salt
;
14322 char *salt_buf
= input_buf
+ 3;
14324 char *digest_buf
= strchr (salt_buf
, '$');
14326 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14328 uint salt_len
= digest_buf
- salt_buf
;
14330 digest_buf
++; // skip the '$' symbol
14332 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14334 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14336 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14338 salt_buf_ptr
[salt_len
] = 0x2d;
14340 salt
->salt_len
= salt_len
+ 1;
14342 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14343 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14344 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14345 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14347 digest
[0] = byte_swap_32 (digest
[0]);
14348 digest
[1] = byte_swap_32 (digest
[1]);
14349 digest
[2] = byte_swap_32 (digest
[2]);
14350 digest
[3] = byte_swap_32 (digest
[3]);
14352 digest
[0] -= MD5M_A
;
14353 digest
[1] -= MD5M_B
;
14354 digest
[2] -= MD5M_C
;
14355 digest
[3] -= MD5M_D
;
14357 return (PARSER_OK
);
14360 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14362 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14364 u32
*digest
= (u32
*) hash_buf
->digest
;
14368 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14370 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14372 memcpy (digest
, tmp_buf
, 20);
14374 digest
[0] = byte_swap_32 (digest
[0]);
14375 digest
[1] = byte_swap_32 (digest
[1]);
14376 digest
[2] = byte_swap_32 (digest
[2]);
14377 digest
[3] = byte_swap_32 (digest
[3]);
14378 digest
[4] = byte_swap_32 (digest
[4]);
14380 digest
[0] -= SHA1M_A
;
14381 digest
[1] -= SHA1M_B
;
14382 digest
[2] -= SHA1M_C
;
14383 digest
[3] -= SHA1M_D
;
14384 digest
[4] -= SHA1M_E
;
14386 return (PARSER_OK
);
14389 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14391 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14393 u32
*digest
= (u32
*) hash_buf
->digest
;
14395 salt_t
*salt
= hash_buf
->salt
;
14397 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14398 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14399 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14400 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14402 digest
[0] = byte_swap_32 (digest
[0]);
14403 digest
[1] = byte_swap_32 (digest
[1]);
14404 digest
[2] = byte_swap_32 (digest
[2]);
14405 digest
[3] = byte_swap_32 (digest
[3]);
14407 digest
[0] -= MD5M_A
;
14408 digest
[1] -= MD5M_B
;
14409 digest
[2] -= MD5M_C
;
14410 digest
[3] -= MD5M_D
;
14412 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14414 uint salt_len
= input_len
- 32 - 1;
14416 char *salt_buf
= input_buf
+ 32 + 1;
14418 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14420 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14422 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14425 * add static "salt" part
14428 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14432 salt
->salt_len
= salt_len
;
14434 return (PARSER_OK
);
14437 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14439 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14441 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14443 u32
*digest
= (u32
*) hash_buf
->digest
;
14445 salt_t
*salt
= hash_buf
->salt
;
14447 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14453 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14455 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14457 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14459 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14461 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14465 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14467 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14469 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14471 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14475 char *keybuf_pos
= strchr (keylen_pos
, '$');
14477 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14479 uint keylen_len
= keybuf_pos
- keylen_pos
;
14481 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14485 char *databuf_pos
= strchr (keybuf_pos
, '$');
14487 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14489 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14491 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14495 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14497 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14503 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14504 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14505 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14506 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14508 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14509 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14510 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14511 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14513 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14514 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14515 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14516 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14518 salt
->salt_len
= 16;
14519 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14521 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14523 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14526 return (PARSER_OK
);
14529 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14531 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14533 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14535 u32
*digest
= (u32
*) hash_buf
->digest
;
14537 salt_t
*salt
= hash_buf
->salt
;
14543 // first is the N salt parameter
14545 char *N_pos
= input_buf
+ 6;
14547 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14551 salt
->scrypt_N
= atoi (N_pos
);
14555 char *r_pos
= strchr (N_pos
, ':');
14557 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14561 salt
->scrypt_r
= atoi (r_pos
);
14565 char *p_pos
= strchr (r_pos
, ':');
14567 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14571 salt
->scrypt_p
= atoi (p_pos
);
14575 char *saltbuf_pos
= strchr (p_pos
, ':');
14577 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14581 char *hash_pos
= strchr (saltbuf_pos
, ':');
14583 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14591 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14593 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14595 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14597 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14599 salt
->salt_len
= tmp_len
;
14600 salt
->salt_iter
= 1;
14602 // digest - base64 decode
14604 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14606 tmp_len
= input_len
- (hash_pos
- input_buf
);
14608 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14610 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14612 memcpy (digest
, tmp_buf
, 32);
14614 return (PARSER_OK
);
14617 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14619 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14621 u32
*digest
= (u32
*) hash_buf
->digest
;
14623 salt_t
*salt
= hash_buf
->salt
;
14629 char decrypted
[76]; // iv + hash
14631 juniper_decrypt_hash (input_buf
, decrypted
);
14633 char *md5crypt_hash
= decrypted
+ 12;
14635 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14637 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14639 char *salt_pos
= md5crypt_hash
+ 3;
14641 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14643 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14645 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14649 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14651 return (PARSER_OK
);
14654 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14656 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14658 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14660 u32
*digest
= (u32
*) hash_buf
->digest
;
14662 salt_t
*salt
= hash_buf
->salt
;
14664 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14670 // first is *raw* salt
14672 char *salt_pos
= input_buf
+ 3;
14674 char *hash_pos
= strchr (salt_pos
, '$');
14676 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14678 uint salt_len
= hash_pos
- salt_pos
;
14680 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14684 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14686 memcpy (salt_buf_ptr
, salt_pos
, 14);
14688 salt_buf_ptr
[17] = 0x01;
14689 salt_buf_ptr
[18] = 0x80;
14691 // add some stuff to normal salt to make sorted happy
14693 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14694 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14695 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14696 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14698 salt
->salt_len
= salt_len
;
14699 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14701 // base64 decode hash
14705 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14707 uint hash_len
= input_len
- 3 - salt_len
- 1;
14709 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14711 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14713 memcpy (digest
, tmp_buf
, 32);
14715 digest
[0] = byte_swap_32 (digest
[0]);
14716 digest
[1] = byte_swap_32 (digest
[1]);
14717 digest
[2] = byte_swap_32 (digest
[2]);
14718 digest
[3] = byte_swap_32 (digest
[3]);
14719 digest
[4] = byte_swap_32 (digest
[4]);
14720 digest
[5] = byte_swap_32 (digest
[5]);
14721 digest
[6] = byte_swap_32 (digest
[6]);
14722 digest
[7] = byte_swap_32 (digest
[7]);
14724 return (PARSER_OK
);
14727 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14729 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14731 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14733 u32
*digest
= (u32
*) hash_buf
->digest
;
14735 salt_t
*salt
= hash_buf
->salt
;
14741 // first is *raw* salt
14743 char *salt_pos
= input_buf
+ 3;
14745 char *hash_pos
= strchr (salt_pos
, '$');
14747 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14749 uint salt_len
= hash_pos
- salt_pos
;
14751 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14753 salt
->salt_len
= salt_len
;
14756 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14758 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14759 salt_buf_ptr
[salt_len
] = 0;
14761 // base64 decode hash
14765 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14767 uint hash_len
= input_len
- 3 - salt_len
- 1;
14769 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14771 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14773 memcpy (digest
, tmp_buf
, 32);
14776 salt
->scrypt_N
= 16384;
14777 salt
->scrypt_r
= 1;
14778 salt
->scrypt_p
= 1;
14779 salt
->salt_iter
= 1;
14781 return (PARSER_OK
);
14784 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14786 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14788 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14790 u32
*digest
= (u32
*) hash_buf
->digest
;
14792 salt_t
*salt
= hash_buf
->salt
;
14794 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14800 char *version_pos
= input_buf
+ 8 + 1;
14802 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14804 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14806 u32 version_len
= verifierHashSize_pos
- version_pos
;
14808 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14810 verifierHashSize_pos
++;
14812 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14814 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14816 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14818 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14822 char *saltSize_pos
= strchr (keySize_pos
, '*');
14824 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14826 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14828 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14832 char *osalt_pos
= strchr (saltSize_pos
, '*');
14834 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14836 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14838 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14842 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14844 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14846 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14848 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14850 encryptedVerifier_pos
++;
14852 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14854 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14856 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14858 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14860 encryptedVerifierHash_pos
++;
14862 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;
14864 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14866 const uint version
= atoi (version_pos
);
14868 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14870 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14872 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14874 const uint keySize
= atoi (keySize_pos
);
14876 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14878 office2007
->keySize
= keySize
;
14880 const uint saltSize
= atoi (saltSize_pos
);
14882 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14888 salt
->salt_len
= 16;
14889 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14891 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
14892 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
14893 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
14894 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
14900 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
14901 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
14902 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
14903 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
14905 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
14906 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
14907 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
14908 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
14909 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
14915 digest
[0] = office2007
->encryptedVerifierHash
[0];
14916 digest
[1] = office2007
->encryptedVerifierHash
[1];
14917 digest
[2] = office2007
->encryptedVerifierHash
[2];
14918 digest
[3] = office2007
->encryptedVerifierHash
[3];
14920 return (PARSER_OK
);
14923 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14925 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14927 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14929 u32
*digest
= (u32
*) hash_buf
->digest
;
14931 salt_t
*salt
= hash_buf
->salt
;
14933 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14939 char *version_pos
= input_buf
+ 8 + 1;
14941 char *spinCount_pos
= strchr (version_pos
, '*');
14943 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14945 u32 version_len
= spinCount_pos
- version_pos
;
14947 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14951 char *keySize_pos
= strchr (spinCount_pos
, '*');
14953 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14955 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
14957 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14961 char *saltSize_pos
= strchr (keySize_pos
, '*');
14963 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14965 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14967 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14971 char *osalt_pos
= strchr (saltSize_pos
, '*');
14973 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14975 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14977 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14981 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14983 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14985 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14987 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14989 encryptedVerifier_pos
++;
14991 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14993 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14995 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14997 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14999 encryptedVerifierHash_pos
++;
15001 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;
15003 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15005 const uint version
= atoi (version_pos
);
15007 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15009 const uint spinCount
= atoi (spinCount_pos
);
15011 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15013 const uint keySize
= atoi (keySize_pos
);
15015 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15017 const uint saltSize
= atoi (saltSize_pos
);
15019 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15025 salt
->salt_len
= 16;
15026 salt
->salt_iter
= spinCount
;
15028 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15029 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15030 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15031 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15037 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15038 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15039 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15040 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15042 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15043 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15044 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15045 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15046 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15047 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15048 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15049 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15055 digest
[0] = office2010
->encryptedVerifierHash
[0];
15056 digest
[1] = office2010
->encryptedVerifierHash
[1];
15057 digest
[2] = office2010
->encryptedVerifierHash
[2];
15058 digest
[3] = office2010
->encryptedVerifierHash
[3];
15060 return (PARSER_OK
);
15063 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15065 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15067 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15069 u32
*digest
= (u32
*) hash_buf
->digest
;
15071 salt_t
*salt
= hash_buf
->salt
;
15073 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15079 char *version_pos
= input_buf
+ 8 + 1;
15081 char *spinCount_pos
= strchr (version_pos
, '*');
15083 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15085 u32 version_len
= spinCount_pos
- version_pos
;
15087 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15091 char *keySize_pos
= strchr (spinCount_pos
, '*');
15093 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15095 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15097 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15101 char *saltSize_pos
= strchr (keySize_pos
, '*');
15103 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15105 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15107 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15111 char *osalt_pos
= strchr (saltSize_pos
, '*');
15113 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15115 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15117 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15121 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15123 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15125 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15127 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15129 encryptedVerifier_pos
++;
15131 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15133 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15135 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15137 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15139 encryptedVerifierHash_pos
++;
15141 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;
15143 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15145 const uint version
= atoi (version_pos
);
15147 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15149 const uint spinCount
= atoi (spinCount_pos
);
15151 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15153 const uint keySize
= atoi (keySize_pos
);
15155 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15157 const uint saltSize
= atoi (saltSize_pos
);
15159 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15165 salt
->salt_len
= 16;
15166 salt
->salt_iter
= spinCount
;
15168 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15169 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15170 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15171 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15177 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15178 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15179 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15180 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15182 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15183 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15184 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15185 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15186 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15187 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15188 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15189 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15195 digest
[0] = office2013
->encryptedVerifierHash
[0];
15196 digest
[1] = office2013
->encryptedVerifierHash
[1];
15197 digest
[2] = office2013
->encryptedVerifierHash
[2];
15198 digest
[3] = office2013
->encryptedVerifierHash
[3];
15200 return (PARSER_OK
);
15203 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15205 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15207 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15209 u32
*digest
= (u32
*) hash_buf
->digest
;
15211 salt_t
*salt
= hash_buf
->salt
;
15213 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15219 char *version_pos
= input_buf
+ 11;
15221 char *osalt_pos
= strchr (version_pos
, '*');
15223 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15225 u32 version_len
= osalt_pos
- version_pos
;
15227 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15231 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15233 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15235 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15237 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15239 encryptedVerifier_pos
++;
15241 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15243 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15245 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15247 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15249 encryptedVerifierHash_pos
++;
15251 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15253 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15255 const uint version
= *version_pos
- 0x30;
15257 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15263 oldoffice01
->version
= version
;
15265 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15266 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15267 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15268 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15270 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15271 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15272 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15273 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15275 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15276 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15277 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15278 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15280 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15281 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15282 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15283 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15289 salt
->salt_len
= 16;
15291 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15292 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15293 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15294 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15296 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15297 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15298 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15299 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15301 // this is a workaround as office produces multiple documents with the same salt
15303 salt
->salt_len
+= 32;
15305 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15306 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15307 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15308 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15309 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15310 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15311 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15312 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15318 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15319 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15320 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15321 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15323 return (PARSER_OK
);
15326 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15328 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15331 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15333 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15335 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15337 u32
*digest
= (u32
*) hash_buf
->digest
;
15339 salt_t
*salt
= hash_buf
->salt
;
15341 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15347 char *version_pos
= input_buf
+ 11;
15349 char *osalt_pos
= strchr (version_pos
, '*');
15351 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15353 u32 version_len
= osalt_pos
- version_pos
;
15355 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15359 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15361 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15363 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15365 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15367 encryptedVerifier_pos
++;
15369 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15371 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15373 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15375 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15377 encryptedVerifierHash_pos
++;
15379 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15381 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15383 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15385 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15389 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15391 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15393 const uint version
= *version_pos
- 0x30;
15395 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15401 oldoffice01
->version
= version
;
15403 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15404 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15405 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15406 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15408 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15409 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15410 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15411 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15413 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15414 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15415 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15416 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15418 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15419 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15420 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15421 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15423 oldoffice01
->rc4key
[1] = 0;
15424 oldoffice01
->rc4key
[0] = 0;
15426 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15427 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15428 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15429 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15430 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15431 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15432 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15433 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15434 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15435 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15437 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15438 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15444 salt
->salt_len
= 16;
15446 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15447 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15448 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15449 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15451 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15452 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15453 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15454 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15456 // this is a workaround as office produces multiple documents with the same salt
15458 salt
->salt_len
+= 32;
15460 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15461 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15462 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15463 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15464 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15465 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15466 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15467 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15473 digest
[0] = oldoffice01
->rc4key
[0];
15474 digest
[1] = oldoffice01
->rc4key
[1];
15478 return (PARSER_OK
);
15481 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15483 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15485 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15487 u32
*digest
= (u32
*) hash_buf
->digest
;
15489 salt_t
*salt
= hash_buf
->salt
;
15491 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15497 char *version_pos
= input_buf
+ 11;
15499 char *osalt_pos
= strchr (version_pos
, '*');
15501 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15503 u32 version_len
= osalt_pos
- version_pos
;
15505 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15509 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15511 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15513 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15515 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15517 encryptedVerifier_pos
++;
15519 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15521 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15523 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15525 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15527 encryptedVerifierHash_pos
++;
15529 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15531 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15533 const uint version
= *version_pos
- 0x30;
15535 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15541 oldoffice34
->version
= version
;
15543 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15544 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15545 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15546 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15548 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15549 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15550 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15551 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15553 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15554 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15555 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15556 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15557 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15559 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15560 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15561 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15562 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15563 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15569 salt
->salt_len
= 16;
15571 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15572 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15573 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15574 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15576 // this is a workaround as office produces multiple documents with the same salt
15578 salt
->salt_len
+= 32;
15580 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15581 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15582 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15583 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15584 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15585 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15586 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15587 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15593 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15594 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15595 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15596 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15598 return (PARSER_OK
);
15601 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15603 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15605 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15608 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15610 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15612 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15614 u32
*digest
= (u32
*) hash_buf
->digest
;
15616 salt_t
*salt
= hash_buf
->salt
;
15618 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15624 char *version_pos
= input_buf
+ 11;
15626 char *osalt_pos
= strchr (version_pos
, '*');
15628 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15630 u32 version_len
= osalt_pos
- version_pos
;
15632 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15636 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15638 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15640 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15642 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15644 encryptedVerifier_pos
++;
15646 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15648 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15650 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15652 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15654 encryptedVerifierHash_pos
++;
15656 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15658 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15660 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15662 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15666 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15668 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15670 const uint version
= *version_pos
- 0x30;
15672 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15678 oldoffice34
->version
= version
;
15680 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15681 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15682 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15683 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15685 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15686 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15687 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15688 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15690 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15691 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15692 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15693 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15694 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15696 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15697 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15698 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15699 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15700 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15702 oldoffice34
->rc4key
[1] = 0;
15703 oldoffice34
->rc4key
[0] = 0;
15705 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15706 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15707 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15708 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15709 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15710 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15711 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15712 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15713 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15714 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15716 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15717 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15723 salt
->salt_len
= 16;
15725 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15726 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15727 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15728 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15730 // this is a workaround as office produces multiple documents with the same salt
15732 salt
->salt_len
+= 32;
15734 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15735 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15736 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15737 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15738 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15739 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15740 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15741 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15747 digest
[0] = oldoffice34
->rc4key
[0];
15748 digest
[1] = oldoffice34
->rc4key
[1];
15752 return (PARSER_OK
);
15755 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15757 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15759 u32
*digest
= (u32
*) hash_buf
->digest
;
15761 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15762 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15763 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15764 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15766 digest
[0] = byte_swap_32 (digest
[0]);
15767 digest
[1] = byte_swap_32 (digest
[1]);
15768 digest
[2] = byte_swap_32 (digest
[2]);
15769 digest
[3] = byte_swap_32 (digest
[3]);
15771 return (PARSER_OK
);
15774 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15776 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15778 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15780 u32
*digest
= (u32
*) hash_buf
->digest
;
15782 salt_t
*salt
= hash_buf
->salt
;
15784 char *signature_pos
= input_buf
;
15786 char *salt_pos
= strchr (signature_pos
, '$');
15788 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15790 u32 signature_len
= salt_pos
- signature_pos
;
15792 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15796 char *hash_pos
= strchr (salt_pos
, '$');
15798 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15800 u32 salt_len
= hash_pos
- salt_pos
;
15802 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15806 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15808 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15810 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
15811 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
15812 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
15813 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
15814 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
15816 digest
[0] -= SHA1M_A
;
15817 digest
[1] -= SHA1M_B
;
15818 digest
[2] -= SHA1M_C
;
15819 digest
[3] -= SHA1M_D
;
15820 digest
[4] -= SHA1M_E
;
15822 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15824 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15826 salt
->salt_len
= salt_len
;
15828 return (PARSER_OK
);
15831 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15833 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15835 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15837 u32
*digest
= (u32
*) hash_buf
->digest
;
15839 salt_t
*salt
= hash_buf
->salt
;
15841 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15847 char *iter_pos
= input_buf
+ 14;
15849 const int iter
= atoi (iter_pos
);
15851 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15853 salt
->salt_iter
= iter
- 1;
15855 char *salt_pos
= strchr (iter_pos
, '$');
15857 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15861 char *hash_pos
= strchr (salt_pos
, '$');
15863 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15865 const uint salt_len
= hash_pos
- salt_pos
;
15869 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15871 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15873 salt
->salt_len
= salt_len
;
15875 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15876 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15878 // add some stuff to normal salt to make sorted happy
15880 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15881 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15882 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15883 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15884 salt
->salt_buf
[4] = salt
->salt_iter
;
15886 // base64 decode hash
15890 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15892 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15894 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15896 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15898 memcpy (digest
, tmp_buf
, 32);
15900 digest
[0] = byte_swap_32 (digest
[0]);
15901 digest
[1] = byte_swap_32 (digest
[1]);
15902 digest
[2] = byte_swap_32 (digest
[2]);
15903 digest
[3] = byte_swap_32 (digest
[3]);
15904 digest
[4] = byte_swap_32 (digest
[4]);
15905 digest
[5] = byte_swap_32 (digest
[5]);
15906 digest
[6] = byte_swap_32 (digest
[6]);
15907 digest
[7] = byte_swap_32 (digest
[7]);
15909 return (PARSER_OK
);
15912 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15914 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15916 u32
*digest
= (u32
*) hash_buf
->digest
;
15918 salt_t
*salt
= hash_buf
->salt
;
15920 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15921 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15925 digest
[0] = byte_swap_32 (digest
[0]);
15926 digest
[1] = byte_swap_32 (digest
[1]);
15928 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15929 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15930 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15932 char iter_c
= input_buf
[17];
15933 char iter_d
= input_buf
[19];
15935 // atm only defaults, let's see if there's more request
15936 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15937 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15939 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15941 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
15942 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
15943 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
15944 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
15946 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15947 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15948 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15949 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15951 salt
->salt_len
= 16;
15953 return (PARSER_OK
);
15956 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15958 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
15960 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15962 u32
*digest
= (u32
*) hash_buf
->digest
;
15964 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
15966 salt_t
*salt
= hash_buf
->salt
;
15968 char *salt_pos
= input_buf
+ 10;
15970 char *hash_pos
= strchr (salt_pos
, '$');
15972 uint salt_len
= hash_pos
- salt_pos
;
15974 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15978 uint hash_len
= input_len
- 10 - salt_len
- 1;
15980 // base64 decode salt
15984 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15986 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
15988 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
15990 tmp_buf
[salt_len
] = 0x80;
15992 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
15994 salt
->salt_len
= salt_len
;
15996 // base64 decode salt
15998 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16000 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16002 uint user_len
= hash_len
- 32;
16004 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16006 user_len
--; // skip the trailing space
16008 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16009 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16010 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16011 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16013 digest
[0] = byte_swap_32 (digest
[0]);
16014 digest
[1] = byte_swap_32 (digest
[1]);
16015 digest
[2] = byte_swap_32 (digest
[2]);
16016 digest
[3] = byte_swap_32 (digest
[3]);
16018 // store username for host only (output hash if cracked)
16020 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16021 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16023 return (PARSER_OK
);
16026 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16028 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16030 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16032 u32
*digest
= (u32
*) hash_buf
->digest
;
16034 salt_t
*salt
= hash_buf
->salt
;
16036 char *iter_pos
= input_buf
+ 10;
16038 u32 iter
= atoi (iter_pos
);
16042 return (PARSER_SALT_ITERATION
);
16045 iter
--; // first iteration is special
16047 salt
->salt_iter
= iter
;
16049 char *base64_pos
= strchr (iter_pos
, '}');
16051 if (base64_pos
== NULL
)
16053 return (PARSER_SIGNATURE_UNMATCHED
);
16058 // base64 decode salt
16060 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16064 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16066 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16068 if (decoded_len
< 24)
16070 return (PARSER_SALT_LENGTH
);
16075 uint salt_len
= decoded_len
- 20;
16077 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16078 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16080 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16082 salt
->salt_len
= salt_len
;
16086 u32
*digest_ptr
= (u32
*) tmp_buf
;
16088 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16089 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16090 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16091 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16092 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16094 return (PARSER_OK
);
16097 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16099 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16101 u32
*digest
= (u32
*) hash_buf
->digest
;
16103 salt_t
*salt
= hash_buf
->salt
;
16105 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16106 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16107 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16108 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16109 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16111 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16113 uint salt_len
= input_len
- 40 - 1;
16115 char *salt_buf
= input_buf
+ 40 + 1;
16117 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16119 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16121 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16123 salt
->salt_len
= salt_len
;
16125 return (PARSER_OK
);
16128 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16130 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16132 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16134 u32
*digest
= (u32
*) hash_buf
->digest
;
16136 salt_t
*salt
= hash_buf
->salt
;
16138 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16144 char *V_pos
= input_buf
+ 5;
16146 char *R_pos
= strchr (V_pos
, '*');
16148 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16150 u32 V_len
= R_pos
- V_pos
;
16154 char *bits_pos
= strchr (R_pos
, '*');
16156 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16158 u32 R_len
= bits_pos
- R_pos
;
16162 char *P_pos
= strchr (bits_pos
, '*');
16164 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16166 u32 bits_len
= P_pos
- bits_pos
;
16170 char *enc_md_pos
= strchr (P_pos
, '*');
16172 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16174 u32 P_len
= enc_md_pos
- P_pos
;
16178 char *id_len_pos
= strchr (enc_md_pos
, '*');
16180 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16182 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16186 char *id_buf_pos
= strchr (id_len_pos
, '*');
16188 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16190 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16194 char *u_len_pos
= strchr (id_buf_pos
, '*');
16196 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16198 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16200 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16204 char *u_buf_pos
= strchr (u_len_pos
, '*');
16206 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16208 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16212 char *o_len_pos
= strchr (u_buf_pos
, '*');
16214 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16216 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16218 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16222 char *o_buf_pos
= strchr (o_len_pos
, '*');
16224 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16226 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16230 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;
16232 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16236 const int V
= atoi (V_pos
);
16237 const int R
= atoi (R_pos
);
16238 const int P
= atoi (P_pos
);
16240 if (V
!= 1) return (PARSER_SALT_VALUE
);
16241 if (R
!= 2) return (PARSER_SALT_VALUE
);
16243 const int enc_md
= atoi (enc_md_pos
);
16245 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16247 const int id_len
= atoi (id_len_pos
);
16248 const int u_len
= atoi (u_len_pos
);
16249 const int o_len
= atoi (o_len_pos
);
16251 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16252 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16253 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16255 const int bits
= atoi (bits_pos
);
16257 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16259 // copy data to esalt
16265 pdf
->enc_md
= enc_md
;
16267 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16268 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16269 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16270 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16271 pdf
->id_len
= id_len
;
16273 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16274 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16275 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16276 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16277 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16278 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16279 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16280 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16281 pdf
->u_len
= u_len
;
16283 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16284 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16285 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16286 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16287 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16288 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16289 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16290 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16291 pdf
->o_len
= o_len
;
16293 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16294 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16295 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16296 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16298 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16299 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16300 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16301 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16302 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16303 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16304 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16305 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16307 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16308 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16309 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16310 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16311 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16312 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16313 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16314 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16316 // we use ID for salt, maybe needs to change, we will see...
16318 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16319 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16320 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16321 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16322 salt
->salt_len
= pdf
->id_len
;
16324 digest
[0] = pdf
->u_buf
[0];
16325 digest
[1] = pdf
->u_buf
[1];
16326 digest
[2] = pdf
->u_buf
[2];
16327 digest
[3] = pdf
->u_buf
[3];
16329 return (PARSER_OK
);
16332 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16334 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16337 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16339 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16341 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16343 u32
*digest
= (u32
*) hash_buf
->digest
;
16345 salt_t
*salt
= hash_buf
->salt
;
16347 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16353 char *V_pos
= input_buf
+ 5;
16355 char *R_pos
= strchr (V_pos
, '*');
16357 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16359 u32 V_len
= R_pos
- V_pos
;
16363 char *bits_pos
= strchr (R_pos
, '*');
16365 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16367 u32 R_len
= bits_pos
- R_pos
;
16371 char *P_pos
= strchr (bits_pos
, '*');
16373 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16375 u32 bits_len
= P_pos
- bits_pos
;
16379 char *enc_md_pos
= strchr (P_pos
, '*');
16381 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16383 u32 P_len
= enc_md_pos
- P_pos
;
16387 char *id_len_pos
= strchr (enc_md_pos
, '*');
16389 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16391 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16395 char *id_buf_pos
= strchr (id_len_pos
, '*');
16397 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16399 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16403 char *u_len_pos
= strchr (id_buf_pos
, '*');
16405 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16407 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16409 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16413 char *u_buf_pos
= strchr (u_len_pos
, '*');
16415 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16417 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16421 char *o_len_pos
= strchr (u_buf_pos
, '*');
16423 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16425 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16427 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16431 char *o_buf_pos
= strchr (o_len_pos
, '*');
16433 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16435 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16439 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16441 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16443 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16445 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16449 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;
16451 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16455 const int V
= atoi (V_pos
);
16456 const int R
= atoi (R_pos
);
16457 const int P
= atoi (P_pos
);
16459 if (V
!= 1) return (PARSER_SALT_VALUE
);
16460 if (R
!= 2) return (PARSER_SALT_VALUE
);
16462 const int enc_md
= atoi (enc_md_pos
);
16464 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16466 const int id_len
= atoi (id_len_pos
);
16467 const int u_len
= atoi (u_len_pos
);
16468 const int o_len
= atoi (o_len_pos
);
16470 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16471 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16472 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16474 const int bits
= atoi (bits_pos
);
16476 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16478 // copy data to esalt
16484 pdf
->enc_md
= enc_md
;
16486 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16487 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16488 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16489 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16490 pdf
->id_len
= id_len
;
16492 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16493 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16494 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16495 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16496 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16497 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16498 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16499 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16500 pdf
->u_len
= u_len
;
16502 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16503 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16504 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16505 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16506 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16507 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16508 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16509 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16510 pdf
->o_len
= o_len
;
16512 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16513 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16514 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16515 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16517 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16518 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16519 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16520 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16521 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16522 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16523 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16524 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16526 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16527 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16528 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16529 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16530 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16531 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16532 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16533 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16535 pdf
->rc4key
[1] = 0;
16536 pdf
->rc4key
[0] = 0;
16538 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16539 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16540 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16541 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16542 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16543 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16544 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16545 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16546 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16547 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16549 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16550 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16552 // we use ID for salt, maybe needs to change, we will see...
16554 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16555 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16556 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16557 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16558 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16559 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16560 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16561 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16562 salt
->salt_len
= pdf
->id_len
+ 16;
16564 digest
[0] = pdf
->rc4key
[0];
16565 digest
[1] = pdf
->rc4key
[1];
16569 return (PARSER_OK
);
16572 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16574 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16576 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16578 u32
*digest
= (u32
*) hash_buf
->digest
;
16580 salt_t
*salt
= hash_buf
->salt
;
16582 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16588 char *V_pos
= input_buf
+ 5;
16590 char *R_pos
= strchr (V_pos
, '*');
16592 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16594 u32 V_len
= R_pos
- V_pos
;
16598 char *bits_pos
= strchr (R_pos
, '*');
16600 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16602 u32 R_len
= bits_pos
- R_pos
;
16606 char *P_pos
= strchr (bits_pos
, '*');
16608 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16610 u32 bits_len
= P_pos
- bits_pos
;
16614 char *enc_md_pos
= strchr (P_pos
, '*');
16616 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16618 u32 P_len
= enc_md_pos
- P_pos
;
16622 char *id_len_pos
= strchr (enc_md_pos
, '*');
16624 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16626 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16630 char *id_buf_pos
= strchr (id_len_pos
, '*');
16632 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16634 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16638 char *u_len_pos
= strchr (id_buf_pos
, '*');
16640 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16642 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16644 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16648 char *u_buf_pos
= strchr (u_len_pos
, '*');
16650 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16652 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16656 char *o_len_pos
= strchr (u_buf_pos
, '*');
16658 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16660 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16662 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16666 char *o_buf_pos
= strchr (o_len_pos
, '*');
16668 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16670 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16674 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;
16676 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16680 const int V
= atoi (V_pos
);
16681 const int R
= atoi (R_pos
);
16682 const int P
= atoi (P_pos
);
16686 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16687 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16689 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16691 const int id_len
= atoi (id_len_pos
);
16692 const int u_len
= atoi (u_len_pos
);
16693 const int o_len
= atoi (o_len_pos
);
16695 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16697 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16698 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16700 const int bits
= atoi (bits_pos
);
16702 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16708 enc_md
= atoi (enc_md_pos
);
16711 // copy data to esalt
16717 pdf
->enc_md
= enc_md
;
16719 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16720 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16721 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16722 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16726 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
16727 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
16728 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
16729 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
16732 pdf
->id_len
= id_len
;
16734 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16735 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16736 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16737 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16738 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16739 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16740 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16741 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16742 pdf
->u_len
= u_len
;
16744 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16745 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16746 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16747 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16748 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16749 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16750 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16751 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16752 pdf
->o_len
= o_len
;
16754 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16755 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16756 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16757 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16761 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16762 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16763 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16764 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16767 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16768 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16769 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16770 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16771 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16772 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16773 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16774 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16776 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16777 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16778 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16779 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16780 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16781 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16782 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16783 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16785 // precompute rc4 data for later use
16801 uint salt_pc_block
[32];
16803 char *salt_pc_ptr
= (char *) salt_pc_block
;
16805 memcpy (salt_pc_ptr
, padding
, 32);
16806 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16808 uint salt_pc_digest
[4];
16810 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16812 pdf
->rc4data
[0] = salt_pc_digest
[0];
16813 pdf
->rc4data
[1] = salt_pc_digest
[1];
16815 // we use ID for salt, maybe needs to change, we will see...
16817 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16818 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16819 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16820 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16821 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16822 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16823 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16824 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16825 salt
->salt_len
= pdf
->id_len
+ 16;
16827 salt
->salt_iter
= ROUNDS_PDF14
;
16829 digest
[0] = pdf
->u_buf
[0];
16830 digest
[1] = pdf
->u_buf
[1];
16834 return (PARSER_OK
);
16837 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16839 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16841 if (ret
!= PARSER_OK
)
16846 u32
*digest
= (u32
*) hash_buf
->digest
;
16848 salt_t
*salt
= hash_buf
->salt
;
16850 digest
[0] -= SHA256M_A
;
16851 digest
[1] -= SHA256M_B
;
16852 digest
[2] -= SHA256M_C
;
16853 digest
[3] -= SHA256M_D
;
16854 digest
[4] -= SHA256M_E
;
16855 digest
[5] -= SHA256M_F
;
16856 digest
[6] -= SHA256M_G
;
16857 digest
[7] -= SHA256M_H
;
16859 salt
->salt_buf
[2] = 0x80;
16861 return (PARSER_OK
);
16864 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16866 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16868 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16870 u32
*digest
= (u32
*) hash_buf
->digest
;
16872 salt_t
*salt
= hash_buf
->salt
;
16874 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16880 char *V_pos
= input_buf
+ 5;
16882 char *R_pos
= strchr (V_pos
, '*');
16884 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16886 u32 V_len
= R_pos
- V_pos
;
16890 char *bits_pos
= strchr (R_pos
, '*');
16892 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16894 u32 R_len
= bits_pos
- R_pos
;
16898 char *P_pos
= strchr (bits_pos
, '*');
16900 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16902 u32 bits_len
= P_pos
- bits_pos
;
16906 char *enc_md_pos
= strchr (P_pos
, '*');
16908 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16910 u32 P_len
= enc_md_pos
- P_pos
;
16914 char *id_len_pos
= strchr (enc_md_pos
, '*');
16916 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16918 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16922 char *id_buf_pos
= strchr (id_len_pos
, '*');
16924 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16926 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16930 char *u_len_pos
= strchr (id_buf_pos
, '*');
16932 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16934 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16938 char *u_buf_pos
= strchr (u_len_pos
, '*');
16940 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16942 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16946 char *o_len_pos
= strchr (u_buf_pos
, '*');
16948 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16950 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16954 char *o_buf_pos
= strchr (o_len_pos
, '*');
16956 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16958 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16962 char *last
= strchr (o_buf_pos
, '*');
16964 if (last
== NULL
) last
= input_buf
+ input_len
;
16966 u32 o_buf_len
= last
- o_buf_pos
;
16970 const int V
= atoi (V_pos
);
16971 const int R
= atoi (R_pos
);
16975 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
16976 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
16978 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16980 const int bits
= atoi (bits_pos
);
16982 if (bits
!= 256) return (PARSER_SALT_VALUE
);
16984 int enc_md
= atoi (enc_md_pos
);
16986 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
16988 const uint id_len
= atoi (id_len_pos
);
16989 const uint u_len
= atoi (u_len_pos
);
16990 const uint o_len
= atoi (o_len_pos
);
16992 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
16993 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
16994 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
16995 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
16996 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
16997 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
16998 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
16999 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17001 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17002 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17003 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17005 // copy data to esalt
17007 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17009 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17011 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17014 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17015 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17017 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17018 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17020 salt
->salt_len
= 8;
17021 salt
->salt_iter
= ROUNDS_PDF17L8
;
17023 digest
[0] = pdf
->u_buf
[0];
17024 digest
[1] = pdf
->u_buf
[1];
17025 digest
[2] = pdf
->u_buf
[2];
17026 digest
[3] = pdf
->u_buf
[3];
17027 digest
[4] = pdf
->u_buf
[4];
17028 digest
[5] = pdf
->u_buf
[5];
17029 digest
[6] = pdf
->u_buf
[6];
17030 digest
[7] = pdf
->u_buf
[7];
17032 return (PARSER_OK
);
17035 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17037 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17039 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17041 u32
*digest
= (u32
*) hash_buf
->digest
;
17043 salt_t
*salt
= hash_buf
->salt
;
17045 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17053 char *iter_pos
= input_buf
+ 7;
17055 u32 iter
= atoi (iter_pos
);
17057 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17058 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17060 // first is *raw* salt
17062 char *salt_pos
= strchr (iter_pos
, ':');
17064 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17068 char *hash_pos
= strchr (salt_pos
, ':');
17070 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17072 u32 salt_len
= hash_pos
- salt_pos
;
17074 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17078 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17080 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17084 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17086 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17088 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17090 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17091 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17093 salt
->salt_len
= salt_len
;
17094 salt
->salt_iter
= iter
- 1;
17100 memset (tmp_buf
, 0, sizeof (tmp_buf
));
17102 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17104 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17106 memcpy (digest
, tmp_buf
, 16);
17108 digest
[0] = byte_swap_32 (digest
[0]);
17109 digest
[1] = byte_swap_32 (digest
[1]);
17110 digest
[2] = byte_swap_32 (digest
[2]);
17111 digest
[3] = byte_swap_32 (digest
[3]);
17113 // add some stuff to normal salt to make sorted happy
17115 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17116 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17117 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17118 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17119 salt
->salt_buf
[4] = salt
->salt_iter
;
17121 return (PARSER_OK
);
17124 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17126 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17128 u32
*digest
= (u32
*) hash_buf
->digest
;
17130 salt_t
*salt
= hash_buf
->salt
;
17132 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17133 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17134 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17135 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17137 digest
[0] = byte_swap_32 (digest
[0]);
17138 digest
[1] = byte_swap_32 (digest
[1]);
17139 digest
[2] = byte_swap_32 (digest
[2]);
17140 digest
[3] = byte_swap_32 (digest
[3]);
17142 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17144 uint salt_len
= input_len
- 32 - 1;
17146 char *salt_buf
= input_buf
+ 32 + 1;
17148 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17150 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17152 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17154 salt
->salt_len
= salt_len
;
17156 return (PARSER_OK
);
17159 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17161 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17163 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17165 u32
*digest
= (u32
*) hash_buf
->digest
;
17167 salt_t
*salt
= hash_buf
->salt
;
17169 char *user_pos
= input_buf
+ 10;
17171 char *salt_pos
= strchr (user_pos
, '*');
17173 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17177 char *hash_pos
= strchr (salt_pos
, '*');
17181 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17183 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17185 uint user_len
= salt_pos
- user_pos
- 1;
17187 uint salt_len
= hash_pos
- salt_pos
- 1;
17189 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17195 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17196 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17197 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17198 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17200 digest
[0] = byte_swap_32 (digest
[0]);
17201 digest
[1] = byte_swap_32 (digest
[1]);
17202 digest
[2] = byte_swap_32 (digest
[2]);
17203 digest
[3] = byte_swap_32 (digest
[3]);
17205 digest
[0] -= MD5M_A
;
17206 digest
[1] -= MD5M_B
;
17207 digest
[2] -= MD5M_C
;
17208 digest
[3] -= MD5M_D
;
17214 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17216 // first 4 bytes are the "challenge"
17218 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17219 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17220 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17221 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17223 // append the user name
17225 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17227 salt
->salt_len
= 4 + user_len
;
17229 return (PARSER_OK
);
17232 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17234 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17236 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17238 u32
*digest
= (u32
*) hash_buf
->digest
;
17240 salt_t
*salt
= hash_buf
->salt
;
17242 char *salt_pos
= input_buf
+ 9;
17244 char *hash_pos
= strchr (salt_pos
, '*');
17246 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17250 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17252 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17254 uint salt_len
= hash_pos
- salt_pos
- 1;
17256 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17262 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17263 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17264 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17265 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17266 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17272 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17274 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17276 salt
->salt_len
= salt_len
;
17278 return (PARSER_OK
);
17281 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17283 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17285 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17287 u32
*digest
= (u32
*) hash_buf
->digest
;
17289 salt_t
*salt
= hash_buf
->salt
;
17291 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17297 char *cry_master_len_pos
= input_buf
+ 9;
17299 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17301 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17303 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17305 cry_master_buf_pos
++;
17307 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17309 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17311 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17313 cry_salt_len_pos
++;
17315 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17317 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17319 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17321 cry_salt_buf_pos
++;
17323 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17325 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17327 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17331 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17333 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17335 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17339 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17341 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17343 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17347 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17349 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17351 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17353 public_key_len_pos
++;
17355 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17357 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17359 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17361 public_key_buf_pos
++;
17363 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;
17365 const uint cry_master_len
= atoi (cry_master_len_pos
);
17366 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17367 const uint ckey_len
= atoi (ckey_len_pos
);
17368 const uint public_key_len
= atoi (public_key_len_pos
);
17370 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17371 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17372 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17373 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17375 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17377 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17379 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17382 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17384 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17386 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17389 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17391 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17393 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17396 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17397 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17398 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17401 * store digest (should be unique enought, hopefully)
17404 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17405 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17406 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17407 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17413 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17415 const uint cry_rounds
= atoi (cry_rounds_pos
);
17417 salt
->salt_iter
= cry_rounds
- 1;
17419 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17421 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17423 salt
->salt_len
= salt_len
;
17425 return (PARSER_OK
);
17428 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17430 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17432 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17434 u32
*digest
= (u32
*) hash_buf
->digest
;
17436 salt_t
*salt
= hash_buf
->salt
;
17438 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17440 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17442 char temp_input_buf
[input_len
+ 1];
17444 memset (temp_input_buf
, 0, sizeof (temp_input_buf
));
17445 memcpy (temp_input_buf
, input_buf
, input_len
);
17449 char *URI_server_pos
= temp_input_buf
+ 6;
17451 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17453 if (URI_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17455 URI_client_pos
[0] = 0;
17458 uint URI_server_len
= strlen (URI_server_pos
);
17460 if (URI_server_len
> 512) return (PARSER_SALT_LENGTH
);
17464 char *user_pos
= strchr (URI_client_pos
, '*');
17466 if (user_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17471 uint URI_client_len
= strlen (URI_client_pos
);
17473 if (URI_client_len
> 512) return (PARSER_SALT_LENGTH
);
17477 char *realm_pos
= strchr (user_pos
, '*');
17479 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17484 uint user_len
= strlen (user_pos
);
17486 if (user_len
> 116) return (PARSER_SALT_LENGTH
);
17490 char *method_pos
= strchr (realm_pos
, '*');
17492 if (method_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17497 uint realm_len
= strlen (realm_pos
);
17499 if (realm_len
> 116) return (PARSER_SALT_LENGTH
);
17503 char *URI_prefix_pos
= strchr (method_pos
, '*');
17505 if (URI_prefix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17507 URI_prefix_pos
[0] = 0;
17510 uint method_len
= strlen (method_pos
);
17512 if (method_len
> 246) return (PARSER_SALT_LENGTH
);
17516 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17518 if (URI_resource_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17520 URI_resource_pos
[0] = 0;
17521 URI_resource_pos
++;
17523 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17525 if (URI_prefix_len
> 245) return (PARSER_SALT_LENGTH
);
17529 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17531 if (URI_suffix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17533 URI_suffix_pos
[0] = 0;
17536 uint URI_resource_len
= strlen (URI_resource_pos
);
17538 if (URI_resource_len
< 1) return (PARSER_SALT_LENGTH
);
17539 if (URI_resource_len
> 246) return (PARSER_SALT_LENGTH
);
17543 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17545 if (nonce_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17550 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17552 if (URI_suffix_len
> 245) return (PARSER_SALT_LENGTH
);
17556 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17558 if (nonce_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17560 nonce_client_pos
[0] = 0;
17561 nonce_client_pos
++;
17563 uint nonce_len
= strlen (nonce_pos
);
17565 if (nonce_len
< 1) return (PARSER_SALT_LENGTH
);
17566 if (nonce_len
> 50) return (PARSER_SALT_LENGTH
);
17570 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17572 if (nonce_count_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17574 nonce_count_pos
[0] = 0;
17577 uint nonce_client_len
= strlen (nonce_client_pos
);
17579 if (nonce_client_len
> 50) return (PARSER_SALT_LENGTH
);
17583 char *qop_pos
= strchr (nonce_count_pos
, '*');
17585 if (qop_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17590 uint nonce_count_len
= strlen (nonce_count_pos
);
17592 if (nonce_count_len
> 50) return (PARSER_SALT_LENGTH
);
17596 char *directive_pos
= strchr (qop_pos
, '*');
17598 if (directive_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17600 directive_pos
[0] = 0;
17603 uint qop_len
= strlen (qop_pos
);
17605 if (qop_len
> 50) return (PARSER_SALT_LENGTH
);
17609 char *digest_pos
= strchr (directive_pos
, '*');
17611 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17616 uint directive_len
= strlen (directive_pos
);
17618 if (directive_len
!= 3) return (PARSER_SALT_LENGTH
);
17620 if (memcmp (directive_pos
, "MD5", 3))
17622 log_info ("ERROR: only the MD5 directive is currently supported\n");
17624 return (PARSER_SIP_AUTH_DIRECTIVE
);
17628 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17633 uint md5_max_len
= 4 * 64;
17635 uint md5_remaining_len
= md5_max_len
;
17637 uint tmp_md5_buf
[md5_max_len
/ 4];
17639 memset (tmp_md5_buf
, 0, sizeof (tmp_md5_buf
));
17641 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17643 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17645 md5_len
+= method_len
+ 1;
17646 tmp_md5_ptr
+= method_len
+ 1;
17648 if (URI_prefix_len
> 0)
17650 md5_remaining_len
= md5_max_len
- md5_len
;
17652 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17654 md5_len
+= URI_prefix_len
+ 1;
17655 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17658 md5_remaining_len
= md5_max_len
- md5_len
;
17660 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17662 md5_len
+= URI_resource_len
;
17663 tmp_md5_ptr
+= URI_resource_len
;
17665 if (URI_suffix_len
> 0)
17667 md5_remaining_len
= md5_max_len
- md5_len
;
17669 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17671 md5_len
+= 1 + URI_suffix_len
;
17674 uint tmp_digest
[4];
17676 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17678 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17679 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17680 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17681 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17687 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17689 uint esalt_len
= 0;
17691 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17693 // there are 2 possibilities for the esalt:
17695 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17697 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17699 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17701 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17713 esalt_len
= 1 + nonce_len
+ 1 + 32;
17715 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17717 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17725 // add 0x80 to esalt
17727 esalt_buf_ptr
[esalt_len
] = 0x80;
17729 sip
->esalt_len
= esalt_len
;
17735 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17737 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17739 uint max_salt_len
= 119;
17741 if (salt_len
> max_salt_len
) return (PARSER_SALT_LENGTH
);
17743 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17745 sip
->salt_len
= salt_len
;
17748 * fake salt (for sorting)
17751 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17755 uint fake_salt_len
= salt_len
;
17757 if (fake_salt_len
> max_salt_len
)
17759 fake_salt_len
= max_salt_len
;
17762 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17764 salt
->salt_len
= fake_salt_len
;
17770 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
17771 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
17772 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
17773 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
17775 digest
[0] = byte_swap_32 (digest
[0]);
17776 digest
[1] = byte_swap_32 (digest
[1]);
17777 digest
[2] = byte_swap_32 (digest
[2]);
17778 digest
[3] = byte_swap_32 (digest
[3]);
17780 return (PARSER_OK
);
17783 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17785 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17787 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17789 u32
*digest
= (u32
*) hash_buf
->digest
;
17791 salt_t
*salt
= hash_buf
->salt
;
17795 char *digest_pos
= input_buf
;
17797 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
17804 char *salt_buf
= input_buf
+ 8 + 1;
17808 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17810 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17812 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17814 salt
->salt_len
= salt_len
;
17816 return (PARSER_OK
);
17819 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17821 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
17823 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17825 u32
*digest
= (u32
*) hash_buf
->digest
;
17827 salt_t
*salt
= hash_buf
->salt
;
17829 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
17835 char *p_buf_pos
= input_buf
+ 4;
17837 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
17839 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17841 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
17843 NumCyclesPower_pos
++;
17845 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
17847 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17849 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
17853 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
17855 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17857 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
17861 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
17863 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17865 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
17869 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
17871 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17873 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
17877 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
17879 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17881 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
17885 char *data_len_pos
= strchr (crc_buf_pos
, '$');
17887 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17889 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
17893 char *unpack_size_pos
= strchr (data_len_pos
, '$');
17895 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17897 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
17901 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
17903 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17905 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
17909 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;
17911 const uint iter
= atoi (NumCyclesPower_pos
);
17912 const uint crc
= atoi (crc_buf_pos
);
17913 const uint p_buf
= atoi (p_buf_pos
);
17914 const uint salt_len
= atoi (salt_len_pos
);
17915 const uint iv_len
= atoi (iv_len_pos
);
17916 const uint unpack_size
= atoi (unpack_size_pos
);
17917 const uint data_len
= atoi (data_len_pos
);
17923 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
17924 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
17926 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
17928 if (data_len
> 384) return (PARSER_SALT_VALUE
);
17930 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
17936 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
17937 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
17938 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
17939 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
17941 seven_zip
->iv_len
= iv_len
;
17943 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
17945 seven_zip
->salt_len
= 0;
17947 seven_zip
->crc
= crc
;
17949 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
17951 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
17953 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
17956 seven_zip
->data_len
= data_len
;
17958 seven_zip
->unpack_size
= unpack_size
;
17962 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
17963 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
17964 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
17965 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
17967 salt
->salt_len
= 16;
17969 salt
->salt_sign
[0] = iter
;
17971 salt
->salt_iter
= 1 << iter
;
17982 return (PARSER_OK
);
17985 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17987 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
17989 u32
*digest
= (u32
*) hash_buf
->digest
;
17991 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17992 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17993 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17994 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17995 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
17996 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
17997 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
17998 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18000 digest
[0] = byte_swap_32 (digest
[0]);
18001 digest
[1] = byte_swap_32 (digest
[1]);
18002 digest
[2] = byte_swap_32 (digest
[2]);
18003 digest
[3] = byte_swap_32 (digest
[3]);
18004 digest
[4] = byte_swap_32 (digest
[4]);
18005 digest
[5] = byte_swap_32 (digest
[5]);
18006 digest
[6] = byte_swap_32 (digest
[6]);
18007 digest
[7] = byte_swap_32 (digest
[7]);
18009 return (PARSER_OK
);
18012 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18014 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18016 u32
*digest
= (u32
*) hash_buf
->digest
;
18018 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18019 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18020 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18021 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18022 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18023 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18024 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18025 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18026 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18027 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18028 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18029 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18030 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18031 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18032 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18033 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18035 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18036 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18037 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18038 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18039 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18040 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18041 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18042 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18043 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18044 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18045 digest
[10] = byte_swap_32 (digest
[10]);
18046 digest
[11] = byte_swap_32 (digest
[11]);
18047 digest
[12] = byte_swap_32 (digest
[12]);
18048 digest
[13] = byte_swap_32 (digest
[13]);
18049 digest
[14] = byte_swap_32 (digest
[14]);
18050 digest
[15] = byte_swap_32 (digest
[15]);
18052 return (PARSER_OK
);
18055 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18057 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18059 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18061 u32
*digest
= (u32
*) hash_buf
->digest
;
18063 salt_t
*salt
= hash_buf
->salt
;
18065 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18073 char *iter_pos
= input_buf
+ 4;
18075 u32 iter
= atoi (iter_pos
);
18077 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18078 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18080 // first is *raw* salt
18082 char *salt_pos
= strchr (iter_pos
, ':');
18084 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18088 char *hash_pos
= strchr (salt_pos
, ':');
18090 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18092 u32 salt_len
= hash_pos
- salt_pos
;
18094 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18098 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18100 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18104 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18106 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18108 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18110 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18111 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18113 salt
->salt_len
= salt_len
;
18114 salt
->salt_iter
= iter
- 1;
18120 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18122 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18124 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18126 memcpy (digest
, tmp_buf
, 16);
18128 // add some stuff to normal salt to make sorted happy
18130 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18131 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18132 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18133 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18134 salt
->salt_buf
[4] = salt
->salt_iter
;
18136 return (PARSER_OK
);
18139 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18141 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18143 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18145 u32
*digest
= (u32
*) hash_buf
->digest
;
18147 salt_t
*salt
= hash_buf
->salt
;
18149 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18157 char *iter_pos
= input_buf
+ 5;
18159 u32 iter
= atoi (iter_pos
);
18161 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18162 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18164 // first is *raw* salt
18166 char *salt_pos
= strchr (iter_pos
, ':');
18168 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18172 char *hash_pos
= strchr (salt_pos
, ':');
18174 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18176 u32 salt_len
= hash_pos
- salt_pos
;
18178 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18182 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18184 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18188 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18190 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18192 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18194 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18195 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18197 salt
->salt_len
= salt_len
;
18198 salt
->salt_iter
= iter
- 1;
18204 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18206 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18208 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18210 memcpy (digest
, tmp_buf
, 16);
18212 digest
[0] = byte_swap_32 (digest
[0]);
18213 digest
[1] = byte_swap_32 (digest
[1]);
18214 digest
[2] = byte_swap_32 (digest
[2]);
18215 digest
[3] = byte_swap_32 (digest
[3]);
18217 // add some stuff to normal salt to make sorted happy
18219 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18220 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18221 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18222 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18223 salt
->salt_buf
[4] = salt
->salt_iter
;
18225 return (PARSER_OK
);
18228 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18230 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18232 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18234 u64
*digest
= (u64
*) hash_buf
->digest
;
18236 salt_t
*salt
= hash_buf
->salt
;
18238 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18246 char *iter_pos
= input_buf
+ 7;
18248 u32 iter
= atoi (iter_pos
);
18250 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18251 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18253 // first is *raw* salt
18255 char *salt_pos
= strchr (iter_pos
, ':');
18257 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18261 char *hash_pos
= strchr (salt_pos
, ':');
18263 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18265 u32 salt_len
= hash_pos
- salt_pos
;
18267 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18271 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18273 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18277 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18279 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18281 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18283 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18284 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18286 salt
->salt_len
= salt_len
;
18287 salt
->salt_iter
= iter
- 1;
18293 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18295 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18297 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18299 memcpy (digest
, tmp_buf
, 64);
18301 digest
[0] = byte_swap_64 (digest
[0]);
18302 digest
[1] = byte_swap_64 (digest
[1]);
18303 digest
[2] = byte_swap_64 (digest
[2]);
18304 digest
[3] = byte_swap_64 (digest
[3]);
18305 digest
[4] = byte_swap_64 (digest
[4]);
18306 digest
[5] = byte_swap_64 (digest
[5]);
18307 digest
[6] = byte_swap_64 (digest
[6]);
18308 digest
[7] = byte_swap_64 (digest
[7]);
18310 // add some stuff to normal salt to make sorted happy
18312 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18313 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18314 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18315 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18316 salt
->salt_buf
[4] = salt
->salt_iter
;
18318 return (PARSER_OK
);
18321 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18323 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18325 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18327 uint
*digest
= (uint
*) hash_buf
->digest
;
18329 salt_t
*salt
= hash_buf
->salt
;
18335 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18337 char *hash_pos
= strchr (salt_pos
, '$');
18339 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18341 u32 salt_len
= hash_pos
- salt_pos
;
18343 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18347 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18349 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18353 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18354 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18372 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18373 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18375 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18376 salt
->salt_len
= 8;
18378 return (PARSER_OK
);
18381 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18383 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18385 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18387 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18389 if (c19
& 3) return (PARSER_HASH_VALUE
);
18391 salt_t
*salt
= hash_buf
->salt
;
18393 u32
*digest
= (u32
*) hash_buf
->digest
;
18397 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18398 | itoa64_to_int (input_buf
[2]) << 6
18399 | itoa64_to_int (input_buf
[3]) << 12
18400 | itoa64_to_int (input_buf
[4]) << 18;
18404 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18405 | itoa64_to_int (input_buf
[6]) << 6
18406 | itoa64_to_int (input_buf
[7]) << 12
18407 | itoa64_to_int (input_buf
[8]) << 18;
18409 salt
->salt_len
= 4;
18413 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18415 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18417 memcpy (digest
, tmp_buf
, 8);
18421 IP (digest
[0], digest
[1], tt
);
18423 digest
[0] = rotr32 (digest
[0], 31);
18424 digest
[1] = rotr32 (digest
[1], 31);
18428 return (PARSER_OK
);
18431 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18433 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18435 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18437 u32
*digest
= (u32
*) hash_buf
->digest
;
18439 salt_t
*salt
= hash_buf
->salt
;
18445 char *type_pos
= input_buf
+ 6 + 1;
18447 char *salt_pos
= strchr (type_pos
, '*');
18449 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18451 u32 type_len
= salt_pos
- type_pos
;
18453 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18457 char *crypted_pos
= strchr (salt_pos
, '*');
18459 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18461 u32 salt_len
= crypted_pos
- salt_pos
;
18463 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18467 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18469 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18475 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18476 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18478 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18479 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18481 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18482 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18483 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18484 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18486 salt
->salt_len
= 24;
18487 salt
->salt_iter
= ROUNDS_RAR3
;
18489 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18490 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18492 digest
[0] = 0xc43d7b00;
18493 digest
[1] = 0x40070000;
18497 return (PARSER_OK
);
18500 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18502 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18504 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18506 u32
*digest
= (u32
*) hash_buf
->digest
;
18508 salt_t
*salt
= hash_buf
->salt
;
18510 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18516 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18518 char *param1_pos
= strchr (param0_pos
, '$');
18520 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18522 u32 param0_len
= param1_pos
- param0_pos
;
18526 char *param2_pos
= strchr (param1_pos
, '$');
18528 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18530 u32 param1_len
= param2_pos
- param1_pos
;
18534 char *param3_pos
= strchr (param2_pos
, '$');
18536 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18538 u32 param2_len
= param3_pos
- param2_pos
;
18542 char *param4_pos
= strchr (param3_pos
, '$');
18544 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18546 u32 param3_len
= param4_pos
- param3_pos
;
18550 char *param5_pos
= strchr (param4_pos
, '$');
18552 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18554 u32 param4_len
= param5_pos
- param4_pos
;
18558 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18560 char *salt_buf
= param1_pos
;
18561 char *iv
= param3_pos
;
18562 char *pswcheck
= param5_pos
;
18564 const uint salt_len
= atoi (param0_pos
);
18565 const uint iterations
= atoi (param2_pos
);
18566 const uint pswcheck_len
= atoi (param4_pos
);
18572 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18573 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18574 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18576 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18577 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18578 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18584 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18585 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18586 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18587 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
18589 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
18590 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
18591 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
18592 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
18594 salt
->salt_len
= 16;
18596 salt
->salt_sign
[0] = iterations
;
18598 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18604 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
18605 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
18609 return (PARSER_OK
);
18612 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18614 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18616 u32
*digest
= (u32
*) hash_buf
->digest
;
18618 salt_t
*salt
= hash_buf
->salt
;
18620 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18621 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18622 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18623 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18624 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18625 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18626 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18627 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18629 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18631 uint salt_len
= input_len
- 64 - 1;
18633 char *salt_buf
= input_buf
+ 64 + 1;
18635 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18637 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18639 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18641 salt
->salt_len
= salt_len
;
18644 * we can precompute the first sha256 transform
18649 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18650 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18651 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18652 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18653 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18654 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18655 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18656 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18657 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18658 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18659 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18660 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18661 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18662 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18663 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18664 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18668 pc256
[0] = SHA256M_A
;
18669 pc256
[1] = SHA256M_B
;
18670 pc256
[2] = SHA256M_C
;
18671 pc256
[3] = SHA256M_D
;
18672 pc256
[4] = SHA256M_E
;
18673 pc256
[5] = SHA256M_F
;
18674 pc256
[6] = SHA256M_G
;
18675 pc256
[7] = SHA256M_H
;
18677 sha256_64 (w
, pc256
);
18679 salt
->salt_buf_pc
[0] = pc256
[0];
18680 salt
->salt_buf_pc
[1] = pc256
[1];
18681 salt
->salt_buf_pc
[2] = pc256
[2];
18682 salt
->salt_buf_pc
[3] = pc256
[3];
18683 salt
->salt_buf_pc
[4] = pc256
[4];
18684 salt
->salt_buf_pc
[5] = pc256
[5];
18685 salt
->salt_buf_pc
[6] = pc256
[6];
18686 salt
->salt_buf_pc
[7] = pc256
[7];
18688 digest
[0] -= pc256
[0];
18689 digest
[1] -= pc256
[1];
18690 digest
[2] -= pc256
[2];
18691 digest
[3] -= pc256
[3];
18692 digest
[4] -= pc256
[4];
18693 digest
[5] -= pc256
[5];
18694 digest
[6] -= pc256
[6];
18695 digest
[7] -= pc256
[7];
18697 return (PARSER_OK
);
18700 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18702 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18704 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18706 u32
*digest
= (u32
*) hash_buf
->digest
;
18708 salt_t
*salt
= hash_buf
->salt
;
18714 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18716 char *data_buf_pos
= strchr (data_len_pos
, '$');
18718 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18720 u32 data_len_len
= data_buf_pos
- data_len_pos
;
18722 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18723 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18727 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18729 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
18731 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
18733 u32 data_len
= atoi (data_len_pos
);
18735 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
18741 char *salt_pos
= data_buf_pos
;
18743 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18744 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18745 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
18746 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
18748 // this is actually the CT, which is also the hash later (if matched)
18750 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
18751 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
18752 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
18753 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
18755 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
18757 salt
->salt_iter
= 10 - 1;
18763 digest
[0] = salt
->salt_buf
[4];
18764 digest
[1] = salt
->salt_buf
[5];
18765 digest
[2] = salt
->salt_buf
[6];
18766 digest
[3] = salt
->salt_buf
[7];
18768 return (PARSER_OK
);
18771 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18773 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
18775 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18777 u32
*digest
= (u32
*) hash_buf
->digest
;
18779 salt_t
*salt
= hash_buf
->salt
;
18785 char *salt_pos
= input_buf
+ 11 + 1;
18787 char *iter_pos
= strchr (salt_pos
, ',');
18789 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18791 u32 salt_len
= iter_pos
- salt_pos
;
18793 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
18797 char *hash_pos
= strchr (iter_pos
, ',');
18799 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18801 u32 iter_len
= hash_pos
- iter_pos
;
18803 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
18807 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
18809 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
18815 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18816 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18817 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
18818 salt
->salt_buf
[3] = 0x00018000;
18820 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18821 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18822 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
18823 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
18825 salt
->salt_len
= salt_len
/ 2;
18827 salt
->salt_iter
= atoi (iter_pos
) - 1;
18833 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18834 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18835 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18836 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18837 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18838 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
18839 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
18840 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
18842 return (PARSER_OK
);
18845 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18847 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
18849 u32
*digest
= (u32
*) hash_buf
->digest
;
18851 salt_t
*salt
= hash_buf
->salt
;
18857 char *hash_pos
= input_buf
+ 64;
18858 char *salt1_pos
= input_buf
+ 128;
18859 char *salt2_pos
= input_buf
;
18865 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
18866 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
18867 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
18868 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
18870 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
18871 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
18872 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
18873 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
18875 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
18876 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
18877 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
18878 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
18880 salt
->salt_len
= 48;
18882 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
18888 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18889 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18890 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18891 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18892 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18893 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
18894 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
18895 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
18897 return (PARSER_OK
);
18901 * parallel running threads
18906 BOOL WINAPI
sigHandler_default (DWORD sig
)
18910 case CTRL_CLOSE_EVENT
:
18913 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
18914 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
18915 * function otherwise it is too late (e.g. after returning from this function)
18920 SetConsoleCtrlHandler (NULL
, TRUE
);
18927 case CTRL_LOGOFF_EVENT
:
18928 case CTRL_SHUTDOWN_EVENT
:
18932 SetConsoleCtrlHandler (NULL
, TRUE
);
18940 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
18944 case CTRL_CLOSE_EVENT
:
18948 SetConsoleCtrlHandler (NULL
, TRUE
);
18955 case CTRL_LOGOFF_EVENT
:
18956 case CTRL_SHUTDOWN_EVENT
:
18960 SetConsoleCtrlHandler (NULL
, TRUE
);
18968 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
18970 if (callback
== NULL
)
18972 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
18976 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
18982 void sigHandler_default (int sig
)
18986 signal (sig
, NULL
);
18989 void sigHandler_benchmark (int sig
)
18993 signal (sig
, NULL
);
18996 void hc_signal (void (callback
) (int))
18998 if (callback
== NULL
) callback
= SIG_DFL
;
19000 signal (SIGINT
, callback
);
19001 signal (SIGTERM
, callback
);
19002 signal (SIGABRT
, callback
);
19007 void status_display ();
19009 void *thread_keypress (void *p
)
19011 int benchmark
= *((int *) p
);
19013 uint quiet
= data
.quiet
;
19017 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19019 int ch
= tty_getchar();
19021 if (ch
== -1) break;
19023 if (ch
== 0) continue;
19029 hc_thread_mutex_lock (mux_display
);
19044 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19045 if (quiet
== 0) fflush (stdout
);
19057 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19058 if (quiet
== 0) fflush (stdout
);
19070 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19071 if (quiet
== 0) fflush (stdout
);
19083 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19084 if (quiet
== 0) fflush (stdout
);
19092 if (benchmark
== 1) break;
19094 stop_at_checkpoint ();
19098 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19099 if (quiet
== 0) fflush (stdout
);
19107 if (benchmark
== 1)
19119 hc_thread_mutex_unlock (mux_display
);
19131 bool class_num (const u8 c
)
19133 return ((c
>= '0') && (c
<= '9'));
19136 bool class_lower (const u8 c
)
19138 return ((c
>= 'a') && (c
<= 'z'));
19141 bool class_upper (const u8 c
)
19143 return ((c
>= 'A') && (c
<= 'Z'));
19146 bool class_alpha (const u8 c
)
19148 return (class_lower (c
) || class_upper (c
));
19151 int conv_ctoi (const u8 c
)
19157 else if (class_upper (c
))
19159 return c
- 'A' + 10;
19165 int conv_itoc (const u8 c
)
19173 return c
+ 'A' - 10;
19183 #define INCR_POS if (++rule_pos == rule_len) return (-1)
19184 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
19185 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
19186 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
19187 #define MAX_KERNEL_RULES 255
19188 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
19189 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19190 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19192 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
19193 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
19194 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19195 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19197 int cpu_rule_to_kernel_rule (char rule_buf
[BUFSIZ
], uint rule_len
, kernel_rule_t
*rule
)
19202 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19204 switch (rule_buf
[rule_pos
])
19210 case RULE_OP_MANGLE_NOOP
:
19211 SET_NAME (rule
, rule_buf
[rule_pos
]);
19214 case RULE_OP_MANGLE_LREST
:
19215 SET_NAME (rule
, rule_buf
[rule_pos
]);
19218 case RULE_OP_MANGLE_UREST
:
19219 SET_NAME (rule
, rule_buf
[rule_pos
]);
19222 case RULE_OP_MANGLE_LREST_UFIRST
:
19223 SET_NAME (rule
, rule_buf
[rule_pos
]);
19226 case RULE_OP_MANGLE_UREST_LFIRST
:
19227 SET_NAME (rule
, rule_buf
[rule_pos
]);
19230 case RULE_OP_MANGLE_TREST
:
19231 SET_NAME (rule
, rule_buf
[rule_pos
]);
19234 case RULE_OP_MANGLE_TOGGLE_AT
:
19235 SET_NAME (rule
, rule_buf
[rule_pos
]);
19236 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19239 case RULE_OP_MANGLE_REVERSE
:
19240 SET_NAME (rule
, rule_buf
[rule_pos
]);
19243 case RULE_OP_MANGLE_DUPEWORD
:
19244 SET_NAME (rule
, rule_buf
[rule_pos
]);
19247 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19248 SET_NAME (rule
, rule_buf
[rule_pos
]);
19249 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19252 case RULE_OP_MANGLE_REFLECT
:
19253 SET_NAME (rule
, rule_buf
[rule_pos
]);
19256 case RULE_OP_MANGLE_ROTATE_LEFT
:
19257 SET_NAME (rule
, rule_buf
[rule_pos
]);
19260 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19261 SET_NAME (rule
, rule_buf
[rule_pos
]);
19264 case RULE_OP_MANGLE_APPEND
:
19265 SET_NAME (rule
, rule_buf
[rule_pos
]);
19266 SET_P0 (rule
, rule_buf
[rule_pos
]);
19269 case RULE_OP_MANGLE_PREPEND
:
19270 SET_NAME (rule
, rule_buf
[rule_pos
]);
19271 SET_P0 (rule
, rule_buf
[rule_pos
]);
19274 case RULE_OP_MANGLE_DELETE_FIRST
:
19275 SET_NAME (rule
, rule_buf
[rule_pos
]);
19278 case RULE_OP_MANGLE_DELETE_LAST
:
19279 SET_NAME (rule
, rule_buf
[rule_pos
]);
19282 case RULE_OP_MANGLE_DELETE_AT
:
19283 SET_NAME (rule
, rule_buf
[rule_pos
]);
19284 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19287 case RULE_OP_MANGLE_EXTRACT
:
19288 SET_NAME (rule
, rule_buf
[rule_pos
]);
19289 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19290 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19293 case RULE_OP_MANGLE_OMIT
:
19294 SET_NAME (rule
, rule_buf
[rule_pos
]);
19295 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19296 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19299 case RULE_OP_MANGLE_INSERT
:
19300 SET_NAME (rule
, rule_buf
[rule_pos
]);
19301 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19302 SET_P1 (rule
, rule_buf
[rule_pos
]);
19305 case RULE_OP_MANGLE_OVERSTRIKE
:
19306 SET_NAME (rule
, rule_buf
[rule_pos
]);
19307 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19308 SET_P1 (rule
, rule_buf
[rule_pos
]);
19311 case RULE_OP_MANGLE_TRUNCATE_AT
:
19312 SET_NAME (rule
, rule_buf
[rule_pos
]);
19313 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19316 case RULE_OP_MANGLE_REPLACE
:
19317 SET_NAME (rule
, rule_buf
[rule_pos
]);
19318 SET_P0 (rule
, rule_buf
[rule_pos
]);
19319 SET_P1 (rule
, rule_buf
[rule_pos
]);
19322 case RULE_OP_MANGLE_PURGECHAR
:
19326 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19330 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19331 SET_NAME (rule
, rule_buf
[rule_pos
]);
19332 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19335 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19336 SET_NAME (rule
, rule_buf
[rule_pos
]);
19337 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19340 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19341 SET_NAME (rule
, rule_buf
[rule_pos
]);
19344 case RULE_OP_MANGLE_SWITCH_FIRST
:
19345 SET_NAME (rule
, rule_buf
[rule_pos
]);
19348 case RULE_OP_MANGLE_SWITCH_LAST
:
19349 SET_NAME (rule
, rule_buf
[rule_pos
]);
19352 case RULE_OP_MANGLE_SWITCH_AT
:
19353 SET_NAME (rule
, rule_buf
[rule_pos
]);
19354 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19355 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19358 case RULE_OP_MANGLE_CHR_SHIFTL
:
19359 SET_NAME (rule
, rule_buf
[rule_pos
]);
19360 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19363 case RULE_OP_MANGLE_CHR_SHIFTR
:
19364 SET_NAME (rule
, rule_buf
[rule_pos
]);
19365 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19368 case RULE_OP_MANGLE_CHR_INCR
:
19369 SET_NAME (rule
, rule_buf
[rule_pos
]);
19370 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19373 case RULE_OP_MANGLE_CHR_DECR
:
19374 SET_NAME (rule
, rule_buf
[rule_pos
]);
19375 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19378 case RULE_OP_MANGLE_REPLACE_NP1
:
19379 SET_NAME (rule
, rule_buf
[rule_pos
]);
19380 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19383 case RULE_OP_MANGLE_REPLACE_NM1
:
19384 SET_NAME (rule
, rule_buf
[rule_pos
]);
19385 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19388 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19389 SET_NAME (rule
, rule_buf
[rule_pos
]);
19390 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19393 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19394 SET_NAME (rule
, rule_buf
[rule_pos
]);
19395 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19398 case RULE_OP_MANGLE_TITLE
:
19399 SET_NAME (rule
, rule_buf
[rule_pos
]);
19408 if (rule_pos
< rule_len
) return (-1);
19413 int kernel_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], kernel_rule_t
*rule
)
19417 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19421 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19425 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19429 case RULE_OP_MANGLE_NOOP
:
19430 rule_buf
[rule_pos
] = rule_cmd
;
19433 case RULE_OP_MANGLE_LREST
:
19434 rule_buf
[rule_pos
] = rule_cmd
;
19437 case RULE_OP_MANGLE_UREST
:
19438 rule_buf
[rule_pos
] = rule_cmd
;
19441 case RULE_OP_MANGLE_LREST_UFIRST
:
19442 rule_buf
[rule_pos
] = rule_cmd
;
19445 case RULE_OP_MANGLE_UREST_LFIRST
:
19446 rule_buf
[rule_pos
] = rule_cmd
;
19449 case RULE_OP_MANGLE_TREST
:
19450 rule_buf
[rule_pos
] = rule_cmd
;
19453 case RULE_OP_MANGLE_TOGGLE_AT
:
19454 rule_buf
[rule_pos
] = rule_cmd
;
19455 GET_P0_CONV (rule
);
19458 case RULE_OP_MANGLE_REVERSE
:
19459 rule_buf
[rule_pos
] = rule_cmd
;
19462 case RULE_OP_MANGLE_DUPEWORD
:
19463 rule_buf
[rule_pos
] = rule_cmd
;
19466 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19467 rule_buf
[rule_pos
] = rule_cmd
;
19468 GET_P0_CONV (rule
);
19471 case RULE_OP_MANGLE_REFLECT
:
19472 rule_buf
[rule_pos
] = rule_cmd
;
19475 case RULE_OP_MANGLE_ROTATE_LEFT
:
19476 rule_buf
[rule_pos
] = rule_cmd
;
19479 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19480 rule_buf
[rule_pos
] = rule_cmd
;
19483 case RULE_OP_MANGLE_APPEND
:
19484 rule_buf
[rule_pos
] = rule_cmd
;
19488 case RULE_OP_MANGLE_PREPEND
:
19489 rule_buf
[rule_pos
] = rule_cmd
;
19493 case RULE_OP_MANGLE_DELETE_FIRST
:
19494 rule_buf
[rule_pos
] = rule_cmd
;
19497 case RULE_OP_MANGLE_DELETE_LAST
:
19498 rule_buf
[rule_pos
] = rule_cmd
;
19501 case RULE_OP_MANGLE_DELETE_AT
:
19502 rule_buf
[rule_pos
] = rule_cmd
;
19503 GET_P0_CONV (rule
);
19506 case RULE_OP_MANGLE_EXTRACT
:
19507 rule_buf
[rule_pos
] = rule_cmd
;
19508 GET_P0_CONV (rule
);
19509 GET_P1_CONV (rule
);
19512 case RULE_OP_MANGLE_OMIT
:
19513 rule_buf
[rule_pos
] = rule_cmd
;
19514 GET_P0_CONV (rule
);
19515 GET_P1_CONV (rule
);
19518 case RULE_OP_MANGLE_INSERT
:
19519 rule_buf
[rule_pos
] = rule_cmd
;
19520 GET_P0_CONV (rule
);
19524 case RULE_OP_MANGLE_OVERSTRIKE
:
19525 rule_buf
[rule_pos
] = rule_cmd
;
19526 GET_P0_CONV (rule
);
19530 case RULE_OP_MANGLE_TRUNCATE_AT
:
19531 rule_buf
[rule_pos
] = rule_cmd
;
19532 GET_P0_CONV (rule
);
19535 case RULE_OP_MANGLE_REPLACE
:
19536 rule_buf
[rule_pos
] = rule_cmd
;
19541 case RULE_OP_MANGLE_PURGECHAR
:
19545 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19549 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19550 rule_buf
[rule_pos
] = rule_cmd
;
19551 GET_P0_CONV (rule
);
19554 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19555 rule_buf
[rule_pos
] = rule_cmd
;
19556 GET_P0_CONV (rule
);
19559 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19560 rule_buf
[rule_pos
] = rule_cmd
;
19563 case RULE_OP_MANGLE_SWITCH_FIRST
:
19564 rule_buf
[rule_pos
] = rule_cmd
;
19567 case RULE_OP_MANGLE_SWITCH_LAST
:
19568 rule_buf
[rule_pos
] = rule_cmd
;
19571 case RULE_OP_MANGLE_SWITCH_AT
:
19572 rule_buf
[rule_pos
] = rule_cmd
;
19573 GET_P0_CONV (rule
);
19574 GET_P1_CONV (rule
);
19577 case RULE_OP_MANGLE_CHR_SHIFTL
:
19578 rule_buf
[rule_pos
] = rule_cmd
;
19579 GET_P0_CONV (rule
);
19582 case RULE_OP_MANGLE_CHR_SHIFTR
:
19583 rule_buf
[rule_pos
] = rule_cmd
;
19584 GET_P0_CONV (rule
);
19587 case RULE_OP_MANGLE_CHR_INCR
:
19588 rule_buf
[rule_pos
] = rule_cmd
;
19589 GET_P0_CONV (rule
);
19592 case RULE_OP_MANGLE_CHR_DECR
:
19593 rule_buf
[rule_pos
] = rule_cmd
;
19594 GET_P0_CONV (rule
);
19597 case RULE_OP_MANGLE_REPLACE_NP1
:
19598 rule_buf
[rule_pos
] = rule_cmd
;
19599 GET_P0_CONV (rule
);
19602 case RULE_OP_MANGLE_REPLACE_NM1
:
19603 rule_buf
[rule_pos
] = rule_cmd
;
19604 GET_P0_CONV (rule
);
19607 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19608 rule_buf
[rule_pos
] = rule_cmd
;
19609 GET_P0_CONV (rule
);
19612 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19613 rule_buf
[rule_pos
] = rule_cmd
;
19614 GET_P0_CONV (rule
);
19617 case RULE_OP_MANGLE_TITLE
:
19618 rule_buf
[rule_pos
] = rule_cmd
;
19622 return rule_pos
- 1;
19640 * CPU rules : this is from hashcat sources, cpu based rules
19643 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19644 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19646 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19647 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19648 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19650 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19651 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19652 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19654 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19658 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19663 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19667 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19672 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19676 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19681 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19686 for (l
= 0; l
< arr_len
; l
++)
19688 r
= arr_len
- 1 - l
;
19692 MANGLE_SWITCH (arr
, l
, r
);
19698 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19700 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19702 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19704 return (arr_len
* 2);
19707 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19709 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19711 int orig_len
= arr_len
;
19715 for (i
= 0; i
< times
; i
++)
19717 memcpy (&arr
[arr_len
], arr
, orig_len
);
19719 arr_len
+= orig_len
;
19725 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19727 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19729 mangle_double (arr
, arr_len
);
19731 mangle_reverse (arr
+ arr_len
, arr_len
);
19733 return (arr_len
* 2);
19736 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
19741 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
19743 MANGLE_SWITCH (arr
, l
, r
);
19749 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
19754 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
19756 MANGLE_SWITCH (arr
, l
, r
);
19762 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19764 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19768 return (arr_len
+ 1);
19771 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19773 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19777 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19779 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19784 return (arr_len
+ 1);
19787 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19789 if (upos
>= arr_len
) return (arr_len
);
19793 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
19795 arr
[arr_pos
] = arr
[arr_pos
+ 1];
19798 return (arr_len
- 1);
19801 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19803 if (upos
>= arr_len
) return (arr_len
);
19805 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
19809 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
19811 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
19817 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19819 if (upos
>= arr_len
) return (arr_len
);
19821 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
19825 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
19827 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
19830 return (arr_len
- ulen
);
19833 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19835 if (upos
>= arr_len
) return (arr_len
);
19837 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19841 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
19843 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19848 return (arr_len
+ 1);
19851 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
)
19853 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
19855 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
19857 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
19859 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
19861 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
19863 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
19865 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
19867 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
19869 return (arr_len
+ arr2_cpy
);
19872 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19874 if (upos
>= arr_len
) return (arr_len
);
19881 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19883 if (upos
>= arr_len
) return (arr_len
);
19885 memset (arr
+ upos
, 0, arr_len
- upos
);
19890 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
19894 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19896 if (arr
[arr_pos
] != oldc
) continue;
19898 arr
[arr_pos
] = newc
;
19904 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19910 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19912 if (arr
[arr_pos
] == c
) continue;
19914 arr
[ret_len
] = arr
[arr_pos
];
19922 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19924 if (ulen
> arr_len
) return (arr_len
);
19926 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19930 memcpy (cs
, arr
, ulen
);
19934 for (i
= 0; i
< ulen
; i
++)
19938 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
19944 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19946 if (ulen
> arr_len
) return (arr_len
);
19948 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19950 int upos
= arr_len
- ulen
;
19954 for (i
= 0; i
< ulen
; i
++)
19956 char c
= arr
[upos
+ i
];
19958 arr_len
= mangle_append (arr
, arr_len
, c
);
19964 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19966 if ( arr_len
== 0) return (arr_len
);
19967 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19969 char c
= arr
[upos
];
19973 for (i
= 0; i
< ulen
; i
++)
19975 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
19981 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
19983 if ( arr_len
== 0) return (arr_len
);
19984 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19988 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19990 int new_pos
= arr_pos
* 2;
19992 arr
[new_pos
] = arr
[arr_pos
];
19994 arr
[new_pos
+ 1] = arr
[arr_pos
];
19997 return (arr_len
* 2);
20000 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20002 if (upos
>= arr_len
) return (arr_len
);
20003 if (upos2
>= arr_len
) return (arr_len
);
20005 MANGLE_SWITCH (arr
, upos
, upos2
);
20010 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20012 MANGLE_SWITCH (arr
, upos
, upos2
);
20017 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20019 if (upos
>= arr_len
) return (arr_len
);
20026 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20028 if (upos
>= arr_len
) return (arr_len
);
20035 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20037 if (upos
>= arr_len
) return (arr_len
);
20044 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20046 if (upos
>= arr_len
) return (arr_len
);
20053 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20055 int upper_next
= 1;
20059 for (pos
= 0; pos
< arr_len
; pos
++)
20061 if (arr
[pos
] == ' ')
20072 MANGLE_UPPER_AT (arr
, pos
);
20076 MANGLE_LOWER_AT (arr
, pos
);
20083 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20085 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20091 for (j
= 0; j
< rp_gen_num
; j
++)
20098 switch ((char) get_random_num (0, 9))
20101 r
= get_random_num (0, sizeof (grp_op_nop
));
20102 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20106 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20107 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20108 p1
= get_random_num (0, sizeof (grp_pos
));
20109 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20113 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20114 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20115 p1
= get_random_num (1, 6);
20116 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20120 r
= get_random_num (0, sizeof (grp_op_chr
));
20121 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20122 p1
= get_random_num (0x20, 0x7e);
20123 rule_buf
[rule_pos
++] = (char) p1
;
20127 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20128 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20129 p1
= get_random_num (0x20, 0x7e);
20130 rule_buf
[rule_pos
++] = (char) p1
;
20131 p2
= get_random_num (0x20, 0x7e);
20133 p2
= get_random_num (0x20, 0x7e);
20134 rule_buf
[rule_pos
++] = (char) p2
;
20138 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20139 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20140 p1
= get_random_num (0, sizeof (grp_pos
));
20141 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20142 p2
= get_random_num (0x20, 0x7e);
20143 rule_buf
[rule_pos
++] = (char) p2
;
20147 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20148 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20149 p1
= get_random_num (0, sizeof (grp_pos
));
20150 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20151 p2
= get_random_num (0, sizeof (grp_pos
));
20153 p2
= get_random_num (0, sizeof (grp_pos
));
20154 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20158 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20159 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
20160 p1
= get_random_num (0, sizeof (grp_pos
));
20161 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20162 p2
= get_random_num (1, sizeof (grp_pos
));
20164 p2
= get_random_num (1, sizeof (grp_pos
));
20165 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20169 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
20170 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
20171 p1
= get_random_num (0, sizeof (grp_pos
));
20172 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20173 p2
= get_random_num (1, sizeof (grp_pos
));
20174 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20175 p3
= get_random_num (0, sizeof (grp_pos
));
20176 rule_buf
[rule_pos
++] = grp_pos
[p3
];
20184 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
20186 char mem
[BLOCK_SIZE
];
20188 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
20190 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
20192 if (in_len
< 1) return (RULE_RC_REJECT_ERROR
);
20194 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
20196 int out_len
= in_len
;
20197 int mem_len
= in_len
;
20199 memcpy (out
, in
, out_len
);
20203 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
20205 int upos
; int upos2
;
20208 switch (rule
[rule_pos
])
20213 case RULE_OP_MANGLE_NOOP
:
20216 case RULE_OP_MANGLE_LREST
:
20217 out_len
= mangle_lrest (out
, out_len
);
20220 case RULE_OP_MANGLE_UREST
:
20221 out_len
= mangle_urest (out
, out_len
);
20224 case RULE_OP_MANGLE_LREST_UFIRST
:
20225 out_len
= mangle_lrest (out
, out_len
);
20226 if (out_len
) MANGLE_UPPER_AT (out
, 0);
20229 case RULE_OP_MANGLE_UREST_LFIRST
:
20230 out_len
= mangle_urest (out
, out_len
);
20231 if (out_len
) MANGLE_LOWER_AT (out
, 0);
20234 case RULE_OP_MANGLE_TREST
:
20235 out_len
= mangle_trest (out
, out_len
);
20238 case RULE_OP_MANGLE_TOGGLE_AT
:
20239 NEXT_RULEPOS (rule_pos
);
20240 NEXT_RPTOI (rule
, rule_pos
, upos
);
20241 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
20244 case RULE_OP_MANGLE_REVERSE
:
20245 out_len
= mangle_reverse (out
, out_len
);
20248 case RULE_OP_MANGLE_DUPEWORD
:
20249 out_len
= mangle_double (out
, out_len
);
20252 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20253 NEXT_RULEPOS (rule_pos
);
20254 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20255 out_len
= mangle_double_times (out
, out_len
, ulen
);
20258 case RULE_OP_MANGLE_REFLECT
:
20259 out_len
= mangle_reflect (out
, out_len
);
20262 case RULE_OP_MANGLE_ROTATE_LEFT
:
20263 mangle_rotate_left (out
, out_len
);
20266 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20267 mangle_rotate_right (out
, out_len
);
20270 case RULE_OP_MANGLE_APPEND
:
20271 NEXT_RULEPOS (rule_pos
);
20272 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
20275 case RULE_OP_MANGLE_PREPEND
:
20276 NEXT_RULEPOS (rule_pos
);
20277 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
20280 case RULE_OP_MANGLE_DELETE_FIRST
:
20281 out_len
= mangle_delete_at (out
, out_len
, 0);
20284 case RULE_OP_MANGLE_DELETE_LAST
:
20285 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
20288 case RULE_OP_MANGLE_DELETE_AT
:
20289 NEXT_RULEPOS (rule_pos
);
20290 NEXT_RPTOI (rule
, rule_pos
, upos
);
20291 out_len
= mangle_delete_at (out
, out_len
, upos
);
20294 case RULE_OP_MANGLE_EXTRACT
:
20295 NEXT_RULEPOS (rule_pos
);
20296 NEXT_RPTOI (rule
, rule_pos
, upos
);
20297 NEXT_RULEPOS (rule_pos
);
20298 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20299 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
20302 case RULE_OP_MANGLE_OMIT
:
20303 NEXT_RULEPOS (rule_pos
);
20304 NEXT_RPTOI (rule
, rule_pos
, upos
);
20305 NEXT_RULEPOS (rule_pos
);
20306 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20307 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
20310 case RULE_OP_MANGLE_INSERT
:
20311 NEXT_RULEPOS (rule_pos
);
20312 NEXT_RPTOI (rule
, rule_pos
, upos
);
20313 NEXT_RULEPOS (rule_pos
);
20314 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
20317 case RULE_OP_MANGLE_OVERSTRIKE
:
20318 NEXT_RULEPOS (rule_pos
);
20319 NEXT_RPTOI (rule
, rule_pos
, upos
);
20320 NEXT_RULEPOS (rule_pos
);
20321 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20324 case RULE_OP_MANGLE_TRUNCATE_AT
:
20325 NEXT_RULEPOS (rule_pos
);
20326 NEXT_RPTOI (rule
, rule_pos
, upos
);
20327 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20330 case RULE_OP_MANGLE_REPLACE
:
20331 NEXT_RULEPOS (rule_pos
);
20332 NEXT_RULEPOS (rule_pos
);
20333 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20336 case RULE_OP_MANGLE_PURGECHAR
:
20337 NEXT_RULEPOS (rule_pos
);
20338 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20341 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20345 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20346 NEXT_RULEPOS (rule_pos
);
20347 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20348 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20351 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20352 NEXT_RULEPOS (rule_pos
);
20353 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20354 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20357 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20358 out_len
= mangle_dupechar (out
, out_len
);
20361 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20362 NEXT_RULEPOS (rule_pos
);
20363 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20364 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20367 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20368 NEXT_RULEPOS (rule_pos
);
20369 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20370 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20373 case RULE_OP_MANGLE_SWITCH_FIRST
:
20374 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20377 case RULE_OP_MANGLE_SWITCH_LAST
:
20378 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20381 case RULE_OP_MANGLE_SWITCH_AT
:
20382 NEXT_RULEPOS (rule_pos
);
20383 NEXT_RPTOI (rule
, rule_pos
, upos
);
20384 NEXT_RULEPOS (rule_pos
);
20385 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20386 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20389 case RULE_OP_MANGLE_CHR_SHIFTL
:
20390 NEXT_RULEPOS (rule_pos
);
20391 NEXT_RPTOI (rule
, rule_pos
, upos
);
20392 mangle_chr_shiftl (out
, out_len
, upos
);
20395 case RULE_OP_MANGLE_CHR_SHIFTR
:
20396 NEXT_RULEPOS (rule_pos
);
20397 NEXT_RPTOI (rule
, rule_pos
, upos
);
20398 mangle_chr_shiftr (out
, out_len
, upos
);
20401 case RULE_OP_MANGLE_CHR_INCR
:
20402 NEXT_RULEPOS (rule_pos
);
20403 NEXT_RPTOI (rule
, rule_pos
, upos
);
20404 mangle_chr_incr (out
, out_len
, upos
);
20407 case RULE_OP_MANGLE_CHR_DECR
:
20408 NEXT_RULEPOS (rule_pos
);
20409 NEXT_RPTOI (rule
, rule_pos
, upos
);
20410 mangle_chr_decr (out
, out_len
, upos
);
20413 case RULE_OP_MANGLE_REPLACE_NP1
:
20414 NEXT_RULEPOS (rule_pos
);
20415 NEXT_RPTOI (rule
, rule_pos
, upos
);
20416 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20419 case RULE_OP_MANGLE_REPLACE_NM1
:
20420 NEXT_RULEPOS (rule_pos
);
20421 NEXT_RPTOI (rule
, rule_pos
, upos
);
20422 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20425 case RULE_OP_MANGLE_TITLE
:
20426 out_len
= mangle_title (out
, out_len
);
20429 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20430 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20431 NEXT_RULEPOS (rule_pos
);
20432 NEXT_RPTOI (rule
, rule_pos
, upos
);
20433 NEXT_RULEPOS (rule_pos
);
20434 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20435 NEXT_RULEPOS (rule_pos
);
20436 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20437 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20440 case RULE_OP_MANGLE_APPEND_MEMORY
:
20441 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20442 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20443 memcpy (out
+ out_len
, mem
, mem_len
);
20444 out_len
+= mem_len
;
20447 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20448 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20449 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20450 memcpy (mem
+ mem_len
, out
, out_len
);
20451 out_len
+= mem_len
;
20452 memcpy (out
, mem
, out_len
);
20455 case RULE_OP_MEMORIZE_WORD
:
20456 memcpy (mem
, out
, out_len
);
20460 case RULE_OP_REJECT_LESS
:
20461 NEXT_RULEPOS (rule_pos
);
20462 NEXT_RPTOI (rule
, rule_pos
, upos
);
20463 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20466 case RULE_OP_REJECT_GREATER
:
20467 NEXT_RULEPOS (rule_pos
);
20468 NEXT_RPTOI (rule
, rule_pos
, upos
);
20469 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20472 case RULE_OP_REJECT_CONTAIN
:
20473 NEXT_RULEPOS (rule_pos
);
20474 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20477 case RULE_OP_REJECT_NOT_CONTAIN
:
20478 NEXT_RULEPOS (rule_pos
);
20479 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20482 case RULE_OP_REJECT_EQUAL_FIRST
:
20483 NEXT_RULEPOS (rule_pos
);
20484 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20487 case RULE_OP_REJECT_EQUAL_LAST
:
20488 NEXT_RULEPOS (rule_pos
);
20489 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20492 case RULE_OP_REJECT_EQUAL_AT
:
20493 NEXT_RULEPOS (rule_pos
);
20494 NEXT_RPTOI (rule
, rule_pos
, upos
);
20495 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20496 NEXT_RULEPOS (rule_pos
);
20497 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20500 case RULE_OP_REJECT_CONTAINS
:
20501 NEXT_RULEPOS (rule_pos
);
20502 NEXT_RPTOI (rule
, rule_pos
, upos
);
20503 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20504 NEXT_RULEPOS (rule_pos
);
20505 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20506 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20509 case RULE_OP_REJECT_MEMORY
:
20510 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20514 return (RULE_RC_SYNTAX_ERROR
);
20519 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);