2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
19 u32
rotl32 (const u32 a
, const u32 n
)
21 return ((a
<< n
) | (a
>> (32 - n
)));
24 u32
rotr32 (const u32 a
, const u32 n
)
26 return ((a
>> n
) | (a
<< (32 - n
)));
29 u64
rotl64 (const u64 a
, const u64 n
)
31 return ((a
<< n
) | (a
>> (64 - n
)));
34 u64
rotr64 (const u64 a
, const u64 n
)
36 return ((a
>> n
) | (a
<< (64 - n
)));
39 u32
byte_swap_32 (const u32 n
)
41 return (n
& 0xff000000) >> 24
42 | (n
& 0x00ff0000) >> 8
43 | (n
& 0x0000ff00) << 8
44 | (n
& 0x000000ff) << 24;
47 u64
byte_swap_64 (const u64 n
)
49 return (n
& 0xff00000000000000ULL
) >> 56
50 | (n
& 0x00ff000000000000ULL
) >> 40
51 | (n
& 0x0000ff0000000000ULL
) >> 24
52 | (n
& 0x000000ff00000000ULL
) >> 8
53 | (n
& 0x00000000ff000000ULL
) << 8
54 | (n
& 0x0000000000ff0000ULL
) << 24
55 | (n
& 0x000000000000ff00ULL
) << 40
56 | (n
& 0x00000000000000ffULL
) << 56;
60 * ciphers for use on cpu
67 * hashes for use on cpu
71 #include "cpu-sha256.c"
79 void log_final (FILE *fp
, const char *fmt
, va_list ap
)
85 for (int i
= 0; i
< last_len
; i
++)
95 int max_len
= (int) sizeof (s
);
97 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
99 if (len
> max_len
) len
= max_len
;
101 fwrite (s
, len
, 1, fp
);
108 void log_out_nn (FILE *fp
, const char *fmt
, ...)
110 if (SUPPRESS_OUTPUT
) return;
116 log_final (fp
, fmt
, ap
);
121 void log_info_nn (const char *fmt
, ...)
123 if (SUPPRESS_OUTPUT
) return;
129 log_final (stdout
, fmt
, ap
);
134 void log_error_nn (const char *fmt
, ...)
136 if (SUPPRESS_OUTPUT
) return;
142 log_final (stderr
, fmt
, ap
);
147 void log_out (FILE *fp
, const char *fmt
, ...)
149 if (SUPPRESS_OUTPUT
) return;
155 log_final (fp
, fmt
, ap
);
164 void log_info (const char *fmt
, ...)
166 if (SUPPRESS_OUTPUT
) return;
172 log_final (stdout
, fmt
, ap
);
176 fputc ('\n', stdout
);
181 void log_error (const char *fmt
, ...)
183 if (SUPPRESS_OUTPUT
) return;
185 fputc ('\n', stderr
);
186 fputc ('\n', stderr
);
192 log_final (stderr
, fmt
, ap
);
196 fputc ('\n', stderr
);
197 fputc ('\n', stderr
);
206 u8
int_to_base32 (const u8 c
)
208 static const u8 tbl
[0x20] =
210 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
211 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
217 u8
base32_to_int (const u8 c
)
219 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
220 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
225 u8
int_to_itoa32 (const u8 c
)
227 static const u8 tbl
[0x20] =
229 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
230 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
236 u8
itoa32_to_int (const u8 c
)
238 if ((c
>= '0') && (c
<= '9')) return c
- '0';
239 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
244 u8
int_to_itoa64 (const u8 c
)
246 static const u8 tbl
[0x40] =
248 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
249 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
250 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
251 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
257 u8
itoa64_to_int (const u8 c
)
259 static const u8 tbl
[0x100] =
261 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
262 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
263 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
264 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
265 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
266 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
267 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
268 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
269 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
270 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
271 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
272 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
273 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
274 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
275 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
276 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
282 u8
int_to_base64 (const u8 c
)
284 static const u8 tbl
[0x40] =
286 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
287 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
288 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
289 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
295 u8
base64_to_int (const u8 c
)
297 static const u8 tbl
[0x100] =
299 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
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, 0x3e, 0x00, 0x00, 0x00, 0x3f,
302 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
303 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
304 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
305 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
306 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
307 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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,
320 u8
int_to_bf64 (const u8 c
)
322 static const u8 tbl
[0x40] =
324 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
325 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
326 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
327 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
333 u8
bf64_to_int (const u8 c
)
335 static const u8 tbl
[0x100] =
337 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
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, 0x01,
340 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
341 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
342 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
343 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
344 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
345 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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,
358 u8
int_to_lotus64 (const u8 c
)
360 if (c
< 10) return '0' + c
;
361 else if (c
< 36) return 'A' + c
- 10;
362 else if (c
< 62) return 'a' + c
- 36;
363 else if (c
== 62) return '+';
364 else if (c
== 63) return '/';
369 u8
lotus64_to_int (const u8 c
)
371 if ((c
>= '0') && (c
<= '9')) return c
- '0';
372 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
373 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
374 else if (c
== '+') return 62;
375 else if (c
== '/') return 63;
381 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
383 const u8
*in_ptr
= in_buf
;
385 u8
*out_ptr
= out_buf
;
387 for (int i
= 0; i
< in_len
; i
+= 8)
389 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
390 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
391 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
392 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
393 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
394 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
395 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
396 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
398 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
399 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
400 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
401 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
402 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
408 for (int i
= 0; i
< in_len
; i
++)
410 if (in_buf
[i
] != '=') continue;
415 int out_len
= (in_len
* 5) / 8;
420 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
422 const u8
*in_ptr
= in_buf
;
424 u8
*out_ptr
= out_buf
;
426 for (int i
= 0; i
< in_len
; i
+= 5)
428 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
429 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
430 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
431 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
432 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
433 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
434 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
435 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
437 out_ptr
[0] = out_val0
& 0x7f;
438 out_ptr
[1] = out_val1
& 0x7f;
439 out_ptr
[2] = out_val2
& 0x7f;
440 out_ptr
[3] = out_val3
& 0x7f;
441 out_ptr
[4] = out_val4
& 0x7f;
442 out_ptr
[5] = out_val5
& 0x7f;
443 out_ptr
[6] = out_val6
& 0x7f;
444 out_ptr
[7] = out_val7
& 0x7f;
450 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
454 out_buf
[out_len
] = '=';
462 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
464 const u8
*in_ptr
= in_buf
;
466 u8
*out_ptr
= out_buf
;
468 for (int i
= 0; i
< in_len
; i
+= 4)
470 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
471 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
472 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
473 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
475 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
476 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
477 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
483 for (int i
= 0; i
< in_len
; i
++)
485 if (in_buf
[i
] != '=') continue;
490 int out_len
= (in_len
* 6) / 8;
495 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
497 const u8
*in_ptr
= in_buf
;
499 u8
*out_ptr
= out_buf
;
501 for (int i
= 0; i
< in_len
; i
+= 3)
503 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
504 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
505 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
506 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
508 out_ptr
[0] = out_val0
& 0x7f;
509 out_ptr
[1] = out_val1
& 0x7f;
510 out_ptr
[2] = out_val2
& 0x7f;
511 out_ptr
[3] = out_val3
& 0x7f;
517 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
521 out_buf
[out_len
] = '=';
529 int is_valid_hex_char (const u8 c
)
531 if ((c
>= '0') && (c
<= '9')) return 1;
532 if ((c
>= 'A') && (c
<= 'F')) return 1;
533 if ((c
>= 'a') && (c
<= 'f')) return 1;
538 u8
hex_convert (const u8 c
)
540 return (c
& 15) + (c
>> 6) * 9;
543 u8
hex_to_u8 (const u8 hex
[2])
547 v
|= (hex_convert (hex
[1]) << 0);
548 v
|= (hex_convert (hex
[0]) << 4);
553 u32
hex_to_u32 (const u8 hex
[8])
557 v
|= ((u32
) hex_convert (hex
[7])) << 0;
558 v
|= ((u32
) hex_convert (hex
[6])) << 4;
559 v
|= ((u32
) hex_convert (hex
[5])) << 8;
560 v
|= ((u32
) hex_convert (hex
[4])) << 12;
561 v
|= ((u32
) hex_convert (hex
[3])) << 16;
562 v
|= ((u32
) hex_convert (hex
[2])) << 20;
563 v
|= ((u32
) hex_convert (hex
[1])) << 24;
564 v
|= ((u32
) hex_convert (hex
[0])) << 28;
569 u64
hex_to_u64 (const u8 hex
[16])
573 v
|= ((u64
) hex_convert (hex
[15]) << 0);
574 v
|= ((u64
) hex_convert (hex
[14]) << 4);
575 v
|= ((u64
) hex_convert (hex
[13]) << 8);
576 v
|= ((u64
) hex_convert (hex
[12]) << 12);
577 v
|= ((u64
) hex_convert (hex
[11]) << 16);
578 v
|= ((u64
) hex_convert (hex
[10]) << 20);
579 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
580 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
581 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
582 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
583 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
584 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
585 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
586 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
587 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
588 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
593 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
595 hex
[0] = v
>> 28 & 15;
596 hex
[1] = v
>> 24 & 15;
597 hex
[2] = v
>> 20 & 15;
598 hex
[3] = v
>> 16 & 15;
599 hex
[4] = v
>> 12 & 15;
600 hex
[5] = v
>> 8 & 15;
601 hex
[6] = v
>> 4 & 15;
602 hex
[7] = v
>> 0 & 15;
606 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
607 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
608 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
609 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
610 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
611 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
612 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
613 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
620 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
624 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
633 for (int i
= 0; i
< 16; i
+= 4)
643 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
650 out
[i
+ 0] = _out
[0];
651 out
[i
+ 1] = _out
[1];
652 out
[i
+ 2] = _out
[2];
653 out
[i
+ 3] = _out
[3];
662 static void juniper_decrypt_hash (char *in
, char *out
)
666 u8 base64_buf
[100] = { 0 };
668 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
672 u32 juniper_iv
[4] = { 0 };
674 memcpy (juniper_iv
, base64_buf
, 12);
676 memcpy (out
, juniper_iv
, 12);
680 u32 juniper_key
[4] = { 0 };
682 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
683 juniper_key
[1] = byte_swap_32 (0x8df91059);
684 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
685 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
689 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
690 u32
*out_ptr
= (u32
*) (out
+ 12);
692 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
695 void phpass_decode (u8 digest
[16], u8 buf
[22])
699 l
= itoa64_to_int (buf
[ 0]) << 0;
700 l
|= itoa64_to_int (buf
[ 1]) << 6;
701 l
|= itoa64_to_int (buf
[ 2]) << 12;
702 l
|= itoa64_to_int (buf
[ 3]) << 18;
704 digest
[ 0] = (l
>> 0) & 0xff;
705 digest
[ 1] = (l
>> 8) & 0xff;
706 digest
[ 2] = (l
>> 16) & 0xff;
708 l
= itoa64_to_int (buf
[ 4]) << 0;
709 l
|= itoa64_to_int (buf
[ 5]) << 6;
710 l
|= itoa64_to_int (buf
[ 6]) << 12;
711 l
|= itoa64_to_int (buf
[ 7]) << 18;
713 digest
[ 3] = (l
>> 0) & 0xff;
714 digest
[ 4] = (l
>> 8) & 0xff;
715 digest
[ 5] = (l
>> 16) & 0xff;
717 l
= itoa64_to_int (buf
[ 8]) << 0;
718 l
|= itoa64_to_int (buf
[ 9]) << 6;
719 l
|= itoa64_to_int (buf
[10]) << 12;
720 l
|= itoa64_to_int (buf
[11]) << 18;
722 digest
[ 6] = (l
>> 0) & 0xff;
723 digest
[ 7] = (l
>> 8) & 0xff;
724 digest
[ 8] = (l
>> 16) & 0xff;
726 l
= itoa64_to_int (buf
[12]) << 0;
727 l
|= itoa64_to_int (buf
[13]) << 6;
728 l
|= itoa64_to_int (buf
[14]) << 12;
729 l
|= itoa64_to_int (buf
[15]) << 18;
731 digest
[ 9] = (l
>> 0) & 0xff;
732 digest
[10] = (l
>> 8) & 0xff;
733 digest
[11] = (l
>> 16) & 0xff;
735 l
= itoa64_to_int (buf
[16]) << 0;
736 l
|= itoa64_to_int (buf
[17]) << 6;
737 l
|= itoa64_to_int (buf
[18]) << 12;
738 l
|= itoa64_to_int (buf
[19]) << 18;
740 digest
[12] = (l
>> 0) & 0xff;
741 digest
[13] = (l
>> 8) & 0xff;
742 digest
[14] = (l
>> 16) & 0xff;
744 l
= itoa64_to_int (buf
[20]) << 0;
745 l
|= itoa64_to_int (buf
[21]) << 6;
747 digest
[15] = (l
>> 0) & 0xff;
750 void phpass_encode (u8 digest
[16], u8 buf
[22])
754 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
756 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
757 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
758 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
759 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
761 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
763 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
764 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
765 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
766 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
768 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
770 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
771 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
772 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
773 buf
[11] = int_to_itoa64 (l
& 0x3f);
775 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
777 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
778 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
779 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
780 buf
[15] = int_to_itoa64 (l
& 0x3f);
782 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
784 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
785 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
786 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
787 buf
[19] = int_to_itoa64 (l
& 0x3f);
789 l
= (digest
[15] << 0);
791 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
792 buf
[21] = int_to_itoa64 (l
& 0x3f);
795 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
799 l
= itoa64_to_int (buf
[ 0]) << 0;
800 l
|= itoa64_to_int (buf
[ 1]) << 6;
801 l
|= itoa64_to_int (buf
[ 2]) << 12;
802 l
|= itoa64_to_int (buf
[ 3]) << 18;
804 digest
[ 0] = (l
>> 16) & 0xff;
805 digest
[ 6] = (l
>> 8) & 0xff;
806 digest
[12] = (l
>> 0) & 0xff;
808 l
= itoa64_to_int (buf
[ 4]) << 0;
809 l
|= itoa64_to_int (buf
[ 5]) << 6;
810 l
|= itoa64_to_int (buf
[ 6]) << 12;
811 l
|= itoa64_to_int (buf
[ 7]) << 18;
813 digest
[ 1] = (l
>> 16) & 0xff;
814 digest
[ 7] = (l
>> 8) & 0xff;
815 digest
[13] = (l
>> 0) & 0xff;
817 l
= itoa64_to_int (buf
[ 8]) << 0;
818 l
|= itoa64_to_int (buf
[ 9]) << 6;
819 l
|= itoa64_to_int (buf
[10]) << 12;
820 l
|= itoa64_to_int (buf
[11]) << 18;
822 digest
[ 2] = (l
>> 16) & 0xff;
823 digest
[ 8] = (l
>> 8) & 0xff;
824 digest
[14] = (l
>> 0) & 0xff;
826 l
= itoa64_to_int (buf
[12]) << 0;
827 l
|= itoa64_to_int (buf
[13]) << 6;
828 l
|= itoa64_to_int (buf
[14]) << 12;
829 l
|= itoa64_to_int (buf
[15]) << 18;
831 digest
[ 3] = (l
>> 16) & 0xff;
832 digest
[ 9] = (l
>> 8) & 0xff;
833 digest
[15] = (l
>> 0) & 0xff;
835 l
= itoa64_to_int (buf
[16]) << 0;
836 l
|= itoa64_to_int (buf
[17]) << 6;
837 l
|= itoa64_to_int (buf
[18]) << 12;
838 l
|= itoa64_to_int (buf
[19]) << 18;
840 digest
[ 4] = (l
>> 16) & 0xff;
841 digest
[10] = (l
>> 8) & 0xff;
842 digest
[ 5] = (l
>> 0) & 0xff;
844 l
= itoa64_to_int (buf
[20]) << 0;
845 l
|= itoa64_to_int (buf
[21]) << 6;
847 digest
[11] = (l
>> 0) & 0xff;
850 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
854 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
856 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
857 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
858 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
859 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
861 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
863 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
864 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
865 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
866 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
868 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
870 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
871 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
872 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
873 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
875 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
877 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
879 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
880 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
882 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
884 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
886 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
887 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
889 l
= (digest
[11] << 0);
891 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
895 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
899 l
= itoa64_to_int (buf
[ 0]) << 0;
900 l
|= itoa64_to_int (buf
[ 1]) << 6;
901 l
|= itoa64_to_int (buf
[ 2]) << 12;
902 l
|= itoa64_to_int (buf
[ 3]) << 18;
904 digest
[ 0] = (l
>> 16) & 0xff;
905 digest
[21] = (l
>> 8) & 0xff;
906 digest
[42] = (l
>> 0) & 0xff;
908 l
= itoa64_to_int (buf
[ 4]) << 0;
909 l
|= itoa64_to_int (buf
[ 5]) << 6;
910 l
|= itoa64_to_int (buf
[ 6]) << 12;
911 l
|= itoa64_to_int (buf
[ 7]) << 18;
913 digest
[22] = (l
>> 16) & 0xff;
914 digest
[43] = (l
>> 8) & 0xff;
915 digest
[ 1] = (l
>> 0) & 0xff;
917 l
= itoa64_to_int (buf
[ 8]) << 0;
918 l
|= itoa64_to_int (buf
[ 9]) << 6;
919 l
|= itoa64_to_int (buf
[10]) << 12;
920 l
|= itoa64_to_int (buf
[11]) << 18;
922 digest
[44] = (l
>> 16) & 0xff;
923 digest
[ 2] = (l
>> 8) & 0xff;
924 digest
[23] = (l
>> 0) & 0xff;
926 l
= itoa64_to_int (buf
[12]) << 0;
927 l
|= itoa64_to_int (buf
[13]) << 6;
928 l
|= itoa64_to_int (buf
[14]) << 12;
929 l
|= itoa64_to_int (buf
[15]) << 18;
931 digest
[ 3] = (l
>> 16) & 0xff;
932 digest
[24] = (l
>> 8) & 0xff;
933 digest
[45] = (l
>> 0) & 0xff;
935 l
= itoa64_to_int (buf
[16]) << 0;
936 l
|= itoa64_to_int (buf
[17]) << 6;
937 l
|= itoa64_to_int (buf
[18]) << 12;
938 l
|= itoa64_to_int (buf
[19]) << 18;
940 digest
[25] = (l
>> 16) & 0xff;
941 digest
[46] = (l
>> 8) & 0xff;
942 digest
[ 4] = (l
>> 0) & 0xff;
944 l
= itoa64_to_int (buf
[20]) << 0;
945 l
|= itoa64_to_int (buf
[21]) << 6;
946 l
|= itoa64_to_int (buf
[22]) << 12;
947 l
|= itoa64_to_int (buf
[23]) << 18;
949 digest
[47] = (l
>> 16) & 0xff;
950 digest
[ 5] = (l
>> 8) & 0xff;
951 digest
[26] = (l
>> 0) & 0xff;
953 l
= itoa64_to_int (buf
[24]) << 0;
954 l
|= itoa64_to_int (buf
[25]) << 6;
955 l
|= itoa64_to_int (buf
[26]) << 12;
956 l
|= itoa64_to_int (buf
[27]) << 18;
958 digest
[ 6] = (l
>> 16) & 0xff;
959 digest
[27] = (l
>> 8) & 0xff;
960 digest
[48] = (l
>> 0) & 0xff;
962 l
= itoa64_to_int (buf
[28]) << 0;
963 l
|= itoa64_to_int (buf
[29]) << 6;
964 l
|= itoa64_to_int (buf
[30]) << 12;
965 l
|= itoa64_to_int (buf
[31]) << 18;
967 digest
[28] = (l
>> 16) & 0xff;
968 digest
[49] = (l
>> 8) & 0xff;
969 digest
[ 7] = (l
>> 0) & 0xff;
971 l
= itoa64_to_int (buf
[32]) << 0;
972 l
|= itoa64_to_int (buf
[33]) << 6;
973 l
|= itoa64_to_int (buf
[34]) << 12;
974 l
|= itoa64_to_int (buf
[35]) << 18;
976 digest
[50] = (l
>> 16) & 0xff;
977 digest
[ 8] = (l
>> 8) & 0xff;
978 digest
[29] = (l
>> 0) & 0xff;
980 l
= itoa64_to_int (buf
[36]) << 0;
981 l
|= itoa64_to_int (buf
[37]) << 6;
982 l
|= itoa64_to_int (buf
[38]) << 12;
983 l
|= itoa64_to_int (buf
[39]) << 18;
985 digest
[ 9] = (l
>> 16) & 0xff;
986 digest
[30] = (l
>> 8) & 0xff;
987 digest
[51] = (l
>> 0) & 0xff;
989 l
= itoa64_to_int (buf
[40]) << 0;
990 l
|= itoa64_to_int (buf
[41]) << 6;
991 l
|= itoa64_to_int (buf
[42]) << 12;
992 l
|= itoa64_to_int (buf
[43]) << 18;
994 digest
[31] = (l
>> 16) & 0xff;
995 digest
[52] = (l
>> 8) & 0xff;
996 digest
[10] = (l
>> 0) & 0xff;
998 l
= itoa64_to_int (buf
[44]) << 0;
999 l
|= itoa64_to_int (buf
[45]) << 6;
1000 l
|= itoa64_to_int (buf
[46]) << 12;
1001 l
|= itoa64_to_int (buf
[47]) << 18;
1003 digest
[53] = (l
>> 16) & 0xff;
1004 digest
[11] = (l
>> 8) & 0xff;
1005 digest
[32] = (l
>> 0) & 0xff;
1007 l
= itoa64_to_int (buf
[48]) << 0;
1008 l
|= itoa64_to_int (buf
[49]) << 6;
1009 l
|= itoa64_to_int (buf
[50]) << 12;
1010 l
|= itoa64_to_int (buf
[51]) << 18;
1012 digest
[12] = (l
>> 16) & 0xff;
1013 digest
[33] = (l
>> 8) & 0xff;
1014 digest
[54] = (l
>> 0) & 0xff;
1016 l
= itoa64_to_int (buf
[52]) << 0;
1017 l
|= itoa64_to_int (buf
[53]) << 6;
1018 l
|= itoa64_to_int (buf
[54]) << 12;
1019 l
|= itoa64_to_int (buf
[55]) << 18;
1021 digest
[34] = (l
>> 16) & 0xff;
1022 digest
[55] = (l
>> 8) & 0xff;
1023 digest
[13] = (l
>> 0) & 0xff;
1025 l
= itoa64_to_int (buf
[56]) << 0;
1026 l
|= itoa64_to_int (buf
[57]) << 6;
1027 l
|= itoa64_to_int (buf
[58]) << 12;
1028 l
|= itoa64_to_int (buf
[59]) << 18;
1030 digest
[56] = (l
>> 16) & 0xff;
1031 digest
[14] = (l
>> 8) & 0xff;
1032 digest
[35] = (l
>> 0) & 0xff;
1034 l
= itoa64_to_int (buf
[60]) << 0;
1035 l
|= itoa64_to_int (buf
[61]) << 6;
1036 l
|= itoa64_to_int (buf
[62]) << 12;
1037 l
|= itoa64_to_int (buf
[63]) << 18;
1039 digest
[15] = (l
>> 16) & 0xff;
1040 digest
[36] = (l
>> 8) & 0xff;
1041 digest
[57] = (l
>> 0) & 0xff;
1043 l
= itoa64_to_int (buf
[64]) << 0;
1044 l
|= itoa64_to_int (buf
[65]) << 6;
1045 l
|= itoa64_to_int (buf
[66]) << 12;
1046 l
|= itoa64_to_int (buf
[67]) << 18;
1048 digest
[37] = (l
>> 16) & 0xff;
1049 digest
[58] = (l
>> 8) & 0xff;
1050 digest
[16] = (l
>> 0) & 0xff;
1052 l
= itoa64_to_int (buf
[68]) << 0;
1053 l
|= itoa64_to_int (buf
[69]) << 6;
1054 l
|= itoa64_to_int (buf
[70]) << 12;
1055 l
|= itoa64_to_int (buf
[71]) << 18;
1057 digest
[59] = (l
>> 16) & 0xff;
1058 digest
[17] = (l
>> 8) & 0xff;
1059 digest
[38] = (l
>> 0) & 0xff;
1061 l
= itoa64_to_int (buf
[72]) << 0;
1062 l
|= itoa64_to_int (buf
[73]) << 6;
1063 l
|= itoa64_to_int (buf
[74]) << 12;
1064 l
|= itoa64_to_int (buf
[75]) << 18;
1066 digest
[18] = (l
>> 16) & 0xff;
1067 digest
[39] = (l
>> 8) & 0xff;
1068 digest
[60] = (l
>> 0) & 0xff;
1070 l
= itoa64_to_int (buf
[76]) << 0;
1071 l
|= itoa64_to_int (buf
[77]) << 6;
1072 l
|= itoa64_to_int (buf
[78]) << 12;
1073 l
|= itoa64_to_int (buf
[79]) << 18;
1075 digest
[40] = (l
>> 16) & 0xff;
1076 digest
[61] = (l
>> 8) & 0xff;
1077 digest
[19] = (l
>> 0) & 0xff;
1079 l
= itoa64_to_int (buf
[80]) << 0;
1080 l
|= itoa64_to_int (buf
[81]) << 6;
1081 l
|= itoa64_to_int (buf
[82]) << 12;
1082 l
|= itoa64_to_int (buf
[83]) << 18;
1084 digest
[62] = (l
>> 16) & 0xff;
1085 digest
[20] = (l
>> 8) & 0xff;
1086 digest
[41] = (l
>> 0) & 0xff;
1088 l
= itoa64_to_int (buf
[84]) << 0;
1089 l
|= itoa64_to_int (buf
[85]) << 6;
1091 digest
[63] = (l
>> 0) & 0xff;
1094 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1098 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1100 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1101 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1102 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1103 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1105 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1107 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1108 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1109 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1110 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1112 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1114 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1115 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1116 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1117 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1119 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1121 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1123 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1124 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1126 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1128 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1130 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1131 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1133 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1135 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1137 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1138 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1140 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1142 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1144 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1145 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1147 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1149 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1151 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1152 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1154 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1156 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1158 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1159 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1161 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1163 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1165 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1166 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1168 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1170 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1172 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1173 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1175 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1177 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1179 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1180 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1182 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1184 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1186 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1187 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1189 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1191 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1193 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1194 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1196 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1198 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1200 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1201 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1203 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1205 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1207 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1208 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1210 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1212 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1214 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1215 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1217 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1219 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1221 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1222 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1224 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1226 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1228 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1229 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1231 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1233 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1235 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1236 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1238 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1240 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1242 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1243 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1245 l
= 0 | 0 | (digest
[63] << 0);
1247 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1251 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1255 l
= itoa64_to_int (buf
[ 0]) << 0;
1256 l
|= itoa64_to_int (buf
[ 1]) << 6;
1257 l
|= itoa64_to_int (buf
[ 2]) << 12;
1258 l
|= itoa64_to_int (buf
[ 3]) << 18;
1260 digest
[ 2] = (l
>> 0) & 0xff;
1261 digest
[ 1] = (l
>> 8) & 0xff;
1262 digest
[ 0] = (l
>> 16) & 0xff;
1264 l
= itoa64_to_int (buf
[ 4]) << 0;
1265 l
|= itoa64_to_int (buf
[ 5]) << 6;
1266 l
|= itoa64_to_int (buf
[ 6]) << 12;
1267 l
|= itoa64_to_int (buf
[ 7]) << 18;
1269 digest
[ 5] = (l
>> 0) & 0xff;
1270 digest
[ 4] = (l
>> 8) & 0xff;
1271 digest
[ 3] = (l
>> 16) & 0xff;
1273 l
= itoa64_to_int (buf
[ 8]) << 0;
1274 l
|= itoa64_to_int (buf
[ 9]) << 6;
1275 l
|= itoa64_to_int (buf
[10]) << 12;
1276 l
|= itoa64_to_int (buf
[11]) << 18;
1278 digest
[ 8] = (l
>> 0) & 0xff;
1279 digest
[ 7] = (l
>> 8) & 0xff;
1280 digest
[ 6] = (l
>> 16) & 0xff;
1282 l
= itoa64_to_int (buf
[12]) << 0;
1283 l
|= itoa64_to_int (buf
[13]) << 6;
1284 l
|= itoa64_to_int (buf
[14]) << 12;
1285 l
|= itoa64_to_int (buf
[15]) << 18;
1287 digest
[11] = (l
>> 0) & 0xff;
1288 digest
[10] = (l
>> 8) & 0xff;
1289 digest
[ 9] = (l
>> 16) & 0xff;
1291 l
= itoa64_to_int (buf
[16]) << 0;
1292 l
|= itoa64_to_int (buf
[17]) << 6;
1293 l
|= itoa64_to_int (buf
[18]) << 12;
1294 l
|= itoa64_to_int (buf
[19]) << 18;
1296 digest
[14] = (l
>> 0) & 0xff;
1297 digest
[13] = (l
>> 8) & 0xff;
1298 digest
[12] = (l
>> 16) & 0xff;
1300 l
= itoa64_to_int (buf
[20]) << 0;
1301 l
|= itoa64_to_int (buf
[21]) << 6;
1302 l
|= itoa64_to_int (buf
[22]) << 12;
1303 l
|= itoa64_to_int (buf
[23]) << 18;
1305 digest
[17] = (l
>> 0) & 0xff;
1306 digest
[16] = (l
>> 8) & 0xff;
1307 digest
[15] = (l
>> 16) & 0xff;
1309 l
= itoa64_to_int (buf
[24]) << 0;
1310 l
|= itoa64_to_int (buf
[25]) << 6;
1311 l
|= itoa64_to_int (buf
[26]) << 12;
1313 digest
[19] = (l
>> 8) & 0xff;
1314 digest
[18] = (l
>> 16) & 0xff;
1317 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1321 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1323 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1324 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1325 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1326 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1328 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1330 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1331 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1332 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1333 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1335 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1337 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1338 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1339 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1340 buf
[11] = int_to_itoa64 (l
& 0x3f);
1342 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1344 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1345 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1346 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1347 buf
[15] = int_to_itoa64 (l
& 0x3f);
1349 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1351 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1352 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1353 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1354 buf
[19] = int_to_itoa64 (l
& 0x3f);
1356 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1358 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1359 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1360 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1361 buf
[23] = int_to_itoa64 (l
& 0x3f);
1363 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1365 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1366 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1367 buf
[26] = int_to_itoa64 (l
& 0x3f);
1370 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1374 l
= itoa64_to_int (buf
[ 0]) << 0;
1375 l
|= itoa64_to_int (buf
[ 1]) << 6;
1376 l
|= itoa64_to_int (buf
[ 2]) << 12;
1377 l
|= itoa64_to_int (buf
[ 3]) << 18;
1379 digest
[ 2] = (l
>> 0) & 0xff;
1380 digest
[ 1] = (l
>> 8) & 0xff;
1381 digest
[ 0] = (l
>> 16) & 0xff;
1383 l
= itoa64_to_int (buf
[ 4]) << 0;
1384 l
|= itoa64_to_int (buf
[ 5]) << 6;
1385 l
|= itoa64_to_int (buf
[ 6]) << 12;
1386 l
|= itoa64_to_int (buf
[ 7]) << 18;
1388 digest
[ 5] = (l
>> 0) & 0xff;
1389 digest
[ 4] = (l
>> 8) & 0xff;
1390 digest
[ 3] = (l
>> 16) & 0xff;
1392 l
= itoa64_to_int (buf
[ 8]) << 0;
1393 l
|= itoa64_to_int (buf
[ 9]) << 6;
1394 l
|= itoa64_to_int (buf
[10]) << 12;
1395 l
|= itoa64_to_int (buf
[11]) << 18;
1397 digest
[ 8] = (l
>> 0) & 0xff;
1398 digest
[ 7] = (l
>> 8) & 0xff;
1399 digest
[ 6] = (l
>> 16) & 0xff;
1401 l
= itoa64_to_int (buf
[12]) << 0;
1402 l
|= itoa64_to_int (buf
[13]) << 6;
1403 l
|= itoa64_to_int (buf
[14]) << 12;
1404 l
|= itoa64_to_int (buf
[15]) << 18;
1406 digest
[11] = (l
>> 0) & 0xff;
1407 digest
[10] = (l
>> 8) & 0xff;
1408 digest
[ 9] = (l
>> 16) & 0xff;
1410 l
= itoa64_to_int (buf
[16]) << 0;
1411 l
|= itoa64_to_int (buf
[17]) << 6;
1412 l
|= itoa64_to_int (buf
[18]) << 12;
1413 l
|= itoa64_to_int (buf
[19]) << 18;
1415 digest
[14] = (l
>> 0) & 0xff;
1416 digest
[13] = (l
>> 8) & 0xff;
1417 digest
[12] = (l
>> 16) & 0xff;
1419 l
= itoa64_to_int (buf
[20]) << 0;
1420 l
|= itoa64_to_int (buf
[21]) << 6;
1421 l
|= itoa64_to_int (buf
[22]) << 12;
1422 l
|= itoa64_to_int (buf
[23]) << 18;
1424 digest
[17] = (l
>> 0) & 0xff;
1425 digest
[16] = (l
>> 8) & 0xff;
1426 digest
[15] = (l
>> 16) & 0xff;
1428 l
= itoa64_to_int (buf
[24]) << 0;
1429 l
|= itoa64_to_int (buf
[25]) << 6;
1430 l
|= itoa64_to_int (buf
[26]) << 12;
1431 l
|= itoa64_to_int (buf
[27]) << 18;
1433 digest
[20] = (l
>> 0) & 0xff;
1434 digest
[19] = (l
>> 8) & 0xff;
1435 digest
[18] = (l
>> 16) & 0xff;
1437 l
= itoa64_to_int (buf
[28]) << 0;
1438 l
|= itoa64_to_int (buf
[29]) << 6;
1439 l
|= itoa64_to_int (buf
[30]) << 12;
1440 l
|= itoa64_to_int (buf
[31]) << 18;
1442 digest
[23] = (l
>> 0) & 0xff;
1443 digest
[22] = (l
>> 8) & 0xff;
1444 digest
[21] = (l
>> 16) & 0xff;
1446 l
= itoa64_to_int (buf
[32]) << 0;
1447 l
|= itoa64_to_int (buf
[33]) << 6;
1448 l
|= itoa64_to_int (buf
[34]) << 12;
1449 l
|= itoa64_to_int (buf
[35]) << 18;
1451 digest
[26] = (l
>> 0) & 0xff;
1452 digest
[25] = (l
>> 8) & 0xff;
1453 digest
[24] = (l
>> 16) & 0xff;
1455 l
= itoa64_to_int (buf
[36]) << 0;
1456 l
|= itoa64_to_int (buf
[37]) << 6;
1457 l
|= itoa64_to_int (buf
[38]) << 12;
1458 l
|= itoa64_to_int (buf
[39]) << 18;
1460 digest
[29] = (l
>> 0) & 0xff;
1461 digest
[28] = (l
>> 8) & 0xff;
1462 digest
[27] = (l
>> 16) & 0xff;
1464 l
= itoa64_to_int (buf
[40]) << 0;
1465 l
|= itoa64_to_int (buf
[41]) << 6;
1466 l
|= itoa64_to_int (buf
[42]) << 12;
1468 //digest[32] = (l >> 0) & 0xff;
1469 digest
[31] = (l
>> 8) & 0xff;
1470 digest
[30] = (l
>> 16) & 0xff;
1473 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1477 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1479 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1480 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1481 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1482 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1484 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1486 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1487 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1488 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1489 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1491 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1493 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1494 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1495 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1496 buf
[11] = int_to_itoa64 (l
& 0x3f);
1498 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1500 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1501 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1502 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1503 buf
[15] = int_to_itoa64 (l
& 0x3f);
1505 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1507 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1508 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1509 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1510 buf
[19] = int_to_itoa64 (l
& 0x3f);
1512 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1514 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1515 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1516 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1517 buf
[23] = int_to_itoa64 (l
& 0x3f);
1519 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1521 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1522 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1523 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1524 buf
[27] = int_to_itoa64 (l
& 0x3f);
1526 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1528 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1529 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1530 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1531 buf
[31] = int_to_itoa64 (l
& 0x3f);
1533 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1535 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1536 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1537 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1538 buf
[35] = int_to_itoa64 (l
& 0x3f);
1540 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1542 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1543 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1544 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1545 buf
[39] = int_to_itoa64 (l
& 0x3f);
1547 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1549 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1550 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1551 buf
[42] = int_to_itoa64 (l
& 0x3f);
1554 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1558 l
= itoa64_to_int (buf
[ 0]) << 0;
1559 l
|= itoa64_to_int (buf
[ 1]) << 6;
1560 l
|= itoa64_to_int (buf
[ 2]) << 12;
1561 l
|= itoa64_to_int (buf
[ 3]) << 18;
1563 digest
[ 2] = (l
>> 0) & 0xff;
1564 digest
[ 1] = (l
>> 8) & 0xff;
1565 digest
[ 0] = (l
>> 16) & 0xff;
1567 l
= itoa64_to_int (buf
[ 4]) << 0;
1568 l
|= itoa64_to_int (buf
[ 5]) << 6;
1569 l
|= itoa64_to_int (buf
[ 6]) << 12;
1570 l
|= itoa64_to_int (buf
[ 7]) << 18;
1572 digest
[ 5] = (l
>> 0) & 0xff;
1573 digest
[ 4] = (l
>> 8) & 0xff;
1574 digest
[ 3] = (l
>> 16) & 0xff;
1576 l
= itoa64_to_int (buf
[ 8]) << 0;
1577 l
|= itoa64_to_int (buf
[ 9]) << 6;
1578 l
|= itoa64_to_int (buf
[10]) << 12;
1579 l
|= itoa64_to_int (buf
[11]) << 18;
1581 digest
[ 8] = (l
>> 0) & 0xff;
1582 digest
[ 7] = (l
>> 8) & 0xff;
1583 digest
[ 6] = (l
>> 16) & 0xff;
1585 l
= itoa64_to_int (buf
[12]) << 0;
1586 l
|= itoa64_to_int (buf
[13]) << 6;
1587 l
|= itoa64_to_int (buf
[14]) << 12;
1588 l
|= itoa64_to_int (buf
[15]) << 18;
1590 digest
[11] = (l
>> 0) & 0xff;
1591 digest
[10] = (l
>> 8) & 0xff;
1592 digest
[ 9] = (l
>> 16) & 0xff;
1594 l
= itoa64_to_int (buf
[16]) << 0;
1595 l
|= itoa64_to_int (buf
[17]) << 6;
1596 l
|= itoa64_to_int (buf
[18]) << 12;
1597 l
|= itoa64_to_int (buf
[19]) << 18;
1599 digest
[14] = (l
>> 0) & 0xff;
1600 digest
[13] = (l
>> 8) & 0xff;
1601 digest
[12] = (l
>> 16) & 0xff;
1603 l
= itoa64_to_int (buf
[20]) << 0;
1604 l
|= itoa64_to_int (buf
[21]) << 6;
1605 l
|= itoa64_to_int (buf
[22]) << 12;
1606 l
|= itoa64_to_int (buf
[23]) << 18;
1608 digest
[17] = (l
>> 0) & 0xff;
1609 digest
[16] = (l
>> 8) & 0xff;
1610 digest
[15] = (l
>> 16) & 0xff;
1612 l
= itoa64_to_int (buf
[24]) << 0;
1613 l
|= itoa64_to_int (buf
[25]) << 6;
1614 l
|= itoa64_to_int (buf
[26]) << 12;
1615 l
|= itoa64_to_int (buf
[27]) << 18;
1617 digest
[20] = (l
>> 0) & 0xff;
1618 digest
[19] = (l
>> 8) & 0xff;
1619 digest
[18] = (l
>> 16) & 0xff;
1621 l
= itoa64_to_int (buf
[28]) << 0;
1622 l
|= itoa64_to_int (buf
[29]) << 6;
1623 l
|= itoa64_to_int (buf
[30]) << 12;
1624 l
|= itoa64_to_int (buf
[31]) << 18;
1626 digest
[23] = (l
>> 0) & 0xff;
1627 digest
[22] = (l
>> 8) & 0xff;
1628 digest
[21] = (l
>> 16) & 0xff;
1630 l
= itoa64_to_int (buf
[32]) << 0;
1631 l
|= itoa64_to_int (buf
[33]) << 6;
1632 l
|= itoa64_to_int (buf
[34]) << 12;
1633 l
|= itoa64_to_int (buf
[35]) << 18;
1635 digest
[26] = (l
>> 0) & 0xff;
1636 digest
[25] = (l
>> 8) & 0xff;
1637 digest
[24] = (l
>> 16) & 0xff;
1639 l
= itoa64_to_int (buf
[36]) << 0;
1640 l
|= itoa64_to_int (buf
[37]) << 6;
1641 l
|= itoa64_to_int (buf
[38]) << 12;
1642 l
|= itoa64_to_int (buf
[39]) << 18;
1644 digest
[29] = (l
>> 0) & 0xff;
1645 digest
[28] = (l
>> 8) & 0xff;
1646 digest
[27] = (l
>> 16) & 0xff;
1648 l
= itoa64_to_int (buf
[40]) << 0;
1649 l
|= itoa64_to_int (buf
[41]) << 6;
1650 l
|= itoa64_to_int (buf
[42]) << 12;
1651 l
|= itoa64_to_int (buf
[43]) << 18;
1653 digest
[32] = (l
>> 0) & 0xff;
1654 digest
[31] = (l
>> 8) & 0xff;
1655 digest
[30] = (l
>> 16) & 0xff;
1657 l
= itoa64_to_int (buf
[44]) << 0;
1658 l
|= itoa64_to_int (buf
[45]) << 6;
1659 l
|= itoa64_to_int (buf
[46]) << 12;
1660 l
|= itoa64_to_int (buf
[47]) << 18;
1662 digest
[35] = (l
>> 0) & 0xff;
1663 digest
[34] = (l
>> 8) & 0xff;
1664 digest
[33] = (l
>> 16) & 0xff;
1666 l
= itoa64_to_int (buf
[48]) << 0;
1667 l
|= itoa64_to_int (buf
[49]) << 6;
1668 l
|= itoa64_to_int (buf
[50]) << 12;
1669 l
|= itoa64_to_int (buf
[51]) << 18;
1671 digest
[38] = (l
>> 0) & 0xff;
1672 digest
[37] = (l
>> 8) & 0xff;
1673 digest
[36] = (l
>> 16) & 0xff;
1675 l
= itoa64_to_int (buf
[52]) << 0;
1676 l
|= itoa64_to_int (buf
[53]) << 6;
1677 l
|= itoa64_to_int (buf
[54]) << 12;
1678 l
|= itoa64_to_int (buf
[55]) << 18;
1680 digest
[41] = (l
>> 0) & 0xff;
1681 digest
[40] = (l
>> 8) & 0xff;
1682 digest
[39] = (l
>> 16) & 0xff;
1684 l
= itoa64_to_int (buf
[56]) << 0;
1685 l
|= itoa64_to_int (buf
[57]) << 6;
1686 l
|= itoa64_to_int (buf
[58]) << 12;
1687 l
|= itoa64_to_int (buf
[59]) << 18;
1689 digest
[44] = (l
>> 0) & 0xff;
1690 digest
[43] = (l
>> 8) & 0xff;
1691 digest
[42] = (l
>> 16) & 0xff;
1693 l
= itoa64_to_int (buf
[60]) << 0;
1694 l
|= itoa64_to_int (buf
[61]) << 6;
1695 l
|= itoa64_to_int (buf
[62]) << 12;
1696 l
|= itoa64_to_int (buf
[63]) << 18;
1698 digest
[47] = (l
>> 0) & 0xff;
1699 digest
[46] = (l
>> 8) & 0xff;
1700 digest
[45] = (l
>> 16) & 0xff;
1702 l
= itoa64_to_int (buf
[64]) << 0;
1703 l
|= itoa64_to_int (buf
[65]) << 6;
1704 l
|= itoa64_to_int (buf
[66]) << 12;
1705 l
|= itoa64_to_int (buf
[67]) << 18;
1707 digest
[50] = (l
>> 0) & 0xff;
1708 digest
[49] = (l
>> 8) & 0xff;
1709 digest
[48] = (l
>> 16) & 0xff;
1711 l
= itoa64_to_int (buf
[68]) << 0;
1712 l
|= itoa64_to_int (buf
[69]) << 6;
1713 l
|= itoa64_to_int (buf
[70]) << 12;
1714 l
|= itoa64_to_int (buf
[71]) << 18;
1716 digest
[53] = (l
>> 0) & 0xff;
1717 digest
[52] = (l
>> 8) & 0xff;
1718 digest
[51] = (l
>> 16) & 0xff;
1720 l
= itoa64_to_int (buf
[72]) << 0;
1721 l
|= itoa64_to_int (buf
[73]) << 6;
1722 l
|= itoa64_to_int (buf
[74]) << 12;
1723 l
|= itoa64_to_int (buf
[75]) << 18;
1725 digest
[56] = (l
>> 0) & 0xff;
1726 digest
[55] = (l
>> 8) & 0xff;
1727 digest
[54] = (l
>> 16) & 0xff;
1729 l
= itoa64_to_int (buf
[76]) << 0;
1730 l
|= itoa64_to_int (buf
[77]) << 6;
1731 l
|= itoa64_to_int (buf
[78]) << 12;
1732 l
|= itoa64_to_int (buf
[79]) << 18;
1734 digest
[59] = (l
>> 0) & 0xff;
1735 digest
[58] = (l
>> 8) & 0xff;
1736 digest
[57] = (l
>> 16) & 0xff;
1738 l
= itoa64_to_int (buf
[80]) << 0;
1739 l
|= itoa64_to_int (buf
[81]) << 6;
1740 l
|= itoa64_to_int (buf
[82]) << 12;
1741 l
|= itoa64_to_int (buf
[83]) << 18;
1743 digest
[62] = (l
>> 0) & 0xff;
1744 digest
[61] = (l
>> 8) & 0xff;
1745 digest
[60] = (l
>> 16) & 0xff;
1747 l
= itoa64_to_int (buf
[84]) << 0;
1748 l
|= itoa64_to_int (buf
[85]) << 6;
1750 digest
[63] = (l
>> 16) & 0xff;
1753 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1757 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1759 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1760 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1761 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1762 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1764 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1766 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1767 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1768 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1769 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1771 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1773 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1774 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1775 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1776 buf
[11] = int_to_itoa64 (l
& 0x3f);
1778 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1780 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1781 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1782 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1783 buf
[15] = int_to_itoa64 (l
& 0x3f);
1785 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1787 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1788 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1789 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1790 buf
[19] = int_to_itoa64 (l
& 0x3f);
1792 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1794 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1795 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1796 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1797 buf
[23] = int_to_itoa64 (l
& 0x3f);
1799 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1801 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1802 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1803 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1804 buf
[27] = int_to_itoa64 (l
& 0x3f);
1806 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1808 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1809 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1810 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1811 buf
[31] = int_to_itoa64 (l
& 0x3f);
1813 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1815 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1816 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1817 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1818 buf
[35] = int_to_itoa64 (l
& 0x3f);
1820 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1822 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1823 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1824 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1825 buf
[39] = int_to_itoa64 (l
& 0x3f);
1827 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1829 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1830 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1831 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1832 buf
[43] = int_to_itoa64 (l
& 0x3f);
1834 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1836 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1837 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1838 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1839 buf
[47] = int_to_itoa64 (l
& 0x3f);
1841 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1843 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1844 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1845 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1846 buf
[51] = int_to_itoa64 (l
& 0x3f);
1848 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1850 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1851 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1852 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1853 buf
[55] = int_to_itoa64 (l
& 0x3f);
1855 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1857 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1858 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1859 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1860 buf
[59] = int_to_itoa64 (l
& 0x3f);
1862 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1864 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1865 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1866 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1867 buf
[63] = int_to_itoa64 (l
& 0x3f);
1869 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1871 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1872 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1873 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1874 buf
[67] = int_to_itoa64 (l
& 0x3f);
1876 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1878 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1879 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1880 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1881 buf
[71] = int_to_itoa64 (l
& 0x3f);
1883 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1885 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1886 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1887 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1888 buf
[75] = int_to_itoa64 (l
& 0x3f);
1890 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1892 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1893 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1894 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1895 buf
[79] = int_to_itoa64 (l
& 0x3f);
1897 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1899 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1900 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1901 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1902 buf
[83] = int_to_itoa64 (l
& 0x3f);
1904 l
= 0 | 0 | (digest
[63] << 16);
1906 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1907 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1910 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1914 l
= itoa64_to_int (buf
[ 0]) << 0;
1915 l
|= itoa64_to_int (buf
[ 1]) << 6;
1916 l
|= itoa64_to_int (buf
[ 2]) << 12;
1917 l
|= itoa64_to_int (buf
[ 3]) << 18;
1919 digest
[ 0] = (l
>> 16) & 0xff;
1920 digest
[10] = (l
>> 8) & 0xff;
1921 digest
[20] = (l
>> 0) & 0xff;
1923 l
= itoa64_to_int (buf
[ 4]) << 0;
1924 l
|= itoa64_to_int (buf
[ 5]) << 6;
1925 l
|= itoa64_to_int (buf
[ 6]) << 12;
1926 l
|= itoa64_to_int (buf
[ 7]) << 18;
1928 digest
[21] = (l
>> 16) & 0xff;
1929 digest
[ 1] = (l
>> 8) & 0xff;
1930 digest
[11] = (l
>> 0) & 0xff;
1932 l
= itoa64_to_int (buf
[ 8]) << 0;
1933 l
|= itoa64_to_int (buf
[ 9]) << 6;
1934 l
|= itoa64_to_int (buf
[10]) << 12;
1935 l
|= itoa64_to_int (buf
[11]) << 18;
1937 digest
[12] = (l
>> 16) & 0xff;
1938 digest
[22] = (l
>> 8) & 0xff;
1939 digest
[ 2] = (l
>> 0) & 0xff;
1941 l
= itoa64_to_int (buf
[12]) << 0;
1942 l
|= itoa64_to_int (buf
[13]) << 6;
1943 l
|= itoa64_to_int (buf
[14]) << 12;
1944 l
|= itoa64_to_int (buf
[15]) << 18;
1946 digest
[ 3] = (l
>> 16) & 0xff;
1947 digest
[13] = (l
>> 8) & 0xff;
1948 digest
[23] = (l
>> 0) & 0xff;
1950 l
= itoa64_to_int (buf
[16]) << 0;
1951 l
|= itoa64_to_int (buf
[17]) << 6;
1952 l
|= itoa64_to_int (buf
[18]) << 12;
1953 l
|= itoa64_to_int (buf
[19]) << 18;
1955 digest
[24] = (l
>> 16) & 0xff;
1956 digest
[ 4] = (l
>> 8) & 0xff;
1957 digest
[14] = (l
>> 0) & 0xff;
1959 l
= itoa64_to_int (buf
[20]) << 0;
1960 l
|= itoa64_to_int (buf
[21]) << 6;
1961 l
|= itoa64_to_int (buf
[22]) << 12;
1962 l
|= itoa64_to_int (buf
[23]) << 18;
1964 digest
[15] = (l
>> 16) & 0xff;
1965 digest
[25] = (l
>> 8) & 0xff;
1966 digest
[ 5] = (l
>> 0) & 0xff;
1968 l
= itoa64_to_int (buf
[24]) << 0;
1969 l
|= itoa64_to_int (buf
[25]) << 6;
1970 l
|= itoa64_to_int (buf
[26]) << 12;
1971 l
|= itoa64_to_int (buf
[27]) << 18;
1973 digest
[ 6] = (l
>> 16) & 0xff;
1974 digest
[16] = (l
>> 8) & 0xff;
1975 digest
[26] = (l
>> 0) & 0xff;
1977 l
= itoa64_to_int (buf
[28]) << 0;
1978 l
|= itoa64_to_int (buf
[29]) << 6;
1979 l
|= itoa64_to_int (buf
[30]) << 12;
1980 l
|= itoa64_to_int (buf
[31]) << 18;
1982 digest
[27] = (l
>> 16) & 0xff;
1983 digest
[ 7] = (l
>> 8) & 0xff;
1984 digest
[17] = (l
>> 0) & 0xff;
1986 l
= itoa64_to_int (buf
[32]) << 0;
1987 l
|= itoa64_to_int (buf
[33]) << 6;
1988 l
|= itoa64_to_int (buf
[34]) << 12;
1989 l
|= itoa64_to_int (buf
[35]) << 18;
1991 digest
[18] = (l
>> 16) & 0xff;
1992 digest
[28] = (l
>> 8) & 0xff;
1993 digest
[ 8] = (l
>> 0) & 0xff;
1995 l
= itoa64_to_int (buf
[36]) << 0;
1996 l
|= itoa64_to_int (buf
[37]) << 6;
1997 l
|= itoa64_to_int (buf
[38]) << 12;
1998 l
|= itoa64_to_int (buf
[39]) << 18;
2000 digest
[ 9] = (l
>> 16) & 0xff;
2001 digest
[19] = (l
>> 8) & 0xff;
2002 digest
[29] = (l
>> 0) & 0xff;
2004 l
= itoa64_to_int (buf
[40]) << 0;
2005 l
|= itoa64_to_int (buf
[41]) << 6;
2006 l
|= itoa64_to_int (buf
[42]) << 12;
2008 digest
[31] = (l
>> 8) & 0xff;
2009 digest
[30] = (l
>> 0) & 0xff;
2012 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2016 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2018 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2019 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2020 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2021 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2023 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2025 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2026 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2027 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2028 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2030 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2032 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2033 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2034 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2035 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2037 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2039 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2041 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2042 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2044 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2046 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2048 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2049 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2051 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2053 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2055 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2056 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2058 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2060 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2062 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2063 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2065 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2067 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2069 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2070 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2072 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2074 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2076 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2077 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2079 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2081 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2083 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2084 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2086 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2088 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2090 buf
[42] = int_to_itoa64 (l
& 0x3f);
2093 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2097 l
= itoa64_to_int (buf
[ 0]) << 0;
2098 l
|= itoa64_to_int (buf
[ 1]) << 6;
2099 l
|= itoa64_to_int (buf
[ 2]) << 12;
2100 l
|= itoa64_to_int (buf
[ 3]) << 18;
2102 digest
[ 0] = (l
>> 0) & 0xff;
2103 digest
[ 1] = (l
>> 8) & 0xff;
2104 digest
[ 2] = (l
>> 16) & 0xff;
2106 l
= itoa64_to_int (buf
[ 4]) << 0;
2107 l
|= itoa64_to_int (buf
[ 5]) << 6;
2108 l
|= itoa64_to_int (buf
[ 6]) << 12;
2109 l
|= itoa64_to_int (buf
[ 7]) << 18;
2111 digest
[ 3] = (l
>> 0) & 0xff;
2112 digest
[ 4] = (l
>> 8) & 0xff;
2113 digest
[ 5] = (l
>> 16) & 0xff;
2115 l
= itoa64_to_int (buf
[ 8]) << 0;
2116 l
|= itoa64_to_int (buf
[ 9]) << 6;
2117 l
|= itoa64_to_int (buf
[10]) << 12;
2118 l
|= itoa64_to_int (buf
[11]) << 18;
2120 digest
[ 6] = (l
>> 0) & 0xff;
2121 digest
[ 7] = (l
>> 8) & 0xff;
2122 digest
[ 8] = (l
>> 16) & 0xff;
2124 l
= itoa64_to_int (buf
[12]) << 0;
2125 l
|= itoa64_to_int (buf
[13]) << 6;
2126 l
|= itoa64_to_int (buf
[14]) << 12;
2127 l
|= itoa64_to_int (buf
[15]) << 18;
2129 digest
[ 9] = (l
>> 0) & 0xff;
2130 digest
[10] = (l
>> 8) & 0xff;
2131 digest
[11] = (l
>> 16) & 0xff;
2133 l
= itoa64_to_int (buf
[16]) << 0;
2134 l
|= itoa64_to_int (buf
[17]) << 6;
2135 l
|= itoa64_to_int (buf
[18]) << 12;
2136 l
|= itoa64_to_int (buf
[19]) << 18;
2138 digest
[12] = (l
>> 0) & 0xff;
2139 digest
[13] = (l
>> 8) & 0xff;
2140 digest
[14] = (l
>> 16) & 0xff;
2142 l
= itoa64_to_int (buf
[20]) << 0;
2143 l
|= itoa64_to_int (buf
[21]) << 6;
2144 l
|= itoa64_to_int (buf
[22]) << 12;
2145 l
|= itoa64_to_int (buf
[23]) << 18;
2147 digest
[15] = (l
>> 0) & 0xff;
2148 digest
[16] = (l
>> 8) & 0xff;
2149 digest
[17] = (l
>> 16) & 0xff;
2151 l
= itoa64_to_int (buf
[24]) << 0;
2152 l
|= itoa64_to_int (buf
[25]) << 6;
2153 l
|= itoa64_to_int (buf
[26]) << 12;
2154 l
|= itoa64_to_int (buf
[27]) << 18;
2156 digest
[18] = (l
>> 0) & 0xff;
2157 digest
[19] = (l
>> 8) & 0xff;
2158 digest
[20] = (l
>> 16) & 0xff;
2160 l
= itoa64_to_int (buf
[28]) << 0;
2161 l
|= itoa64_to_int (buf
[29]) << 6;
2162 l
|= itoa64_to_int (buf
[30]) << 12;
2163 l
|= itoa64_to_int (buf
[31]) << 18;
2165 digest
[21] = (l
>> 0) & 0xff;
2166 digest
[22] = (l
>> 8) & 0xff;
2167 digest
[23] = (l
>> 16) & 0xff;
2169 l
= itoa64_to_int (buf
[32]) << 0;
2170 l
|= itoa64_to_int (buf
[33]) << 6;
2171 l
|= itoa64_to_int (buf
[34]) << 12;
2172 l
|= itoa64_to_int (buf
[35]) << 18;
2174 digest
[24] = (l
>> 0) & 0xff;
2175 digest
[25] = (l
>> 8) & 0xff;
2176 digest
[26] = (l
>> 16) & 0xff;
2178 l
= itoa64_to_int (buf
[36]) << 0;
2179 l
|= itoa64_to_int (buf
[37]) << 6;
2180 l
|= itoa64_to_int (buf
[38]) << 12;
2181 l
|= itoa64_to_int (buf
[39]) << 18;
2183 digest
[27] = (l
>> 0) & 0xff;
2184 digest
[28] = (l
>> 8) & 0xff;
2185 digest
[29] = (l
>> 16) & 0xff;
2187 l
= itoa64_to_int (buf
[40]) << 0;
2188 l
|= itoa64_to_int (buf
[41]) << 6;
2189 l
|= itoa64_to_int (buf
[42]) << 12;
2190 l
|= itoa64_to_int (buf
[43]) << 18;
2192 digest
[30] = (l
>> 0) & 0xff;
2193 digest
[31] = (l
>> 8) & 0xff;
2194 digest
[32] = (l
>> 16) & 0xff;
2229 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2233 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2235 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2236 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2237 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2238 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2240 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2242 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2243 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2244 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2245 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2247 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2249 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2250 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2251 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2252 buf
[11] = int_to_itoa64 (l
& 0x3f);
2254 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2256 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2257 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2258 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2259 buf
[15] = int_to_itoa64 (l
& 0x3f);
2261 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2263 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2264 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2265 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2266 buf
[19] = int_to_itoa64 (l
& 0x3f);
2268 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2270 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2271 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2272 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2273 buf
[23] = int_to_itoa64 (l
& 0x3f);
2275 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2277 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2278 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2279 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2280 buf
[27] = int_to_itoa64 (l
& 0x3f);
2282 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2284 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2285 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2286 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2287 buf
[31] = int_to_itoa64 (l
& 0x3f);
2289 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2291 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2292 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2293 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2294 buf
[35] = int_to_itoa64 (l
& 0x3f);
2296 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2298 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2299 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2300 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2301 buf
[39] = int_to_itoa64 (l
& 0x3f);
2303 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2305 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2306 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2307 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2308 //buf[43] = int_to_itoa64 (l & 0x3f);
2316 static struct termio savemodes
;
2317 static int havemodes
= 0;
2321 struct termio modmodes
;
2323 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2327 modmodes
= savemodes
;
2328 modmodes
.c_lflag
&= ~ICANON
;
2329 modmodes
.c_cc
[VMIN
] = 1;
2330 modmodes
.c_cc
[VTIME
] = 0;
2332 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2341 FD_SET (fileno (stdin
), &rfds
);
2348 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2350 if (retval
== 0) return 0;
2351 if (retval
== -1) return -1;
2358 if (!havemodes
) return 0;
2360 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2365 static struct termios savemodes
;
2366 static int havemodes
= 0;
2370 struct termios modmodes
;
2372 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2376 modmodes
= savemodes
;
2377 modmodes
.c_lflag
&= ~ICANON
;
2378 modmodes
.c_cc
[VMIN
] = 1;
2379 modmodes
.c_cc
[VTIME
] = 0;
2381 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2390 FD_SET (fileno (stdin
), &rfds
);
2397 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2399 if (retval
== 0) return 0;
2400 if (retval
== -1) return -1;
2407 if (!havemodes
) return 0;
2409 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2414 static DWORD saveMode
= 0;
2418 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2420 GetConsoleMode (stdinHandle
, &saveMode
);
2421 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2428 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2430 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2432 if (rc
== WAIT_TIMEOUT
) return 0;
2433 if (rc
== WAIT_ABANDONED
) return -1;
2434 if (rc
== WAIT_FAILED
) return -1;
2436 // The whole ReadConsoleInput () part is a workaround.
2437 // For some unknown reason, maybe a mingw bug, a random signal
2438 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2439 // Then it wants to read with getche () a keyboard input
2440 // which has never been made.
2442 INPUT_RECORD buf
[100];
2446 memset (buf
, 0, sizeof (buf
));
2448 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2450 FlushConsoleInputBuffer (stdinHandle
);
2452 for (uint i
= 0; i
< num
; i
++)
2454 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2456 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2458 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2460 return KeyEvent
.uChar
.AsciiChar
;
2468 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2470 SetConsoleMode (stdinHandle
, saveMode
);
2480 #define MSG_ENOMEM "Insufficient memory available"
2482 void *mycalloc (size_t nmemb
, size_t size
)
2484 void *p
= calloc (nmemb
, size
);
2488 log_error ("ERROR: %s", MSG_ENOMEM
);
2496 void *mymalloc (size_t size
)
2498 void *p
= malloc (size
);
2502 log_error ("ERROR: %s", MSG_ENOMEM
);
2507 memset (p
, 0, size
);
2512 void myfree (void *ptr
)
2514 if (ptr
== NULL
) return;
2519 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2521 void *p
= realloc (ptr
, oldsz
+ add
);
2525 log_error ("ERROR: %s", MSG_ENOMEM
);
2530 memset ((char *) p
+ oldsz
, 0, add
);
2535 char *mystrdup (const char *s
)
2537 const size_t len
= strlen (s
);
2539 char *b
= (char *) mymalloc (len
+ 1);
2546 FILE *logfile_open (char *logfile
)
2548 FILE *fp
= fopen (logfile
, "ab");
2558 void logfile_close (FILE *fp
)
2560 if (fp
== stdout
) return;
2565 void logfile_append (const char *fmt
, ...)
2567 if (data
.logfile_disable
== 1) return;
2569 FILE *fp
= logfile_open (data
.logfile
);
2575 vfprintf (fp
, fmt
, ap
);
2586 int logfile_generate_id ()
2588 const int n
= rand ();
2597 char *logfile_generate_topid ()
2599 const int id
= logfile_generate_id ();
2601 char *topid
= (char *) mymalloc (1 + 16 + 1);
2603 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2608 char *logfile_generate_subid ()
2610 const int id
= logfile_generate_id ();
2612 char *subid
= (char *) mymalloc (1 + 16 + 1);
2614 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2624 void lock_file (FILE *fp
)
2628 memset (&lock
, 0, sizeof (struct flock
));
2630 lock
.l_type
= F_WRLCK
;
2631 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2635 log_error ("ERROR: failed acquiring write lock: %s", strerror (errno
));
2642 void unlock_file (FILE *fp
)
2646 memset (&lock
, 0, sizeof (struct flock
));
2648 lock
.l_type
= F_UNLCK
;
2649 fcntl(fileno(fp
), F_SETLK
, &lock
);
2656 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2658 FlushFileBuffers (h
);
2667 #if defined(_WIN) && defined(HAVE_NVAPI)
2668 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2672 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nv
, nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2676 log_info ("WARN: No NvAPI adapters found");
2683 #endif // _WIN && HAVE_NVAPI
2685 #if defined(LINUX) && defined(HAVE_NVML)
2686 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2690 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2692 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nv
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2694 // can be used to determine if the device by index matches the cuda device by index
2695 // char name[100]; memset (name, 0, sizeof (name));
2696 // hm_NVML_nvmlDeviceGetName (data.hm_nv, nvGPUHandle[i], name, sizeof (name) - 1);
2703 log_info ("WARN: No NVML adapters found");
2710 #endif // LINUX && HAVE_NVML
2713 int get_adapters_num_amd (void *adl
, int *iNumberAdapters
)
2715 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2717 if (iNumberAdapters
== 0)
2719 log_info ("WARN: No ADL adapters found.");
2728 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2730 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2731 ADLODParameters lpOdParameters;
2733 lpOdParameters.iSize = sizeof (ADLODParameters);
2734 size_t plevels_size = 0;
2736 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2738 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2739 __func__, iAdapterIndex,
2740 lpOdParameters.iNumberOfPerformanceLevels,
2741 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2742 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2744 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2746 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2748 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2750 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2752 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2753 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2754 __func__, iAdapterIndex, j,
2755 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2757 myfree (lpOdPerformanceLevels);
2763 LPAdapterInfo
hm_get_adapter_info_amd (void *adl
, int iNumberAdapters
)
2765 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2767 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2769 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2771 return lpAdapterInfo
;
2776 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2779 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2783 for (uint i = 0; i < num_adl_adapters; i++)
2785 int opencl_bus_num = hm_device[i].busid;
2786 int opencl_dev_num = hm_device[i].devid;
2788 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2796 if (idx >= DEVICES_MAX) return -1;
2801 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2803 for (uint i = 0; i < opencl_num_devices; i++)
2805 cl_device_topology_amd device_topology;
2807 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2809 hm_device[i].busid = device_topology.pcie.bus;
2810 hm_device[i].devid = device_topology.pcie.device;
2815 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2817 // basically bubble sort
2819 for (int i
= 0; i
< num_adl_adapters
; i
++)
2821 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2823 // get info of adapter [x]
2825 u32 adapter_index_x
= valid_adl_device_list
[j
];
2826 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2828 u32 bus_num_x
= info_x
.iBusNumber
;
2829 u32 dev_num_x
= info_x
.iDeviceNumber
;
2831 // get info of adapter [y]
2833 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2834 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2836 u32 bus_num_y
= info_y
.iBusNumber
;
2837 u32 dev_num_y
= info_y
.iDeviceNumber
;
2841 if (bus_num_y
< bus_num_x
)
2845 else if (bus_num_y
== bus_num_x
)
2847 if (dev_num_y
< dev_num_x
)
2855 u32 temp
= valid_adl_device_list
[j
+ 1];
2857 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2858 valid_adl_device_list
[j
+ 0] = temp
;
2864 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2866 *num_adl_adapters
= 0;
2868 u32
*adl_adapters
= NULL
;
2870 int *bus_numbers
= NULL
;
2871 int *device_numbers
= NULL
;
2873 for (int i
= 0; i
< iNumberAdapters
; i
++)
2875 AdapterInfo info
= lpAdapterInfo
[i
];
2877 if (strlen (info
.strUDID
) < 1) continue;
2880 if (info
.iVendorID
!= 1002) continue;
2882 if (info
.iVendorID
!= 0x1002) continue;
2885 if (info
.iBusNumber
< 0) continue;
2886 if (info
.iDeviceNumber
< 0) continue;
2890 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2892 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2899 if (found
) continue;
2901 // add it to the list
2903 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2905 adl_adapters
[*num_adl_adapters
] = i
;
2907 // rest is just bookkeeping
2909 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2910 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2912 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2913 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2915 (*num_adl_adapters
)++;
2918 myfree (bus_numbers
);
2919 myfree (device_numbers
);
2921 // sort the list by increasing bus id, device id number
2923 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2925 return adl_adapters
;
2928 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2930 // loop through all valid devices
2932 for (int i
= 0; i
< num_adl_adapters
; i
++)
2934 u32 adapter_index
= valid_adl_device_list
[i
];
2938 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2940 // unfortunately this doesn't work since bus id and dev id are not unique
2941 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2942 // if (opencl_device_index == -1) continue;
2944 int opencl_device_index
= i
;
2946 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2948 // get fanspeed info
2950 if (hm_device
[opencl_device_index
].od_version
== 5)
2952 ADLFanSpeedInfo FanSpeedInfo
;
2954 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2956 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2958 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2960 // check read and write capability in fanspeedinfo
2962 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2963 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2965 hm_device
[opencl_device_index
].fan_supported
= 1;
2969 hm_device
[opencl_device_index
].fan_supported
= 0;
2972 else // od_version == 6
2974 ADLOD6FanSpeedInfo faninfo
;
2976 memset (&faninfo
, 0, sizeof (faninfo
));
2978 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2980 // check read capability in fanspeedinfo
2982 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2984 hm_device
[opencl_device_index
].fan_supported
= 1;
2988 hm_device
[opencl_device_index
].fan_supported
= 0;
2996 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2998 for (int i
= 0; i
< num_adl_adapters
; i
++)
3000 u32 adapter_index
= valid_adl_device_list
[i
];
3004 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3006 // get overdrive version
3008 int od_supported
= 0;
3012 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3014 // store the overdrive version in hm_device
3016 // unfortunately this doesn't work since bus id and dev id are not unique
3017 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3018 // if (opencl_device_index == -1) continue;
3020 int opencl_device_index
= i
;
3022 hm_device
[opencl_device_index
].od_version
= od_version
;
3028 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3030 for (int i
= 0; i
< num_adl_adapters
; i
++)
3032 u32 adapter_index
= valid_adl_device_list
[i
];
3036 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3038 // store the iAdapterIndex in hm_device
3040 // unfortunately this doesn't work since bus id and dev id are not unique
3041 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3042 // if (opencl_device_index == -1) continue;
3044 int opencl_device_index
= i
;
3046 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3049 return num_adl_adapters
;
3053 int hm_get_temperature_with_device_id (const uint device_id
)
3055 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3058 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3062 if (data
.hm_device
[device_id
].od_version
== 5)
3064 ADLTemperature Temperature
;
3066 Temperature
.iSize
= sizeof (ADLTemperature
);
3068 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3070 return Temperature
.iTemperature
/ 1000;
3072 else if (data
.hm_device
[device_id
].od_version
== 6)
3074 int Temperature
= 0;
3076 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3078 return Temperature
/ 1000;
3084 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3085 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3087 #if defined(LINUX) && defined(HAVE_NVML)
3088 int temperature
= 0;
3090 hm_NVML_nvmlDeviceGetTemperature (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (unsigned int *) &temperature
);
3095 #if defined(WIN) && defined(HAVE_NVAPI)
3096 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3098 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3099 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3100 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3101 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3103 if (hm_NvAPI_GPU_GetThermalSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3105 return pThermalSettings
.sensor
[0].currentTemp
;
3106 #endif // WIN && HAVE_NVAPI
3108 #endif // HAVE_NVML || HAVE_NVAPI
3113 int hm_get_fanspeed_with_device_id (const uint device_id
)
3115 // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
3116 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3118 if (data
.hm_device
[device_id
].fan_supported
== 1)
3121 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3125 if (data
.hm_device
[device_id
].od_version
== 5)
3127 ADLFanSpeedValue lpFanSpeedValue
;
3129 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3131 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3132 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3133 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3135 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3137 return lpFanSpeedValue
.iFanSpeed
;
3139 else // od_version == 6
3141 ADLOD6FanSpeedInfo faninfo
;
3143 memset (&faninfo
, 0, sizeof (faninfo
));
3145 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3147 return faninfo
.iFanSpeedPercent
;
3153 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3154 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3156 #if defined(LINUX) && defined(HAVE_NVML)
3159 hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (unsigned int *) &speed
);
3164 #if defined(WIN) && defined(HAVE_NVAPI)
3166 NV_GPU_COOLER_SETTINGS pCoolerSettings
;
3168 pCoolerSettings
.Version
= GPU_COOLER_SETTINGS_VER
| sizeof (NV_GPU_COOLER_SETTINGS
);
3170 hm_NvAPI_GPU_GetCoolerSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pCoolerSettings
);
3172 return pCoolerSettings
.Cooler
[0].CurrentLevel
;
3175 #endif // HAVE_NVML || HAVE_NVAPI
3181 int hm_get_utilization_with_device_id (const uint device_id
)
3183 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3186 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3190 ADLPMActivity PMActivity
;
3192 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3194 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3196 return PMActivity
.iActivityPercent
;
3201 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3202 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3204 #if defined(LINUX) && defined(HAVE_NVML)
3205 nvmlUtilization_t utilization
;
3207 hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3209 return utilization
.gpu
;
3212 #if defined(WIN) && defined(HAVE_NVAPI)
3213 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3215 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3217 if (hm_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3219 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3222 #endif // HAVE_NVML || HAVE_NVAPI
3228 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3230 if (data
.hm_device
[device_id
].fan_supported
== 1)
3234 if (data
.hm_device
[device_id
].od_version
== 5)
3236 ADLFanSpeedValue lpFanSpeedValue
;
3238 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3240 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3241 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3242 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3243 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3245 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3249 else // od_version == 6
3251 ADLOD6FanSpeedValue fan_speed_value
;
3253 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3255 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3256 fan_speed_value
.iFanSpeed
= fanspeed
;
3258 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3269 // helper function for status display
3271 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3273 #define VALUE_NOT_AVAILABLE "N/A"
3277 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3281 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3284 #endif // HAVE_HWMON
3290 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3292 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3294 if (css_cnt
> SP_PW_MAX
)
3296 log_error ("ERROR: mask length is too long");
3301 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3303 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3305 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3306 uint cs_len
= css
[css_pos
].cs_len
;
3308 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3310 uint c
= cs_buf
[cs_pos
] & 0xff;
3317 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3319 cs_t
*cs
= &css
[css_cnt
];
3321 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3323 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3327 for (i
= 0; i
< cs
->cs_len
; i
++)
3329 const uint u
= cs
->cs_buf
[i
];
3334 for (i
= 0; i
< in_len
; i
++)
3336 uint u
= in_buf
[i
] & 0xff;
3338 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3340 if (css_uniq
[u
] == 1) continue;
3344 cs
->cs_buf
[cs
->cs_len
] = u
;
3352 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3356 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3358 uint p0
= in_buf
[in_pos
] & 0xff;
3360 if (interpret
== 1 && p0
== '?')
3364 if (in_pos
== in_len
) break;
3366 uint p1
= in_buf
[in_pos
] & 0xff;
3370 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3372 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3374 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3376 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3378 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3380 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3382 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3383 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3385 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3386 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3388 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3389 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3391 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3392 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3394 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3396 default: log_error ("Syntax error: %s", in_buf
);
3402 if (data
.hex_charset
)
3406 if (in_pos
== in_len
)
3408 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3413 uint p1
= in_buf
[in_pos
] & 0xff;
3415 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3417 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3424 chr
= hex_convert (p1
) << 0;
3425 chr
|= hex_convert (p0
) << 4;
3427 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3433 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3439 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3443 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3445 sum
*= css
[css_pos
].cs_len
;
3451 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3453 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3458 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3460 char p0
= mask_buf
[mask_pos
];
3466 if (mask_pos
== mask_len
) break;
3468 char p1
= mask_buf
[mask_pos
];
3474 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3476 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3478 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3480 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3482 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3484 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3486 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3487 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3489 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3490 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3492 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3493 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3495 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3496 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3498 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3500 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3506 if (data
.hex_charset
)
3510 // if there is no 2nd hex character, show an error:
3512 if (mask_pos
== mask_len
)
3514 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3519 char p1
= mask_buf
[mask_pos
];
3521 // if they are not valid hex character, show an error:
3523 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3525 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3532 chr
|= hex_convert (p1
) << 0;
3533 chr
|= hex_convert (p0
) << 4;
3535 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3541 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3548 log_error ("ERROR: invalid mask length (0)");
3558 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3560 for (int i
= 0; i
< css_cnt
; i
++)
3562 uint len
= css
[i
].cs_len
;
3563 u64 next
= val
/ len
;
3564 uint pos
= val
% len
;
3565 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3570 void mp_cut_at (char *mask
, uint max
)
3574 uint mask_len
= strlen (mask
);
3576 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3578 if (mask
[i
] == '?') i
++;
3584 void mp_setup_sys (cs_t
*mp_sys
)
3588 uint donec
[CHARSIZ
] = { 0 };
3590 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3591 mp_sys
[0].cs_buf
[pos
++] = chr
;
3592 mp_sys
[0].cs_len
= pos
; }
3594 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3595 mp_sys
[1].cs_buf
[pos
++] = chr
;
3596 mp_sys
[1].cs_len
= pos
; }
3598 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3599 mp_sys
[2].cs_buf
[pos
++] = chr
;
3600 mp_sys
[2].cs_len
= pos
; }
3602 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3603 mp_sys
[3].cs_buf
[pos
++] = chr
;
3604 mp_sys
[3].cs_len
= pos
; }
3606 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3607 mp_sys
[4].cs_len
= pos
; }
3609 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3610 mp_sys
[5].cs_len
= pos
; }
3613 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3615 FILE *fp
= fopen (buf
, "rb");
3617 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3619 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3623 char mp_file
[1024] = { 0 };
3625 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3629 len
= in_superchop (mp_file
);
3633 log_info ("WARNING: charset file corrupted");
3635 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3639 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3644 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3646 mp_usr
[index
].cs_len
= 0;
3648 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3651 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3653 char *new_mask_buf
= (char *) mymalloc (256);
3659 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3661 if (css_pos
== len
) break;
3663 char p0
= mask_buf
[mask_pos
];
3665 new_mask_buf
[mask_pos
] = p0
;
3671 if (mask_pos
== mask_len
) break;
3673 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3677 if (data
.hex_charset
)
3681 if (mask_pos
== mask_len
)
3683 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3688 char p1
= mask_buf
[mask_pos
];
3690 // if they are not valid hex character, show an error:
3692 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3694 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3699 new_mask_buf
[mask_pos
] = p1
;
3704 if (css_pos
== len
) return (new_mask_buf
);
3706 myfree (new_mask_buf
);
3715 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3721 for (i
= start
; i
< stop
; i
++)
3723 sum
*= root_css_buf
[i
].cs_len
;
3729 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3733 cs_t
*cs
= &root_css_buf
[start
];
3737 for (i
= start
; i
< stop
; i
++)
3739 const u64 m
= v
% cs
->cs_len
;
3740 const u64 d
= v
/ cs
->cs_len
;
3744 const uint k
= cs
->cs_buf
[m
];
3746 pw_buf
[i
- start
] = (char) k
;
3748 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3752 int sp_comp_val (const void *p1
, const void *p2
)
3754 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3755 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3757 return b2
->val
- b1
->val
;
3760 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
)
3767 * Initialize hcstats
3770 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3772 u64
*root_stats_ptr
= root_stats_buf
;
3774 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3776 for (i
= 0; i
< SP_PW_MAX
; i
++)
3778 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3780 root_stats_ptr
+= CHARSIZ
;
3783 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3785 u64
*markov_stats_ptr
= markov_stats_buf
;
3787 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3789 for (i
= 0; i
< SP_PW_MAX
; i
++)
3791 for (j
= 0; j
< CHARSIZ
; j
++)
3793 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3795 markov_stats_ptr
+= CHARSIZ
;
3805 char hcstat_tmp
[256] = { 0 };
3807 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3809 hcstat
= hcstat_tmp
;
3812 FILE *fd
= fopen (hcstat
, "rb");
3816 log_error ("%s: %s", hcstat
, strerror (errno
));
3821 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3823 log_error ("%s: Could not load data", hcstat
);
3830 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3832 log_error ("%s: Could not load data", hcstat
);
3842 * Markov modifier of hcstat_table on user request
3847 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
3848 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
3853 /* Add all stats to first position */
3855 for (i
= 1; i
< SP_PW_MAX
; i
++)
3857 u64
*out
= root_stats_buf_by_pos
[0];
3858 u64
*in
= root_stats_buf_by_pos
[i
];
3860 for (j
= 0; j
< CHARSIZ
; j
++)
3866 for (i
= 1; i
< SP_PW_MAX
; i
++)
3868 u64
*out
= markov_stats_buf_by_key
[0][0];
3869 u64
*in
= markov_stats_buf_by_key
[i
][0];
3871 for (j
= 0; j
< CHARSIZ
; j
++)
3873 for (k
= 0; k
< CHARSIZ
; k
++)
3880 /* copy them to all pw_positions */
3882 for (i
= 1; i
< SP_PW_MAX
; i
++)
3884 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
3887 for (i
= 1; i
< SP_PW_MAX
; i
++)
3889 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
3897 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3899 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3901 for (i
= 0; i
< SP_PW_MAX
; i
++)
3903 root_table_buf_by_pos
[i
] = root_table_ptr
;
3905 root_table_ptr
+= CHARSIZ
;
3908 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3910 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3912 for (i
= 0; i
< SP_PW_MAX
; i
++)
3914 for (j
= 0; j
< CHARSIZ
; j
++)
3916 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3918 markov_table_ptr
+= CHARSIZ
;
3923 * Convert hcstat to tables
3926 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3928 uint key
= i
% CHARSIZ
;
3930 root_table_buf
[i
].key
= key
;
3931 root_table_buf
[i
].val
= root_stats_buf
[i
];
3934 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3936 uint key
= i
% CHARSIZ
;
3938 markov_table_buf
[i
].key
= key
;
3939 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3942 myfree (root_stats_buf
);
3943 myfree (markov_stats_buf
);
3949 for (i
= 0; i
< SP_PW_MAX
; i
++)
3951 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3954 for (i
= 0; i
< SP_PW_MAX
; i
++)
3956 for (j
= 0; j
< CHARSIZ
; j
++)
3958 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3963 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
])
3966 * Convert tables to css
3969 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
3971 uint pw_pos
= i
/ CHARSIZ
;
3973 cs_t
*cs
= &root_css_buf
[pw_pos
];
3975 if (cs
->cs_len
== threshold
) continue;
3977 uint key
= root_table_buf
[i
].key
;
3979 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
3981 cs
->cs_buf
[cs
->cs_len
] = key
;
3987 * Convert table to css
3990 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
3992 uint c
= i
/ CHARSIZ
;
3994 cs_t
*cs
= &markov_css_buf
[c
];
3996 if (cs
->cs_len
== threshold
) continue;
3998 uint pw_pos
= c
/ CHARSIZ
;
4000 uint key
= markov_table_buf
[i
].key
;
4002 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4004 cs
->cs_buf
[cs
->cs_len
] = key
;
4010 for (uint i = 0; i < 8; i++)
4012 for (uint j = 0x20; j < 0x80; j++)
4014 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4016 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4018 for (uint k = 0; k < 10; k++)
4020 printf (" %u\n", ptr->cs_buf[k]);
4027 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4029 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4031 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4041 for (uint j
= 1; j
< CHARSIZ
; j
++)
4051 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4053 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4055 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4057 out
+= CHARSIZ
* CHARSIZ
;
4058 in
+= CHARSIZ
* CHARSIZ
;
4060 for (uint j
= 0; j
< CHARSIZ
; j
++)
4067 for (uint k
= 1; k
< CHARSIZ
; k
++)
4079 * mixed shared functions
4082 void dump_hex (const u8
*s
, const int sz
)
4084 for (int i
= 0; i
< sz
; i
++)
4086 log_info_nn ("%02x ", s
[i
]);
4092 void usage_mini_print (const char *progname
)
4094 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4097 void usage_big_print (const char *progname
)
4099 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4102 char *get_exec_path ()
4104 int exec_path_len
= 1024;
4106 char *exec_path
= (char *) mymalloc (exec_path_len
);
4110 char tmp
[32] = { 0 };
4112 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4114 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4118 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4122 uint size
= exec_path_len
;
4124 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4126 log_error("! executable path buffer too small\n");
4131 const int len
= strlen (exec_path
);
4134 #error Your Operating System is not supported or detected
4142 char *get_install_dir (const char *progname
)
4144 char *install_dir
= mystrdup (progname
);
4145 char *last_slash
= NULL
;
4147 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4151 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4157 install_dir
[0] = '.';
4161 return (install_dir
);
4164 char *get_profile_dir (const char *homedir
)
4166 #define DOT_HASHCAT ".hashcat"
4168 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4170 char *profile_dir
= (char *) mymalloc (len
+ 1);
4172 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4177 char *get_session_dir (const char *profile_dir
)
4179 #define SESSIONS_FOLDER "sessions"
4181 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4183 char *session_dir
= (char *) mymalloc (len
+ 1);
4185 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4190 uint
count_lines (FILE *fd
)
4194 char *buf
= (char *) mymalloc (BUFSIZ
+ 1);
4200 size_t nread
= fread (buf
, sizeof (char), BUFSIZ
, fd
);
4202 if (nread
< 1) continue;
4206 for (i
= 0; i
< nread
; i
++)
4208 if (prev
== '\n') cnt
++;
4219 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4223 FILE *fd
= fopen (filename
, "rb");
4227 log_error ("%s: %s", filename
, strerror (errno
));
4232 #define MAX_KEY_SIZE (1024 * 1024)
4234 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4236 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4242 for (int fpos
= 0; fpos
< nread
; fpos
++)
4244 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4246 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4247 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4248 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4249 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4251 if (kpos
>= 64) kpos
= 0;
4258 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4262 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4263 if (CPU_ISSET(core
, cpu_set
)) break;
4265 thread_affinity_policy_data_t policy
= { core
};
4267 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4269 if (data
.quiet
== 0)
4271 if (rc
!= KERN_SUCCESS
)
4273 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4281 void set_cpu_affinity (char *cpu_affinity
)
4284 DWORD_PTR aff_mask
= 0;
4292 char *devices
= strdup (cpu_affinity
);
4294 char *next
= strtok (devices
, ",");
4298 uint cpu_id
= atoi (next
);
4313 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4319 aff_mask
|= 1 << (cpu_id
- 1);
4321 CPU_SET ((cpu_id
- 1), &cpuset
);
4324 } while ((next
= strtok (NULL
, ",")) != NULL
);
4330 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4331 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4333 pthread_t thread
= pthread_self ();
4334 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4338 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4340 char *element
, *end
;
4342 end
= (char *) base
+ nmemb
* size
;
4344 for (element
= (char *) base
; element
< end
; element
+= size
)
4345 if (!compar (element
, key
))
4351 int sort_by_salt (const void *v1
, const void *v2
)
4353 const salt_t
*s1
= (const salt_t
*) v1
;
4354 const salt_t
*s2
= (const salt_t
*) v2
;
4356 const int res1
= s1
->salt_len
- s2
->salt_len
;
4358 if (res1
!= 0) return (res1
);
4360 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4362 if (res2
!= 0) return (res2
);
4370 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4371 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4378 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4379 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4385 int sort_by_salt_buf (const void *v1
, const void *v2
)
4387 const pot_t
*p1
= (const pot_t
*) v1
;
4388 const pot_t
*p2
= (const pot_t
*) v2
;
4390 const hash_t
*h1
= &p1
->hash
;
4391 const hash_t
*h2
= &p2
->hash
;
4393 const salt_t
*s1
= h1
->salt
;
4394 const salt_t
*s2
= h2
->salt
;
4400 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4401 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4407 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4409 const hash_t
*h1
= (const hash_t
*) v1
;
4410 const hash_t
*h2
= (const hash_t
*) v2
;
4412 const salt_t
*s1
= h1
->salt
;
4413 const salt_t
*s2
= h2
->salt
;
4415 // testphase: this should work
4420 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4421 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4424 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4425 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4426 if (s1->salt_len > s2->salt_len) return ( 1);
4427 if (s1->salt_len < s2->salt_len) return (-1);
4429 uint n = s1->salt_len;
4433 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4434 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4441 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4443 const hash_t
*h1
= (const hash_t
*) v1
;
4444 const hash_t
*h2
= (const hash_t
*) v2
;
4446 const salt_t
*s1
= h1
->salt
;
4447 const salt_t
*s2
= h2
->salt
;
4449 // 16 - 2 (since last 2 uints contain the digest)
4454 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4455 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4461 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4463 const hash_t
*h1
= (const hash_t
*) v1
;
4464 const hash_t
*h2
= (const hash_t
*) v2
;
4466 const void *d1
= h1
->digest
;
4467 const void *d2
= h2
->digest
;
4469 return data
.sort_by_digest (d1
, d2
);
4472 int sort_by_hash (const void *v1
, const void *v2
)
4474 const hash_t
*h1
= (const hash_t
*) v1
;
4475 const hash_t
*h2
= (const hash_t
*) v2
;
4479 const salt_t
*s1
= h1
->salt
;
4480 const salt_t
*s2
= h2
->salt
;
4482 int res
= sort_by_salt (s1
, s2
);
4484 if (res
!= 0) return (res
);
4487 const void *d1
= h1
->digest
;
4488 const void *d2
= h2
->digest
;
4490 return data
.sort_by_digest (d1
, d2
);
4493 int sort_by_pot (const void *v1
, const void *v2
)
4495 const pot_t
*p1
= (const pot_t
*) v1
;
4496 const pot_t
*p2
= (const pot_t
*) v2
;
4498 const hash_t
*h1
= &p1
->hash
;
4499 const hash_t
*h2
= &p2
->hash
;
4501 return sort_by_hash (h1
, h2
);
4504 int sort_by_mtime (const void *p1
, const void *p2
)
4506 const char **f1
= (const char **) p1
;
4507 const char **f2
= (const char **) p2
;
4509 struct stat s1
; stat (*f1
, &s1
);
4510 struct stat s2
; stat (*f2
, &s2
);
4512 return s2
.st_mtime
- s1
.st_mtime
;
4515 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4517 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4518 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4520 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4523 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4525 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4526 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4528 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4531 int sort_by_stringptr (const void *p1
, const void *p2
)
4533 const char **s1
= (const char **) p1
;
4534 const char **s2
= (const char **) p2
;
4536 return strcmp (*s1
, *s2
);
4539 int sort_by_dictstat (const void *s1
, const void *s2
)
4541 dictstat_t
*d1
= (dictstat_t
*) s1
;
4542 dictstat_t
*d2
= (dictstat_t
*) s2
;
4545 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4547 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4550 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4553 int sort_by_bitmap (const void *p1
, const void *p2
)
4555 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4556 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4558 return b1
->collisions
- b2
->collisions
;
4561 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4563 const u32
*d1
= (const u32
*) v1
;
4564 const u32
*d2
= (const u32
*) v2
;
4570 if (d1
[n
] > d2
[n
]) return ( 1);
4571 if (d1
[n
] < d2
[n
]) return (-1);
4577 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4579 const u32
*d1
= (const u32
*) v1
;
4580 const u32
*d2
= (const u32
*) v2
;
4586 if (d1
[n
] > d2
[n
]) return ( 1);
4587 if (d1
[n
] < d2
[n
]) return (-1);
4593 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4595 const u32
*d1
= (const u32
*) v1
;
4596 const u32
*d2
= (const u32
*) v2
;
4602 if (d1
[n
] > d2
[n
]) return ( 1);
4603 if (d1
[n
] < d2
[n
]) return (-1);
4609 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4611 const u32
*d1
= (const u32
*) v1
;
4612 const u32
*d2
= (const u32
*) v2
;
4618 if (d1
[n
] > d2
[n
]) return ( 1);
4619 if (d1
[n
] < d2
[n
]) return (-1);
4625 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4627 const u32
*d1
= (const u32
*) v1
;
4628 const u32
*d2
= (const u32
*) v2
;
4634 if (d1
[n
] > d2
[n
]) return ( 1);
4635 if (d1
[n
] < d2
[n
]) return (-1);
4641 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4643 const u32
*d1
= (const u32
*) v1
;
4644 const u32
*d2
= (const u32
*) v2
;
4650 if (d1
[n
] > d2
[n
]) return ( 1);
4651 if (d1
[n
] < d2
[n
]) return (-1);
4657 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4659 const u32
*d1
= (const u32
*) v1
;
4660 const u32
*d2
= (const u32
*) v2
;
4666 if (d1
[n
] > d2
[n
]) return ( 1);
4667 if (d1
[n
] < d2
[n
]) return (-1);
4673 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4675 const u32
*d1
= (const u32
*) v1
;
4676 const u32
*d2
= (const u32
*) v2
;
4682 if (d1
[n
] > d2
[n
]) return ( 1);
4683 if (d1
[n
] < d2
[n
]) return (-1);
4689 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4691 const u64
*d1
= (const u64
*) v1
;
4692 const u64
*d2
= (const u64
*) v2
;
4698 if (d1
[n
] > d2
[n
]) return ( 1);
4699 if (d1
[n
] < d2
[n
]) return (-1);
4705 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4707 const u64
*d1
= (const u64
*) v1
;
4708 const u64
*d2
= (const u64
*) v2
;
4714 if (d1
[n
] > d2
[n
]) return ( 1);
4715 if (d1
[n
] < d2
[n
]) return (-1);
4721 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4723 const u64
*d1
= (const u64
*) v1
;
4724 const u64
*d2
= (const u64
*) v2
;
4730 if (d1
[n
] > d2
[n
]) return ( 1);
4731 if (d1
[n
] < d2
[n
]) return (-1);
4737 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4739 const u32
*d1
= (const u32
*) v1
;
4740 const u32
*d2
= (const u32
*) v2
;
4742 const uint dgst_pos0
= data
.dgst_pos0
;
4743 const uint dgst_pos1
= data
.dgst_pos1
;
4744 const uint dgst_pos2
= data
.dgst_pos2
;
4745 const uint dgst_pos3
= data
.dgst_pos3
;
4747 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4748 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4749 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4750 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4751 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4752 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4753 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4754 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4759 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4761 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4762 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4764 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4766 if (res1
!= 0) return (res1
);
4771 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4773 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4774 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4776 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4778 if (res1
!= 0) return (res1
);
4780 const int res2
= t1
->attack_mode
4783 if (res2
!= 0) return (res2
);
4785 const int res3
= t1
->hash_type
4788 if (res3
!= 0) return (res3
);
4793 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
)
4795 uint outfile_autohex
= data
.outfile_autohex
;
4797 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4799 FILE *debug_fp
= NULL
;
4801 if (debug_file
!= NULL
)
4803 debug_fp
= fopen (debug_file
, "ab");
4805 lock_file (debug_fp
);
4812 if (debug_fp
== NULL
)
4814 log_info ("WARNING: Could not open debug-file for writing");
4818 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4820 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4822 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4825 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4827 if (debug_mode
== 4)
4829 fputc (':', debug_fp
);
4831 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4834 fputc ('\n', debug_fp
);
4836 if (debug_file
!= NULL
) fclose (debug_fp
);
4840 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4842 int needs_hexify
= 0;
4844 if (outfile_autohex
== 1)
4846 for (uint i
= 0; i
< plain_len
; i
++)
4848 if (plain_ptr
[i
] < 0x20)
4855 if (plain_ptr
[i
] > 0x7f)
4864 if (needs_hexify
== 1)
4866 fprintf (fp
, "$HEX[");
4868 for (uint i
= 0; i
< plain_len
; i
++)
4870 fprintf (fp
, "%02x", plain_ptr
[i
]);
4877 fwrite (plain_ptr
, plain_len
, 1, fp
);
4881 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
)
4883 uint outfile_format
= data
.outfile_format
;
4885 char separator
= data
.separator
;
4887 if (outfile_format
& OUTFILE_FMT_HASH
)
4889 fprintf (out_fp
, "%s", out_buf
);
4891 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4893 fputc (separator
, out_fp
);
4896 else if (data
.username
)
4898 if (username
!= NULL
)
4900 for (uint i
= 0; i
< user_len
; i
++)
4902 fprintf (out_fp
, "%c", username
[i
]);
4905 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4907 fputc (separator
, out_fp
);
4912 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4914 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4916 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4918 fputc (separator
, out_fp
);
4922 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4924 for (uint i
= 0; i
< plain_len
; i
++)
4926 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4929 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4931 fputc (separator
, out_fp
);
4935 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4938 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4943 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
4945 fprintf (out_fp
, "%llu", crackpos
);
4950 fputc ('\n', out_fp
);
4953 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
)
4957 pot_key
.hash
.salt
= hashes_buf
->salt
;
4958 pot_key
.hash
.digest
= hashes_buf
->digest
;
4960 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4966 input_buf
[input_len
] = 0;
4969 unsigned char *username
= NULL
;
4974 user_t
*user
= hashes_buf
->hash_info
->user
;
4978 username
= (unsigned char *) (user
->user_name
);
4980 user_len
= user
->user_len
;
4984 // do output the line
4985 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
4989 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
4990 #define LM_MASKED_PLAIN "[notfound]"
4992 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
)
4998 pot_left_key
.hash
.salt
= hash_left
->salt
;
4999 pot_left_key
.hash
.digest
= hash_left
->digest
;
5001 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5005 uint weak_hash_found
= 0;
5007 pot_t pot_right_key
;
5009 pot_right_key
.hash
.salt
= hash_right
->salt
;
5010 pot_right_key
.hash
.digest
= hash_right
->digest
;
5012 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5014 if (pot_right_ptr
== NULL
)
5016 // special case, if "weak hash"
5018 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5020 weak_hash_found
= 1;
5022 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5024 // in theory this is not needed, but we are paranoia:
5026 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5027 pot_right_ptr
->plain_len
= 0;
5031 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5033 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
5038 // at least one half was found:
5042 input_buf
[input_len
] = 0;
5046 unsigned char *username
= NULL
;
5051 user_t
*user
= hash_left
->hash_info
->user
;
5055 username
= (unsigned char *) (user
->user_name
);
5057 user_len
= user
->user_len
;
5061 // mask the part which was not found
5063 uint left_part_masked
= 0;
5064 uint right_part_masked
= 0;
5066 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5068 if (pot_left_ptr
== NULL
)
5070 left_part_masked
= 1;
5072 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5074 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5076 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5077 pot_left_ptr
->plain_len
= mask_plain_len
;
5080 if (pot_right_ptr
== NULL
)
5082 right_part_masked
= 1;
5084 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5086 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5088 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5089 pot_right_ptr
->plain_len
= mask_plain_len
;
5092 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5096 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5098 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5100 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5102 // do output the line
5104 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5106 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5108 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5109 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5112 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
)
5116 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5118 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5120 if (pot_ptr
== NULL
)
5124 input_buf
[input_len
] = 0;
5126 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5130 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
)
5136 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5138 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5142 pot_t pot_right_key
;
5144 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5146 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5148 uint weak_hash_found
= 0;
5150 if (pot_right_ptr
== NULL
)
5152 // special case, if "weak hash"
5154 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5156 weak_hash_found
= 1;
5158 // we just need that pot_right_ptr is not a NULL pointer
5160 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5164 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5166 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5171 // ... at least one part was not cracked
5175 input_buf
[input_len
] = 0;
5177 // only show the hash part which is still not cracked
5179 uint user_len
= input_len
- 32;
5181 char *hash_output
= (char *) mymalloc (33);
5183 memcpy (hash_output
, input_buf
, input_len
);
5185 if (pot_left_ptr
!= NULL
)
5187 // only show right part (because left part was already found)
5189 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5191 hash_output
[user_len
+ 16] = 0;
5194 if (pot_right_ptr
!= NULL
)
5196 // only show left part (because right part was already found)
5198 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5200 hash_output
[user_len
+ 16] = 0;
5203 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5205 myfree (hash_output
);
5207 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5210 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5212 uint opencl_platforms_filter
= 0;
5214 if (opencl_platforms
)
5216 char *platforms
= strdup (opencl_platforms
);
5218 char *next
= strtok (platforms
, ",");
5222 int platform
= atoi (next
);
5224 if (platform
< 1 || platform
> 32)
5226 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5231 opencl_platforms_filter
|= 1 << (platform
- 1);
5233 } while ((next
= strtok (NULL
, ",")) != NULL
);
5239 opencl_platforms_filter
= -1;
5242 return opencl_platforms_filter
;
5245 u32
setup_devices_filter (char *opencl_devices
)
5247 u32 devices_filter
= 0;
5251 char *devices
= strdup (opencl_devices
);
5253 char *next
= strtok (devices
, ",");
5257 int device_id
= atoi (next
);
5259 if (device_id
< 1 || device_id
> 32)
5261 log_error ("ERROR: invalid device_id %u specified", device_id
);
5266 devices_filter
|= 1 << (device_id
- 1);
5268 } while ((next
= strtok (NULL
, ",")) != NULL
);
5274 devices_filter
= -1;
5277 return devices_filter
;
5280 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5282 cl_device_type device_types_filter
= 0;
5284 if (opencl_device_types
)
5286 char *device_types
= strdup (opencl_device_types
);
5288 char *next
= strtok (device_types
, ",");
5292 int device_type
= atoi (next
);
5294 if (device_type
< 1 || device_type
> 3)
5296 log_error ("ERROR: invalid device_type %u specified", device_type
);
5301 device_types_filter
|= 1 << device_type
;
5303 } while ((next
= strtok (NULL
, ",")) != NULL
);
5305 free (device_types
);
5309 // Do not use CPU by default, this often reduces GPU performance because
5310 // the CPU is too busy to handle GPU synchronization
5312 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5315 return device_types_filter
;
5318 u32
get_random_num (const u32 min
, const u32 max
)
5320 if (min
== max
) return (min
);
5322 return ((rand () % (max
- min
)) + min
);
5325 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5327 u32 quotient
= dividend
/ divisor
;
5329 if (dividend
% divisor
) quotient
++;
5334 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5336 u64 quotient
= dividend
/ divisor
;
5338 if (dividend
% divisor
) quotient
++;
5343 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5345 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5346 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5348 if (tm
->tm_year
- 70)
5350 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5351 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5353 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5355 else if (tm
->tm_yday
)
5357 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5358 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5360 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5362 else if (tm
->tm_hour
)
5364 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5365 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5367 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5369 else if (tm
->tm_min
)
5371 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5372 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5374 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5378 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5380 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5384 void format_speed_display (float val
, char *buf
, size_t len
)
5395 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5406 /* generate output */
5410 snprintf (buf
, len
- 1, "%.0f ", val
);
5414 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5418 void lowercase (u8
*buf
, int len
)
5420 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5423 void uppercase (u8
*buf
, int len
)
5425 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5428 int fgetl (FILE *fp
, char *line_buf
)
5434 const int c
= fgetc (fp
);
5436 if (c
== EOF
) break;
5438 line_buf
[line_len
] = (char) c
;
5442 if (line_len
== BUFSIZ
) line_len
--;
5444 if (c
== '\n') break;
5447 if (line_len
== 0) return 0;
5449 if (line_buf
[line_len
- 1] == '\n')
5453 line_buf
[line_len
] = 0;
5456 if (line_len
== 0) return 0;
5458 if (line_buf
[line_len
- 1] == '\r')
5462 line_buf
[line_len
] = 0;
5468 int in_superchop (char *buf
)
5470 int len
= strlen (buf
);
5474 if (buf
[len
- 1] == '\n')
5481 if (buf
[len
- 1] == '\r')
5496 char **scan_directory (const char *path
)
5498 char *tmp_path
= mystrdup (path
);
5500 size_t tmp_path_len
= strlen (tmp_path
);
5502 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5504 tmp_path
[tmp_path_len
- 1] = 0;
5506 tmp_path_len
= strlen (tmp_path
);
5509 char **files
= NULL
;
5515 if ((d
= opendir (tmp_path
)) != NULL
)
5521 memset (&e
, 0, sizeof (e
));
5522 struct dirent
*de
= NULL
;
5524 if (readdir_r (d
, &e
, &de
) != 0)
5526 log_error ("ERROR: readdir_r() failed");
5531 if (de
== NULL
) break;
5535 while ((de
= readdir (d
)) != NULL
)
5538 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5540 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5542 char *path_file
= (char *) mymalloc (path_size
+ 1);
5544 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5546 path_file
[path_size
] = 0;
5550 if ((d_test
= opendir (path_file
)) != NULL
)
5558 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5562 files
[num_files
- 1] = path_file
;
5568 else if (errno
== ENOTDIR
)
5570 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5574 files
[num_files
- 1] = mystrdup (path
);
5577 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5581 files
[num_files
- 1] = NULL
;
5588 int count_dictionaries (char **dictionary_files
)
5590 if (dictionary_files
== NULL
) return 0;
5594 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5602 char *stroptitype (const uint opti_type
)
5606 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5607 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5608 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5609 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5610 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5611 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5612 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5613 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5614 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5615 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5616 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5617 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5618 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5619 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5620 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5621 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5622 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5623 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5629 char *strparser (const uint parser_status
)
5631 switch (parser_status
)
5633 case PARSER_OK
: return ((char *) PA_000
); break;
5634 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5635 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5636 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5637 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5638 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5639 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5640 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5641 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5642 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5643 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5644 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5645 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5646 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5647 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5648 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5649 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5652 return ((char *) PA_255
);
5655 char *strhashtype (const uint hash_mode
)
5659 case 0: return ((char *) HT_00000
); break;
5660 case 10: return ((char *) HT_00010
); break;
5661 case 11: return ((char *) HT_00011
); break;
5662 case 12: return ((char *) HT_00012
); break;
5663 case 20: return ((char *) HT_00020
); break;
5664 case 21: return ((char *) HT_00021
); break;
5665 case 22: return ((char *) HT_00022
); break;
5666 case 23: return ((char *) HT_00023
); break;
5667 case 30: return ((char *) HT_00030
); break;
5668 case 40: return ((char *) HT_00040
); break;
5669 case 50: return ((char *) HT_00050
); break;
5670 case 60: return ((char *) HT_00060
); break;
5671 case 100: return ((char *) HT_00100
); break;
5672 case 101: return ((char *) HT_00101
); break;
5673 case 110: return ((char *) HT_00110
); break;
5674 case 111: return ((char *) HT_00111
); break;
5675 case 112: return ((char *) HT_00112
); break;
5676 case 120: return ((char *) HT_00120
); break;
5677 case 121: return ((char *) HT_00121
); break;
5678 case 122: return ((char *) HT_00122
); break;
5679 case 124: return ((char *) HT_00124
); break;
5680 case 130: return ((char *) HT_00130
); break;
5681 case 131: return ((char *) HT_00131
); break;
5682 case 132: return ((char *) HT_00132
); break;
5683 case 133: return ((char *) HT_00133
); break;
5684 case 140: return ((char *) HT_00140
); break;
5685 case 141: return ((char *) HT_00141
); break;
5686 case 150: return ((char *) HT_00150
); break;
5687 case 160: return ((char *) HT_00160
); break;
5688 case 190: return ((char *) HT_00190
); break;
5689 case 200: return ((char *) HT_00200
); break;
5690 case 300: return ((char *) HT_00300
); break;
5691 case 400: return ((char *) HT_00400
); break;
5692 case 500: return ((char *) HT_00500
); break;
5693 case 501: return ((char *) HT_00501
); break;
5694 case 900: return ((char *) HT_00900
); break;
5695 case 910: return ((char *) HT_00910
); break;
5696 case 1000: return ((char *) HT_01000
); break;
5697 case 1100: return ((char *) HT_01100
); break;
5698 case 1400: return ((char *) HT_01400
); break;
5699 case 1410: return ((char *) HT_01410
); break;
5700 case 1420: return ((char *) HT_01420
); break;
5701 case 1421: return ((char *) HT_01421
); break;
5702 case 1430: return ((char *) HT_01430
); break;
5703 case 1440: return ((char *) HT_01440
); break;
5704 case 1441: return ((char *) HT_01441
); break;
5705 case 1450: return ((char *) HT_01450
); break;
5706 case 1460: return ((char *) HT_01460
); break;
5707 case 1500: return ((char *) HT_01500
); break;
5708 case 1600: return ((char *) HT_01600
); break;
5709 case 1700: return ((char *) HT_01700
); break;
5710 case 1710: return ((char *) HT_01710
); break;
5711 case 1711: return ((char *) HT_01711
); break;
5712 case 1720: return ((char *) HT_01720
); break;
5713 case 1722: return ((char *) HT_01722
); break;
5714 case 1730: return ((char *) HT_01730
); break;
5715 case 1731: return ((char *) HT_01731
); break;
5716 case 1740: return ((char *) HT_01740
); break;
5717 case 1750: return ((char *) HT_01750
); break;
5718 case 1760: return ((char *) HT_01760
); break;
5719 case 1800: return ((char *) HT_01800
); break;
5720 case 2100: return ((char *) HT_02100
); break;
5721 case 2400: return ((char *) HT_02400
); break;
5722 case 2410: return ((char *) HT_02410
); break;
5723 case 2500: return ((char *) HT_02500
); break;
5724 case 2600: return ((char *) HT_02600
); break;
5725 case 2611: return ((char *) HT_02611
); break;
5726 case 2612: return ((char *) HT_02612
); break;
5727 case 2711: return ((char *) HT_02711
); break;
5728 case 2811: return ((char *) HT_02811
); break;
5729 case 3000: return ((char *) HT_03000
); break;
5730 case 3100: return ((char *) HT_03100
); break;
5731 case 3200: return ((char *) HT_03200
); break;
5732 case 3710: return ((char *) HT_03710
); break;
5733 case 3711: return ((char *) HT_03711
); break;
5734 case 3800: return ((char *) HT_03800
); break;
5735 case 4300: return ((char *) HT_04300
); break;
5736 case 4400: return ((char *) HT_04400
); break;
5737 case 4500: return ((char *) HT_04500
); break;
5738 case 4700: return ((char *) HT_04700
); break;
5739 case 4800: return ((char *) HT_04800
); break;
5740 case 4900: return ((char *) HT_04900
); break;
5741 case 5000: return ((char *) HT_05000
); break;
5742 case 5100: return ((char *) HT_05100
); break;
5743 case 5200: return ((char *) HT_05200
); break;
5744 case 5300: return ((char *) HT_05300
); break;
5745 case 5400: return ((char *) HT_05400
); break;
5746 case 5500: return ((char *) HT_05500
); break;
5747 case 5600: return ((char *) HT_05600
); break;
5748 case 5700: return ((char *) HT_05700
); break;
5749 case 5800: return ((char *) HT_05800
); break;
5750 case 6000: return ((char *) HT_06000
); break;
5751 case 6100: return ((char *) HT_06100
); break;
5752 case 6211: return ((char *) HT_06211
); break;
5753 case 6212: return ((char *) HT_06212
); break;
5754 case 6213: return ((char *) HT_06213
); break;
5755 case 6221: return ((char *) HT_06221
); break;
5756 case 6222: return ((char *) HT_06222
); break;
5757 case 6223: return ((char *) HT_06223
); break;
5758 case 6231: return ((char *) HT_06231
); break;
5759 case 6232: return ((char *) HT_06232
); break;
5760 case 6233: return ((char *) HT_06233
); break;
5761 case 6241: return ((char *) HT_06241
); break;
5762 case 6242: return ((char *) HT_06242
); break;
5763 case 6243: return ((char *) HT_06243
); break;
5764 case 6300: return ((char *) HT_06300
); break;
5765 case 6400: return ((char *) HT_06400
); break;
5766 case 6500: return ((char *) HT_06500
); break;
5767 case 6600: return ((char *) HT_06600
); break;
5768 case 6700: return ((char *) HT_06700
); break;
5769 case 6800: return ((char *) HT_06800
); break;
5770 case 6900: return ((char *) HT_06900
); break;
5771 case 7100: return ((char *) HT_07100
); break;
5772 case 7200: return ((char *) HT_07200
); break;
5773 case 7300: return ((char *) HT_07300
); break;
5774 case 7400: return ((char *) HT_07400
); break;
5775 case 7500: return ((char *) HT_07500
); break;
5776 case 7600: return ((char *) HT_07600
); break;
5777 case 7700: return ((char *) HT_07700
); break;
5778 case 7800: return ((char *) HT_07800
); break;
5779 case 7900: return ((char *) HT_07900
); break;
5780 case 8000: return ((char *) HT_08000
); break;
5781 case 8100: return ((char *) HT_08100
); break;
5782 case 8200: return ((char *) HT_08200
); break;
5783 case 8300: return ((char *) HT_08300
); break;
5784 case 8400: return ((char *) HT_08400
); break;
5785 case 8500: return ((char *) HT_08500
); break;
5786 case 8600: return ((char *) HT_08600
); break;
5787 case 8700: return ((char *) HT_08700
); break;
5788 case 8800: return ((char *) HT_08800
); break;
5789 case 8900: return ((char *) HT_08900
); break;
5790 case 9000: return ((char *) HT_09000
); break;
5791 case 9100: return ((char *) HT_09100
); break;
5792 case 9200: return ((char *) HT_09200
); break;
5793 case 9300: return ((char *) HT_09300
); break;
5794 case 9400: return ((char *) HT_09400
); break;
5795 case 9500: return ((char *) HT_09500
); break;
5796 case 9600: return ((char *) HT_09600
); break;
5797 case 9700: return ((char *) HT_09700
); break;
5798 case 9710: return ((char *) HT_09710
); break;
5799 case 9720: return ((char *) HT_09720
); break;
5800 case 9800: return ((char *) HT_09800
); break;
5801 case 9810: return ((char *) HT_09810
); break;
5802 case 9820: return ((char *) HT_09820
); break;
5803 case 9900: return ((char *) HT_09900
); break;
5804 case 10000: return ((char *) HT_10000
); break;
5805 case 10100: return ((char *) HT_10100
); break;
5806 case 10200: return ((char *) HT_10200
); break;
5807 case 10300: return ((char *) HT_10300
); break;
5808 case 10400: return ((char *) HT_10400
); break;
5809 case 10410: return ((char *) HT_10410
); break;
5810 case 10420: return ((char *) HT_10420
); break;
5811 case 10500: return ((char *) HT_10500
); break;
5812 case 10600: return ((char *) HT_10600
); break;
5813 case 10700: return ((char *) HT_10700
); break;
5814 case 10800: return ((char *) HT_10800
); break;
5815 case 10900: return ((char *) HT_10900
); break;
5816 case 11000: return ((char *) HT_11000
); break;
5817 case 11100: return ((char *) HT_11100
); break;
5818 case 11200: return ((char *) HT_11200
); break;
5819 case 11300: return ((char *) HT_11300
); break;
5820 case 11400: return ((char *) HT_11400
); break;
5821 case 11500: return ((char *) HT_11500
); break;
5822 case 11600: return ((char *) HT_11600
); break;
5823 case 11700: return ((char *) HT_11700
); break;
5824 case 11800: return ((char *) HT_11800
); break;
5825 case 11900: return ((char *) HT_11900
); break;
5826 case 12000: return ((char *) HT_12000
); break;
5827 case 12100: return ((char *) HT_12100
); break;
5828 case 12200: return ((char *) HT_12200
); break;
5829 case 12300: return ((char *) HT_12300
); break;
5830 case 12400: return ((char *) HT_12400
); break;
5831 case 12500: return ((char *) HT_12500
); break;
5832 case 12600: return ((char *) HT_12600
); break;
5833 case 12700: return ((char *) HT_12700
); break;
5834 case 12800: return ((char *) HT_12800
); break;
5835 case 12900: return ((char *) HT_12900
); break;
5836 case 13000: return ((char *) HT_13000
); break;
5839 return ((char *) "Unknown");
5842 char *strstatus (const uint devices_status
)
5844 switch (devices_status
)
5846 case STATUS_INIT
: return ((char *) ST_0000
); break;
5847 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5848 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5849 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5850 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5851 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5852 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5853 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5854 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5855 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5856 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
5859 return ((char *) "Unknown");
5862 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5864 uint hash_type
= data
.hash_type
;
5865 uint hash_mode
= data
.hash_mode
;
5866 uint salt_type
= data
.salt_type
;
5867 uint opts_type
= data
.opts_type
;
5868 uint opti_type
= data
.opti_type
;
5869 uint dgst_size
= data
.dgst_size
;
5871 char *hashfile
= data
.hashfile
;
5875 uint digest_buf
[64] = { 0 };
5877 u64
*digest_buf64
= (u64
*) digest_buf
;
5879 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5881 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5883 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5889 case HASH_TYPE_DESCRYPT
:
5890 FP (digest_buf
[1], digest_buf
[0], tt
);
5893 case HASH_TYPE_DESRACF
:
5894 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5895 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5897 FP (digest_buf
[1], digest_buf
[0], tt
);
5901 FP (digest_buf
[1], digest_buf
[0], tt
);
5904 case HASH_TYPE_NETNTLM
:
5905 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5906 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5907 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5908 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5910 FP (digest_buf
[1], digest_buf
[0], tt
);
5911 FP (digest_buf
[3], digest_buf
[2], tt
);
5914 case HASH_TYPE_BSDICRYPT
:
5915 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5916 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5918 FP (digest_buf
[1], digest_buf
[0], tt
);
5923 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5928 digest_buf
[0] += MD4M_A
;
5929 digest_buf
[1] += MD4M_B
;
5930 digest_buf
[2] += MD4M_C
;
5931 digest_buf
[3] += MD4M_D
;
5935 digest_buf
[0] += MD5M_A
;
5936 digest_buf
[1] += MD5M_B
;
5937 digest_buf
[2] += MD5M_C
;
5938 digest_buf
[3] += MD5M_D
;
5941 case HASH_TYPE_SHA1
:
5942 digest_buf
[0] += SHA1M_A
;
5943 digest_buf
[1] += SHA1M_B
;
5944 digest_buf
[2] += SHA1M_C
;
5945 digest_buf
[3] += SHA1M_D
;
5946 digest_buf
[4] += SHA1M_E
;
5949 case HASH_TYPE_SHA256
:
5950 digest_buf
[0] += SHA256M_A
;
5951 digest_buf
[1] += SHA256M_B
;
5952 digest_buf
[2] += SHA256M_C
;
5953 digest_buf
[3] += SHA256M_D
;
5954 digest_buf
[4] += SHA256M_E
;
5955 digest_buf
[5] += SHA256M_F
;
5956 digest_buf
[6] += SHA256M_G
;
5957 digest_buf
[7] += SHA256M_H
;
5960 case HASH_TYPE_SHA384
:
5961 digest_buf64
[0] += SHA384M_A
;
5962 digest_buf64
[1] += SHA384M_B
;
5963 digest_buf64
[2] += SHA384M_C
;
5964 digest_buf64
[3] += SHA384M_D
;
5965 digest_buf64
[4] += SHA384M_E
;
5966 digest_buf64
[5] += SHA384M_F
;
5967 digest_buf64
[6] += 0;
5968 digest_buf64
[7] += 0;
5971 case HASH_TYPE_SHA512
:
5972 digest_buf64
[0] += SHA512M_A
;
5973 digest_buf64
[1] += SHA512M_B
;
5974 digest_buf64
[2] += SHA512M_C
;
5975 digest_buf64
[3] += SHA512M_D
;
5976 digest_buf64
[4] += SHA512M_E
;
5977 digest_buf64
[5] += SHA512M_F
;
5978 digest_buf64
[6] += SHA512M_G
;
5979 digest_buf64
[7] += SHA512M_H
;
5984 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
5986 if (dgst_size
== DGST_SIZE_4_2
)
5988 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5990 else if (dgst_size
== DGST_SIZE_4_4
)
5992 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5994 else if (dgst_size
== DGST_SIZE_4_5
)
5996 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5998 else if (dgst_size
== DGST_SIZE_4_6
)
6000 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6002 else if (dgst_size
== DGST_SIZE_4_8
)
6004 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6006 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6008 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6010 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6012 else if (hash_type
== HASH_TYPE_SHA384
)
6014 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6016 else if (hash_type
== HASH_TYPE_SHA512
)
6018 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6020 else if (hash_type
== HASH_TYPE_GOST
)
6022 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6025 else if (dgst_size
== DGST_SIZE_4_64
)
6027 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6029 else if (dgst_size
== DGST_SIZE_8_25
)
6031 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6035 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6036 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6037 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6043 memset (&salt
, 0, sizeof (salt_t
));
6045 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6047 char *ptr
= (char *) salt
.salt_buf
;
6049 uint len
= salt
.salt_len
;
6051 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6057 case HASH_TYPE_NETNTLM
:
6059 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6060 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6062 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6068 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6070 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6078 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6080 uint max
= salt
.salt_len
/ 4;
6084 for (uint i
= 0; i
< max
; i
++)
6086 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6090 if (opts_type
& OPTS_TYPE_ST_HEX
)
6092 char tmp
[64] = { 0 };
6094 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6096 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6101 memcpy (ptr
, tmp
, len
);
6104 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6106 memset (ptr
+ len
, 0, memset_size
);
6108 salt
.salt_len
= len
;
6112 // some modes require special encoding
6115 uint out_buf_plain
[256] = { 0 };
6116 uint out_buf_salt
[256] = { 0 };
6118 char tmp_buf
[1024] = { 0 };
6120 char *ptr_plain
= (char *) out_buf_plain
;
6121 char *ptr_salt
= (char *) out_buf_salt
;
6123 if (hash_mode
== 22)
6125 char username
[30] = { 0 };
6127 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6129 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6131 u16
*ptr
= (u16
*) digest_buf
;
6133 tmp_buf
[ 0] = sig
[0];
6134 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6135 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6136 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6137 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6138 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6139 tmp_buf
[ 6] = sig
[1];
6140 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6141 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6142 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6143 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6144 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6145 tmp_buf
[12] = sig
[2];
6146 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6147 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6148 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6149 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6150 tmp_buf
[17] = sig
[3];
6151 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6152 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6153 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6154 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6155 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6156 tmp_buf
[23] = sig
[4];
6157 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6158 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6159 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6160 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6161 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6162 tmp_buf
[29] = sig
[5];
6164 snprintf (out_buf
, len
-1, "%s:%s",
6168 else if (hash_mode
== 23)
6170 // do not show the \nskyper\n part in output
6172 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6174 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6176 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6183 else if (hash_mode
== 101)
6185 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6187 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6188 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6189 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6190 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6191 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6193 memcpy (tmp_buf
, digest_buf
, 20);
6195 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6197 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6199 else if (hash_mode
== 111)
6201 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6203 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6204 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6205 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6206 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6207 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6209 memcpy (tmp_buf
, digest_buf
, 20);
6210 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6212 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6214 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6216 else if (hash_mode
== 122)
6218 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6219 (char *) salt
.salt_buf
,
6226 else if (hash_mode
== 124)
6228 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6229 (char *) salt
.salt_buf
,
6236 else if (hash_mode
== 131)
6238 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6239 (char *) salt
.salt_buf
,
6247 else if (hash_mode
== 132)
6249 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6250 (char *) salt
.salt_buf
,
6257 else if (hash_mode
== 133)
6259 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6261 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6262 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6263 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6264 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6265 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6267 memcpy (tmp_buf
, digest_buf
, 20);
6269 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6271 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6273 else if (hash_mode
== 141)
6275 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6277 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6279 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6281 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6283 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6284 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6285 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6286 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6287 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6289 memcpy (tmp_buf
, digest_buf
, 20);
6291 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6295 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6297 else if (hash_mode
== 400)
6299 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6301 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6302 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6303 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6304 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6306 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6308 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6310 else if (hash_mode
== 500)
6312 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6314 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6315 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6316 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6317 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6319 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6321 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6323 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6327 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6330 else if (hash_mode
== 501)
6332 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6334 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6335 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6337 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6339 else if (hash_mode
== 1421)
6341 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6343 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6359 else if (hash_mode
== 1441)
6361 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6363 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6365 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6367 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6369 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6370 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6371 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6372 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6373 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6374 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6375 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6376 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6378 memcpy (tmp_buf
, digest_buf
, 32);
6380 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6384 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6386 else if (hash_mode
== 1500)
6388 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6389 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6390 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6391 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6392 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6394 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6396 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6398 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6399 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6401 memcpy (tmp_buf
, digest_buf
, 8);
6403 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6405 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6409 else if (hash_mode
== 1600)
6411 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6413 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6414 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6415 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6416 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6418 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6420 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6422 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6426 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6429 else if (hash_mode
== 1711)
6431 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6433 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6434 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6435 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6436 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6437 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6438 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6439 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6440 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6442 memcpy (tmp_buf
, digest_buf
, 64);
6443 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6445 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6447 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6449 else if (hash_mode
== 1722)
6451 uint
*ptr
= digest_buf
;
6453 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6454 (unsigned char *) salt
.salt_buf
,
6464 else if (hash_mode
== 1731)
6466 uint
*ptr
= digest_buf
;
6468 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6469 (unsigned char *) salt
.salt_buf
,
6479 else if (hash_mode
== 1800)
6483 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6484 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6485 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6486 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6487 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6488 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6489 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6490 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6492 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6494 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6496 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6500 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6503 else if (hash_mode
== 2100)
6507 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6509 salt
.salt_iter
+ 1);
6511 uint signature_len
= strlen (out_buf
);
6513 pos
+= signature_len
;
6514 len
-= signature_len
;
6516 char *salt_ptr
= (char *) salt
.salt_buf
;
6518 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6520 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6521 byte_swap_32 (digest_buf
[0]),
6522 byte_swap_32 (digest_buf
[1]),
6523 byte_swap_32 (digest_buf
[2]),
6524 byte_swap_32 (digest_buf
[3]));
6526 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6528 memcpy (tmp_buf
, digest_buf
, 16);
6530 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6532 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6533 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6534 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6535 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6537 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6538 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6539 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6540 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6542 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6543 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6544 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6545 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6547 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6548 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6549 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6550 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6552 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6553 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6554 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6555 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6559 else if (hash_mode
== 2500)
6561 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6563 wpa_t
*wpa
= &wpas
[salt_pos
];
6565 uint pke
[25] = { 0 };
6567 char *pke_ptr
= (char *) pke
;
6569 for (uint i
= 0; i
< 25; i
++)
6571 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6574 unsigned char mac1
[6] = { 0 };
6575 unsigned char mac2
[6] = { 0 };
6577 memcpy (mac1
, pke_ptr
+ 23, 6);
6578 memcpy (mac2
, pke_ptr
+ 29, 6);
6580 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6581 (char *) salt
.salt_buf
,
6595 else if (hash_mode
== 4400)
6597 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6598 byte_swap_32 (digest_buf
[0]),
6599 byte_swap_32 (digest_buf
[1]),
6600 byte_swap_32 (digest_buf
[2]),
6601 byte_swap_32 (digest_buf
[3]));
6603 else if (hash_mode
== 4700)
6605 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6606 byte_swap_32 (digest_buf
[0]),
6607 byte_swap_32 (digest_buf
[1]),
6608 byte_swap_32 (digest_buf
[2]),
6609 byte_swap_32 (digest_buf
[3]),
6610 byte_swap_32 (digest_buf
[4]));
6612 else if (hash_mode
== 4800)
6614 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6616 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6621 byte_swap_32 (salt
.salt_buf
[0]),
6622 byte_swap_32 (salt
.salt_buf
[1]),
6623 byte_swap_32 (salt
.salt_buf
[2]),
6624 byte_swap_32 (salt
.salt_buf
[3]),
6627 else if (hash_mode
== 4900)
6629 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6630 byte_swap_32 (digest_buf
[0]),
6631 byte_swap_32 (digest_buf
[1]),
6632 byte_swap_32 (digest_buf
[2]),
6633 byte_swap_32 (digest_buf
[3]),
6634 byte_swap_32 (digest_buf
[4]));
6636 else if (hash_mode
== 5100)
6638 snprintf (out_buf
, len
-1, "%08x%08x",
6642 else if (hash_mode
== 5200)
6644 snprintf (out_buf
, len
-1, "%s", hashfile
);
6646 else if (hash_mode
== 5300)
6648 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6650 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6652 int buf_len
= len
-1;
6656 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6658 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6660 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6662 snprintf (out_buf
, buf_len
, ":");
6668 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6676 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6678 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6680 if ((i
== 0) || (i
== 5))
6682 snprintf (out_buf
, buf_len
, ":");
6688 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6696 for (uint i
= 0; i
< 4; i
++)
6700 snprintf (out_buf
, buf_len
, ":");
6706 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6712 else if (hash_mode
== 5400)
6714 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6716 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6718 int buf_len
= len
-1;
6722 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6724 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6726 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6728 snprintf (out_buf
, buf_len
, ":");
6734 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6742 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6744 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6746 if ((i
== 0) || (i
== 5))
6748 snprintf (out_buf
, buf_len
, ":");
6754 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6762 for (uint i
= 0; i
< 5; i
++)
6766 snprintf (out_buf
, buf_len
, ":");
6772 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6778 else if (hash_mode
== 5500)
6780 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6782 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6784 char user_buf
[64] = { 0 };
6785 char domain_buf
[64] = { 0 };
6786 char srvchall_buf
[1024] = { 0 };
6787 char clichall_buf
[1024] = { 0 };
6789 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6791 char *ptr
= (char *) netntlm
->userdomain_buf
;
6793 user_buf
[i
] = ptr
[j
];
6796 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6798 char *ptr
= (char *) netntlm
->userdomain_buf
;
6800 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6803 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6805 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6807 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6810 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6812 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6814 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6817 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6825 byte_swap_32 (salt
.salt_buf_pc
[0]),
6826 byte_swap_32 (salt
.salt_buf_pc
[1]),
6829 else if (hash_mode
== 5600)
6831 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6833 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6835 char user_buf
[64] = { 0 };
6836 char domain_buf
[64] = { 0 };
6837 char srvchall_buf
[1024] = { 0 };
6838 char clichall_buf
[1024] = { 0 };
6840 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6842 char *ptr
= (char *) netntlm
->userdomain_buf
;
6844 user_buf
[i
] = ptr
[j
];
6847 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6849 char *ptr
= (char *) netntlm
->userdomain_buf
;
6851 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6854 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6856 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6858 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6861 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6863 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6865 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6868 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6878 else if (hash_mode
== 5700)
6880 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6882 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6883 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6884 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6885 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6886 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6887 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6888 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6889 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6891 memcpy (tmp_buf
, digest_buf
, 32);
6893 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6897 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6899 else if (hash_mode
== 5800)
6901 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6902 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6903 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6904 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6905 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6907 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6914 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6916 snprintf (out_buf
, len
-1, "%s", hashfile
);
6918 else if (hash_mode
== 6300)
6920 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6922 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6923 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6924 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6925 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6927 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6929 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6931 else if (hash_mode
== 6400)
6933 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6935 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6937 else if (hash_mode
== 6500)
6939 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6941 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6943 else if (hash_mode
== 6600)
6945 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6947 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6949 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6950 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6952 uint buf_len
= len
- 1;
6954 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6957 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6959 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6964 else if (hash_mode
== 6700)
6966 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6968 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6970 else if (hash_mode
== 6800)
6972 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6974 else if (hash_mode
== 7100)
6976 uint
*ptr
= digest_buf
;
6978 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6980 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6982 uint esalt
[8] = { 0 };
6984 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6985 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6986 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6987 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6988 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6989 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6990 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6991 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6993 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",
6994 SIGNATURE_SHA512OSX
,
6996 esalt
[ 0], esalt
[ 1],
6997 esalt
[ 2], esalt
[ 3],
6998 esalt
[ 4], esalt
[ 5],
6999 esalt
[ 6], esalt
[ 7],
7007 ptr
[15], ptr
[14]);
7009 else if (hash_mode
== 7200)
7011 uint
*ptr
= digest_buf
;
7013 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7015 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7019 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7021 len_used
= strlen (out_buf
);
7023 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7025 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7027 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7030 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",
7038 ptr
[15], ptr
[14]);
7040 else if (hash_mode
== 7300)
7042 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7044 rakp_t
*rakp
= &rakps
[salt_pos
];
7046 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7048 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7051 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7058 else if (hash_mode
== 7400)
7060 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7062 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7063 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7064 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7065 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7066 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7067 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7068 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7069 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7071 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7073 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7075 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7079 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7082 else if (hash_mode
== 7500)
7084 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7086 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7088 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7089 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7091 char data
[128] = { 0 };
7093 char *ptr_data
= data
;
7095 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7097 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7100 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7102 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7107 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7109 (char *) krb5pa
->user
,
7110 (char *) krb5pa
->realm
,
7111 (char *) krb5pa
->salt
,
7114 else if (hash_mode
== 7700)
7116 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7117 (char *) salt
.salt_buf
,
7121 else if (hash_mode
== 7800)
7123 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7124 (char *) salt
.salt_buf
,
7131 else if (hash_mode
== 7900)
7133 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7137 char *tmp
= (char *) salt
.salt_buf_pc
;
7139 ptr_plain
[42] = tmp
[0];
7145 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7147 else if (hash_mode
== 8000)
7149 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7150 (unsigned char *) salt
.salt_buf
,
7160 else if (hash_mode
== 8100)
7162 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7163 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7165 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7166 (unsigned char *) salt
.salt_buf
,
7173 else if (hash_mode
== 8200)
7175 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7177 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7179 char data_buf
[4096] = { 0 };
7181 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7183 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7186 data_buf
[cloudkey
->data_len
* 2] = 0;
7188 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7189 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7190 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7191 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7192 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7193 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7194 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7195 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7197 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7198 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7199 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7200 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7202 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7218 else if (hash_mode
== 8300)
7220 char digest_buf_c
[34] = { 0 };
7222 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7224 digest_buf_c
[32] = 0;
7228 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7230 char domain_buf_c
[33] = { 0 };
7232 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7234 for (uint i
= 0; i
< salt_pc_len
; i
++)
7236 const char next
= domain_buf_c
[i
];
7238 domain_buf_c
[i
] = '.';
7243 domain_buf_c
[salt_pc_len
] = 0;
7247 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7249 else if (hash_mode
== 8500)
7251 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7253 else if (hash_mode
== 2612)
7255 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7257 (char *) salt
.salt_buf
,
7263 else if (hash_mode
== 3711)
7265 char *salt_ptr
= (char *) salt
.salt_buf
;
7267 salt_ptr
[salt
.salt_len
- 1] = 0;
7269 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7270 SIGNATURE_MEDIAWIKI_B
,
7277 else if (hash_mode
== 8800)
7279 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7281 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7283 char tmp
[3073] = { 0 };
7285 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7287 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7292 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7293 SIGNATURE_ANDROIDFDE
,
7294 byte_swap_32 (salt
.salt_buf
[0]),
7295 byte_swap_32 (salt
.salt_buf
[1]),
7296 byte_swap_32 (salt
.salt_buf
[2]),
7297 byte_swap_32 (salt
.salt_buf
[3]),
7298 byte_swap_32 (digest_buf
[0]),
7299 byte_swap_32 (digest_buf
[1]),
7300 byte_swap_32 (digest_buf
[2]),
7301 byte_swap_32 (digest_buf
[3]),
7304 else if (hash_mode
== 8900)
7306 uint N
= salt
.scrypt_N
;
7307 uint r
= salt
.scrypt_r
;
7308 uint p
= salt
.scrypt_p
;
7310 char base64_salt
[32] = { 0 };
7312 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7314 memset (tmp_buf
, 0, 46);
7316 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7317 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7318 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7319 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7320 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7321 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7322 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7323 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7324 digest_buf
[8] = 0; // needed for base64_encode ()
7326 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7328 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7336 else if (hash_mode
== 9000)
7338 snprintf (out_buf
, len
-1, "%s", hashfile
);
7340 else if (hash_mode
== 9200)
7344 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7346 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7348 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7352 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7353 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7354 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7355 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7356 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7357 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7358 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7359 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7360 digest_buf
[8] = 0; // needed for base64_encode ()
7362 char tmp_buf
[64] = { 0 };
7364 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7365 tmp_buf
[43] = 0; // cut it here
7369 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7371 else if (hash_mode
== 9300)
7373 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7374 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7375 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7376 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7377 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7378 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7379 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7380 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7381 digest_buf
[8] = 0; // needed for base64_encode ()
7383 char tmp_buf
[64] = { 0 };
7385 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7386 tmp_buf
[43] = 0; // cut it here
7388 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7390 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7392 else if (hash_mode
== 9400)
7394 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7396 office2007_t
*office2007
= &office2007s
[salt_pos
];
7398 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7399 SIGNATURE_OFFICE2007
,
7402 office2007
->keySize
,
7408 office2007
->encryptedVerifier
[0],
7409 office2007
->encryptedVerifier
[1],
7410 office2007
->encryptedVerifier
[2],
7411 office2007
->encryptedVerifier
[3],
7412 office2007
->encryptedVerifierHash
[0],
7413 office2007
->encryptedVerifierHash
[1],
7414 office2007
->encryptedVerifierHash
[2],
7415 office2007
->encryptedVerifierHash
[3],
7416 office2007
->encryptedVerifierHash
[4]);
7418 else if (hash_mode
== 9500)
7420 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7422 office2010_t
*office2010
= &office2010s
[salt_pos
];
7424 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,
7430 office2010
->encryptedVerifier
[0],
7431 office2010
->encryptedVerifier
[1],
7432 office2010
->encryptedVerifier
[2],
7433 office2010
->encryptedVerifier
[3],
7434 office2010
->encryptedVerifierHash
[0],
7435 office2010
->encryptedVerifierHash
[1],
7436 office2010
->encryptedVerifierHash
[2],
7437 office2010
->encryptedVerifierHash
[3],
7438 office2010
->encryptedVerifierHash
[4],
7439 office2010
->encryptedVerifierHash
[5],
7440 office2010
->encryptedVerifierHash
[6],
7441 office2010
->encryptedVerifierHash
[7]);
7443 else if (hash_mode
== 9600)
7445 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7447 office2013_t
*office2013
= &office2013s
[salt_pos
];
7449 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,
7455 office2013
->encryptedVerifier
[0],
7456 office2013
->encryptedVerifier
[1],
7457 office2013
->encryptedVerifier
[2],
7458 office2013
->encryptedVerifier
[3],
7459 office2013
->encryptedVerifierHash
[0],
7460 office2013
->encryptedVerifierHash
[1],
7461 office2013
->encryptedVerifierHash
[2],
7462 office2013
->encryptedVerifierHash
[3],
7463 office2013
->encryptedVerifierHash
[4],
7464 office2013
->encryptedVerifierHash
[5],
7465 office2013
->encryptedVerifierHash
[6],
7466 office2013
->encryptedVerifierHash
[7]);
7468 else if (hash_mode
== 9700)
7470 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7472 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7474 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7475 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7476 byte_swap_32 (salt
.salt_buf
[0]),
7477 byte_swap_32 (salt
.salt_buf
[1]),
7478 byte_swap_32 (salt
.salt_buf
[2]),
7479 byte_swap_32 (salt
.salt_buf
[3]),
7480 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7481 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7482 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7483 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7484 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7485 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7486 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7487 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7489 else if (hash_mode
== 9710)
7491 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7493 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7495 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7496 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7497 byte_swap_32 (salt
.salt_buf
[0]),
7498 byte_swap_32 (salt
.salt_buf
[1]),
7499 byte_swap_32 (salt
.salt_buf
[2]),
7500 byte_swap_32 (salt
.salt_buf
[3]),
7501 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7502 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7503 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7504 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7505 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7506 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7507 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7508 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7510 else if (hash_mode
== 9720)
7512 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7514 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7516 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7518 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7519 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7520 byte_swap_32 (salt
.salt_buf
[0]),
7521 byte_swap_32 (salt
.salt_buf
[1]),
7522 byte_swap_32 (salt
.salt_buf
[2]),
7523 byte_swap_32 (salt
.salt_buf
[3]),
7524 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7525 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7526 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7527 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7528 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7529 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7530 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7531 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7538 else if (hash_mode
== 9800)
7540 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7542 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7544 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7545 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7550 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7551 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7552 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7553 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7554 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7555 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7556 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7557 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7558 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7560 else if (hash_mode
== 9810)
7562 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7564 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7566 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7567 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7572 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7573 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7574 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7575 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7576 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7577 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7578 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7579 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7580 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7582 else if (hash_mode
== 9820)
7584 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7586 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7588 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7590 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7591 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7596 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7597 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7598 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7599 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7600 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7601 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7602 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7603 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7604 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7611 else if (hash_mode
== 10000)
7615 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7617 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7619 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7623 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7624 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7625 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7626 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7627 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7628 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7629 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7630 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7631 digest_buf
[8] = 0; // needed for base64_encode ()
7633 char tmp_buf
[64] = { 0 };
7635 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7639 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7641 else if (hash_mode
== 10100)
7643 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7648 byte_swap_32 (salt
.salt_buf
[0]),
7649 byte_swap_32 (salt
.salt_buf
[1]),
7650 byte_swap_32 (salt
.salt_buf
[2]),
7651 byte_swap_32 (salt
.salt_buf
[3]));
7653 else if (hash_mode
== 10200)
7655 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7657 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7661 char challenge
[100] = { 0 };
7663 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7667 char tmp_buf
[100] = { 0 };
7669 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7670 (char *) cram_md5
->user
,
7676 char response
[100] = { 0 };
7678 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7680 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7682 else if (hash_mode
== 10300)
7684 char tmp_buf
[100] = { 0 };
7686 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7687 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7689 uint tmp_len
= 20 + salt
.salt_len
;
7693 char base64_encoded
[100] = { 0 };
7695 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7697 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7699 else if (hash_mode
== 10400)
7701 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7703 pdf_t
*pdf
= &pdfs
[salt_pos
];
7705 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",
7713 byte_swap_32 (pdf
->id_buf
[0]),
7714 byte_swap_32 (pdf
->id_buf
[1]),
7715 byte_swap_32 (pdf
->id_buf
[2]),
7716 byte_swap_32 (pdf
->id_buf
[3]),
7718 byte_swap_32 (pdf
->u_buf
[0]),
7719 byte_swap_32 (pdf
->u_buf
[1]),
7720 byte_swap_32 (pdf
->u_buf
[2]),
7721 byte_swap_32 (pdf
->u_buf
[3]),
7722 byte_swap_32 (pdf
->u_buf
[4]),
7723 byte_swap_32 (pdf
->u_buf
[5]),
7724 byte_swap_32 (pdf
->u_buf
[6]),
7725 byte_swap_32 (pdf
->u_buf
[7]),
7727 byte_swap_32 (pdf
->o_buf
[0]),
7728 byte_swap_32 (pdf
->o_buf
[1]),
7729 byte_swap_32 (pdf
->o_buf
[2]),
7730 byte_swap_32 (pdf
->o_buf
[3]),
7731 byte_swap_32 (pdf
->o_buf
[4]),
7732 byte_swap_32 (pdf
->o_buf
[5]),
7733 byte_swap_32 (pdf
->o_buf
[6]),
7734 byte_swap_32 (pdf
->o_buf
[7])
7737 else if (hash_mode
== 10410)
7739 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7741 pdf_t
*pdf
= &pdfs
[salt_pos
];
7743 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",
7751 byte_swap_32 (pdf
->id_buf
[0]),
7752 byte_swap_32 (pdf
->id_buf
[1]),
7753 byte_swap_32 (pdf
->id_buf
[2]),
7754 byte_swap_32 (pdf
->id_buf
[3]),
7756 byte_swap_32 (pdf
->u_buf
[0]),
7757 byte_swap_32 (pdf
->u_buf
[1]),
7758 byte_swap_32 (pdf
->u_buf
[2]),
7759 byte_swap_32 (pdf
->u_buf
[3]),
7760 byte_swap_32 (pdf
->u_buf
[4]),
7761 byte_swap_32 (pdf
->u_buf
[5]),
7762 byte_swap_32 (pdf
->u_buf
[6]),
7763 byte_swap_32 (pdf
->u_buf
[7]),
7765 byte_swap_32 (pdf
->o_buf
[0]),
7766 byte_swap_32 (pdf
->o_buf
[1]),
7767 byte_swap_32 (pdf
->o_buf
[2]),
7768 byte_swap_32 (pdf
->o_buf
[3]),
7769 byte_swap_32 (pdf
->o_buf
[4]),
7770 byte_swap_32 (pdf
->o_buf
[5]),
7771 byte_swap_32 (pdf
->o_buf
[6]),
7772 byte_swap_32 (pdf
->o_buf
[7])
7775 else if (hash_mode
== 10420)
7777 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7779 pdf_t
*pdf
= &pdfs
[salt_pos
];
7781 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7783 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",
7791 byte_swap_32 (pdf
->id_buf
[0]),
7792 byte_swap_32 (pdf
->id_buf
[1]),
7793 byte_swap_32 (pdf
->id_buf
[2]),
7794 byte_swap_32 (pdf
->id_buf
[3]),
7796 byte_swap_32 (pdf
->u_buf
[0]),
7797 byte_swap_32 (pdf
->u_buf
[1]),
7798 byte_swap_32 (pdf
->u_buf
[2]),
7799 byte_swap_32 (pdf
->u_buf
[3]),
7800 byte_swap_32 (pdf
->u_buf
[4]),
7801 byte_swap_32 (pdf
->u_buf
[5]),
7802 byte_swap_32 (pdf
->u_buf
[6]),
7803 byte_swap_32 (pdf
->u_buf
[7]),
7805 byte_swap_32 (pdf
->o_buf
[0]),
7806 byte_swap_32 (pdf
->o_buf
[1]),
7807 byte_swap_32 (pdf
->o_buf
[2]),
7808 byte_swap_32 (pdf
->o_buf
[3]),
7809 byte_swap_32 (pdf
->o_buf
[4]),
7810 byte_swap_32 (pdf
->o_buf
[5]),
7811 byte_swap_32 (pdf
->o_buf
[6]),
7812 byte_swap_32 (pdf
->o_buf
[7]),
7820 else if (hash_mode
== 10500)
7822 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7824 pdf_t
*pdf
= &pdfs
[salt_pos
];
7826 if (pdf
->id_len
== 32)
7828 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",
7836 byte_swap_32 (pdf
->id_buf
[0]),
7837 byte_swap_32 (pdf
->id_buf
[1]),
7838 byte_swap_32 (pdf
->id_buf
[2]),
7839 byte_swap_32 (pdf
->id_buf
[3]),
7840 byte_swap_32 (pdf
->id_buf
[4]),
7841 byte_swap_32 (pdf
->id_buf
[5]),
7842 byte_swap_32 (pdf
->id_buf
[6]),
7843 byte_swap_32 (pdf
->id_buf
[7]),
7845 byte_swap_32 (pdf
->u_buf
[0]),
7846 byte_swap_32 (pdf
->u_buf
[1]),
7847 byte_swap_32 (pdf
->u_buf
[2]),
7848 byte_swap_32 (pdf
->u_buf
[3]),
7849 byte_swap_32 (pdf
->u_buf
[4]),
7850 byte_swap_32 (pdf
->u_buf
[5]),
7851 byte_swap_32 (pdf
->u_buf
[6]),
7852 byte_swap_32 (pdf
->u_buf
[7]),
7854 byte_swap_32 (pdf
->o_buf
[0]),
7855 byte_swap_32 (pdf
->o_buf
[1]),
7856 byte_swap_32 (pdf
->o_buf
[2]),
7857 byte_swap_32 (pdf
->o_buf
[3]),
7858 byte_swap_32 (pdf
->o_buf
[4]),
7859 byte_swap_32 (pdf
->o_buf
[5]),
7860 byte_swap_32 (pdf
->o_buf
[6]),
7861 byte_swap_32 (pdf
->o_buf
[7])
7866 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",
7874 byte_swap_32 (pdf
->id_buf
[0]),
7875 byte_swap_32 (pdf
->id_buf
[1]),
7876 byte_swap_32 (pdf
->id_buf
[2]),
7877 byte_swap_32 (pdf
->id_buf
[3]),
7879 byte_swap_32 (pdf
->u_buf
[0]),
7880 byte_swap_32 (pdf
->u_buf
[1]),
7881 byte_swap_32 (pdf
->u_buf
[2]),
7882 byte_swap_32 (pdf
->u_buf
[3]),
7883 byte_swap_32 (pdf
->u_buf
[4]),
7884 byte_swap_32 (pdf
->u_buf
[5]),
7885 byte_swap_32 (pdf
->u_buf
[6]),
7886 byte_swap_32 (pdf
->u_buf
[7]),
7888 byte_swap_32 (pdf
->o_buf
[0]),
7889 byte_swap_32 (pdf
->o_buf
[1]),
7890 byte_swap_32 (pdf
->o_buf
[2]),
7891 byte_swap_32 (pdf
->o_buf
[3]),
7892 byte_swap_32 (pdf
->o_buf
[4]),
7893 byte_swap_32 (pdf
->o_buf
[5]),
7894 byte_swap_32 (pdf
->o_buf
[6]),
7895 byte_swap_32 (pdf
->o_buf
[7])
7899 else if (hash_mode
== 10600)
7901 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7903 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7904 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7906 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7908 else if (hash_mode
== 10700)
7910 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7912 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7913 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7915 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7917 else if (hash_mode
== 10900)
7919 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7921 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7922 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7924 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7926 else if (hash_mode
== 11100)
7928 u32 salt_challenge
= salt
.salt_buf
[0];
7930 salt_challenge
= byte_swap_32 (salt_challenge
);
7932 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7934 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7935 SIGNATURE_POSTGRESQL_AUTH
,
7943 else if (hash_mode
== 11200)
7945 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7946 SIGNATURE_MYSQL_AUTH
,
7947 (unsigned char *) salt
.salt_buf
,
7954 else if (hash_mode
== 11300)
7956 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7958 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7960 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7961 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7962 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7964 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7965 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7966 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7968 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7970 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7972 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7975 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7977 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7979 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7982 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7984 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
7986 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7989 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
7990 SIGNATURE_BITCOIN_WALLET
,
7994 (unsigned char *) salt
.salt_buf
,
8002 free (cry_master_buf
);
8004 free (public_key_buf
);
8006 else if (hash_mode
== 11400)
8008 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8010 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8011 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8013 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8015 else if (hash_mode
== 11600)
8017 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8019 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8021 const uint data_len
= seven_zip
->data_len
;
8023 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8025 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8027 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8029 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8032 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8033 SIGNATURE_SEVEN_ZIP
,
8037 (char *) seven_zip
->salt_buf
,
8039 seven_zip
->iv_buf
[0],
8040 seven_zip
->iv_buf
[1],
8041 seven_zip
->iv_buf
[2],
8042 seven_zip
->iv_buf
[3],
8044 seven_zip
->data_len
,
8045 seven_zip
->unpack_size
,
8050 else if (hash_mode
== 11700)
8052 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8062 else if (hash_mode
== 11800)
8064 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8082 else if (hash_mode
== 11900)
8084 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8086 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8087 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8089 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8091 else if (hash_mode
== 12000)
8093 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8095 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8096 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8098 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8100 else if (hash_mode
== 12100)
8102 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8104 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8105 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8107 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8109 else if (hash_mode
== 12200)
8111 uint
*ptr_digest
= digest_buf
;
8112 uint
*ptr_salt
= salt
.salt_buf
;
8114 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8121 else if (hash_mode
== 12300)
8123 uint
*ptr_digest
= digest_buf
;
8124 uint
*ptr_salt
= salt
.salt_buf
;
8126 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",
8127 ptr_digest
[ 0], ptr_digest
[ 1],
8128 ptr_digest
[ 2], ptr_digest
[ 3],
8129 ptr_digest
[ 4], ptr_digest
[ 5],
8130 ptr_digest
[ 6], ptr_digest
[ 7],
8131 ptr_digest
[ 8], ptr_digest
[ 9],
8132 ptr_digest
[10], ptr_digest
[11],
8133 ptr_digest
[12], ptr_digest
[13],
8134 ptr_digest
[14], ptr_digest
[15],
8140 else if (hash_mode
== 12400)
8142 // encode iteration count
8144 char salt_iter
[5] = { 0 };
8146 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8147 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8148 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8149 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8154 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8155 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8156 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8157 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8162 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8164 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8165 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8167 memcpy (tmp_buf
, digest_buf
, 8);
8169 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8173 // fill the resulting buffer
8175 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8177 else if (hash_mode
== 12500)
8179 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8181 byte_swap_32 (salt
.salt_buf
[0]),
8182 byte_swap_32 (salt
.salt_buf
[1]),
8188 else if (hash_mode
== 12600)
8190 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8191 digest_buf
[0] + salt
.salt_buf_pc
[0],
8192 digest_buf
[1] + salt
.salt_buf_pc
[1],
8193 digest_buf
[2] + salt
.salt_buf_pc
[2],
8194 digest_buf
[3] + salt
.salt_buf_pc
[3],
8195 digest_buf
[4] + salt
.salt_buf_pc
[4],
8196 digest_buf
[5] + salt
.salt_buf_pc
[5],
8197 digest_buf
[6] + salt
.salt_buf_pc
[6],
8198 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8200 else if (hash_mode
== 12700)
8202 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8204 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8205 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8207 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8209 else if (hash_mode
== 12800)
8211 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8213 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",
8226 byte_swap_32 (digest_buf
[0]),
8227 byte_swap_32 (digest_buf
[1]),
8228 byte_swap_32 (digest_buf
[2]),
8229 byte_swap_32 (digest_buf
[3]),
8230 byte_swap_32 (digest_buf
[4]),
8231 byte_swap_32 (digest_buf
[5]),
8232 byte_swap_32 (digest_buf
[6]),
8233 byte_swap_32 (digest_buf
[7])
8236 else if (hash_mode
== 12900)
8238 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",
8247 byte_swap_32 (digest_buf
[0]),
8248 byte_swap_32 (digest_buf
[1]),
8249 byte_swap_32 (digest_buf
[2]),
8250 byte_swap_32 (digest_buf
[3]),
8251 byte_swap_32 (digest_buf
[4]),
8252 byte_swap_32 (digest_buf
[5]),
8253 byte_swap_32 (digest_buf
[6]),
8254 byte_swap_32 (digest_buf
[7]),
8261 else if (hash_mode
== 13000)
8263 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8265 rar5_t
*rar5
= &rar5s
[salt_pos
];
8267 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8277 byte_swap_32 (digest_buf
[0]),
8278 byte_swap_32 (digest_buf
[1])
8283 if (hash_type
== HASH_TYPE_MD4
)
8285 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8291 else if (hash_type
== HASH_TYPE_MD5
)
8293 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8299 else if (hash_type
== HASH_TYPE_SHA1
)
8301 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8308 else if (hash_type
== HASH_TYPE_SHA256
)
8310 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8320 else if (hash_type
== HASH_TYPE_SHA384
)
8322 uint
*ptr
= digest_buf
;
8324 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8332 else if (hash_type
== HASH_TYPE_SHA512
)
8334 uint
*ptr
= digest_buf
;
8336 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8346 else if (hash_type
== HASH_TYPE_LM
)
8348 snprintf (out_buf
, len
-1, "%08x%08x",
8352 else if (hash_type
== HASH_TYPE_ORACLEH
)
8354 snprintf (out_buf
, len
-1, "%08X%08X",
8358 else if (hash_type
== HASH_TYPE_BCRYPT
)
8360 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8361 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8363 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8365 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8367 else if (hash_type
== HASH_TYPE_KECCAK
)
8369 uint
*ptr
= digest_buf
;
8371 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",
8399 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8401 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8403 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8410 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8412 digest_buf
[ 0] = digest_buf
[ 0];
8413 digest_buf
[ 1] = digest_buf
[ 1];
8414 digest_buf
[ 2] = digest_buf
[ 2];
8415 digest_buf
[ 3] = digest_buf
[ 3];
8416 digest_buf
[ 4] = digest_buf
[ 4];
8417 digest_buf
[ 5] = digest_buf
[ 5];
8418 digest_buf
[ 6] = digest_buf
[ 6];
8419 digest_buf
[ 7] = digest_buf
[ 7];
8420 digest_buf
[ 8] = digest_buf
[ 8];
8421 digest_buf
[ 9] = digest_buf
[ 9];
8422 digest_buf
[10] = digest_buf
[10];
8423 digest_buf
[11] = digest_buf
[11];
8424 digest_buf
[12] = digest_buf
[12];
8425 digest_buf
[13] = digest_buf
[13];
8426 digest_buf
[14] = digest_buf
[14];
8427 digest_buf
[15] = digest_buf
[15];
8429 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8447 else if (hash_type
== HASH_TYPE_GOST
)
8449 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8459 else if (hash_type
== HASH_TYPE_MYSQL
)
8461 snprintf (out_buf
, len
-1, "%08x%08x",
8465 else if (hash_type
== HASH_TYPE_LOTUS5
)
8467 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8473 else if (hash_type
== HASH_TYPE_LOTUS6
)
8475 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8476 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8477 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8478 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8480 char buf
[16] = { 0 };
8482 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8483 memcpy (buf
+ 5, digest_buf
, 9);
8487 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8489 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8492 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8494 else if (hash_type
== HASH_TYPE_LOTUS8
)
8496 char buf
[52] = { 0 };
8500 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8506 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8510 buf
[26] = salt
.salt_buf_pc
[0];
8511 buf
[27] = salt
.salt_buf_pc
[1];
8515 memcpy (buf
+ 28, digest_buf
, 8);
8517 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8521 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8523 else if (hash_type
== HASH_TYPE_CRC32
)
8525 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8529 if (salt_type
== SALT_TYPE_INTERN
)
8531 size_t pos
= strlen (out_buf
);
8533 out_buf
[pos
] = data
.separator
;
8535 char *ptr
= (char *) salt
.salt_buf
;
8537 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8539 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8543 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8545 memset (hccap
, 0, sizeof (hccap_t
));
8547 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8549 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8551 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8552 wpa_t
*wpa
= &wpas
[salt_pos
];
8554 hccap
->keyver
= wpa
->keyver
;
8556 hccap
->eapol_size
= wpa
->eapol_size
;
8558 if (wpa
->keyver
!= 1)
8560 uint eapol_tmp
[64] = { 0 };
8562 for (uint i
= 0; i
< 64; i
++)
8564 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8567 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8571 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8574 uint pke_tmp
[25] = { 0 };
8576 for (int i
= 5; i
< 25; i
++)
8578 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8581 char *pke_ptr
= (char *) pke_tmp
;
8583 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8584 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8585 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8586 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8588 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8590 uint dgst_size
= data
.dgst_size
;
8592 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8594 if (wpa
->keyver
!= 1)
8596 uint digest_tmp
[4] = { 0 };
8598 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8599 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8600 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8601 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8603 memcpy (hccap
->keymic
, digest_tmp
, 16);
8607 memcpy (hccap
->keymic
, digest_ptr
, 16);
8611 void SuspendThreads ()
8613 if (data
.devices_status
== STATUS_RUNNING
)
8615 hc_timer_set (&data
.timer_paused
);
8617 data
.devices_status
= STATUS_PAUSED
;
8619 log_info ("Paused");
8623 void ResumeThreads ()
8625 if (data
.devices_status
== STATUS_PAUSED
)
8629 hc_timer_get (data
.timer_paused
, ms_paused
);
8631 data
.ms_paused
+= ms_paused
;
8633 data
.devices_status
= STATUS_RUNNING
;
8635 log_info ("Resumed");
8641 if (data
.devices_status
!= STATUS_RUNNING
) return;
8643 data
.devices_status
= STATUS_BYPASS
;
8645 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8648 void stop_at_checkpoint ()
8650 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8652 if (data
.devices_status
!= STATUS_RUNNING
) return;
8655 // this feature only makes sense if --restore-disable was not specified
8657 if (data
.restore_disable
== 1)
8659 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8664 // check if monitoring of Restore Point updates should be enabled or disabled
8666 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8668 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8670 // save the current restore point value
8672 data
.checkpoint_cur_words
= get_lowest_words_done ();
8674 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8678 data
.devices_status
= STATUS_RUNNING
;
8680 // reset the global value for checkpoint checks
8682 data
.checkpoint_cur_words
= 0;
8684 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8690 if (data
.devices_status
== STATUS_INIT
) return;
8691 if (data
.devices_status
== STATUS_STARTING
) return;
8693 data
.devices_status
= STATUS_ABORTED
;
8698 if (data
.devices_status
== STATUS_INIT
) return;
8699 if (data
.devices_status
== STATUS_STARTING
) return;
8701 data
.devices_status
= STATUS_QUIT
;
8704 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8706 FILE *fp
= fopen (kernel_file
, "rb");
8712 memset (&st
, 0, sizeof (st
));
8714 stat (kernel_file
, &st
);
8716 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8718 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8720 if (num_read
!= (size_t) st
.st_size
)
8722 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8729 buf
[st
.st_size
] = 0;
8731 for (int i
= 0; i
< num_devices
; i
++)
8733 kernel_lengths
[i
] = (size_t) st
.st_size
;
8735 kernel_sources
[i
] = buf
;
8740 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8748 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8750 if (binary_size
> 0)
8752 FILE *fp
= fopen (dst
, "wb");
8755 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8766 restore_data_t
*init_restore (int argc
, char **argv
)
8768 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8770 if (data
.restore_disable
== 0)
8772 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8776 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8780 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8789 char pidbin
[BUFSIZ
] = { 0 };
8791 int pidbin_len
= -1;
8794 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8796 FILE *fd
= fopen (pidbin
, "rb");
8800 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8802 pidbin
[pidbin_len
] = 0;
8806 char *argv0_r
= strrchr (argv
[0], '/');
8808 char *pidbin_r
= strrchr (pidbin
, '/');
8810 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8812 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8814 if (strcmp (argv0_r
, pidbin_r
) == 0)
8816 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8823 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8825 char pidbin2
[BUFSIZ
] = { 0 };
8827 int pidbin2_len
= -1;
8829 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8830 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8832 pidbin
[pidbin_len
] = 0;
8833 pidbin2
[pidbin2_len
] = 0;
8837 if (strcmp (pidbin
, pidbin2
) == 0)
8839 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8847 if (rd
->version_bin
< RESTORE_MIN
)
8849 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8856 memset (rd
, 0, sizeof (restore_data_t
));
8858 rd
->version_bin
= VERSION_BIN
;
8861 rd
->pid
= getpid ();
8863 rd
->pid
= GetCurrentProcessId ();
8866 if (getcwd (rd
->cwd
, 255) == NULL
)
8879 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8881 FILE *fp
= fopen (eff_restore_file
, "rb");
8885 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8890 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8892 log_error ("ERROR: cannot read %s", eff_restore_file
);
8897 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8899 for (uint i
= 0; i
< rd
->argc
; i
++)
8901 char buf
[BUFSIZ
] = { 0 };
8903 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8905 log_error ("ERROR: cannot read %s", eff_restore_file
);
8910 size_t len
= strlen (buf
);
8912 if (len
) buf
[len
- 1] = 0;
8914 rd
->argv
[i
] = mystrdup (buf
);
8919 char new_cwd
[1024] = { 0 };
8921 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8925 log_error ("Restore file is corrupted");
8928 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8930 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8932 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8937 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8940 if (chdir (rd
->cwd
))
8942 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8948 u64
get_lowest_words_done ()
8952 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8954 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8956 if (device_param
->skipped
) continue;
8958 const u64 words_done
= device_param
->words_done
;
8960 if (words_done
< words_cur
) words_cur
= words_done
;
8963 // It's possible that a device's workload isn't finished right after a restore-case.
8964 // In that case, this function would return 0 and overwrite the real restore point
8965 // There's also data.words_cur which is set to rd->words_cur but it changes while
8966 // the attack is running therefore we should stick to rd->words_cur.
8967 // Note that -s influences rd->words_cur we should keep a close look on that.
8969 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
8974 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
8976 u64 words_cur
= get_lowest_words_done ();
8978 rd
->words_cur
= words_cur
;
8980 FILE *fp
= fopen (new_restore_file
, "wb");
8984 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
8989 if (setvbuf (fp
, NULL
, _IONBF
, 0))
8991 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
8996 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
8998 for (uint i
= 0; i
< rd
->argc
; i
++)
9000 fprintf (fp
, "%s", rd
->argv
[i
]);
9006 fsync (fileno (fp
));
9011 void cycle_restore ()
9013 const char *eff_restore_file
= data
.eff_restore_file
;
9014 const char *new_restore_file
= data
.new_restore_file
;
9016 restore_data_t
*rd
= data
.rd
;
9018 write_restore (new_restore_file
, rd
);
9022 memset (&st
, 0, sizeof(st
));
9024 if (stat (eff_restore_file
, &st
) == 0)
9026 if (unlink (eff_restore_file
))
9028 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9032 if (rename (new_restore_file
, eff_restore_file
))
9034 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9038 void check_checkpoint ()
9040 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9042 u64 words_cur
= get_lowest_words_done ();
9044 if (words_cur
!= data
.checkpoint_cur_words
)
9054 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9058 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9060 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9062 myfree (alias
->device_name
);
9063 myfree (alias
->alias_name
);
9066 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9068 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9070 myfree (entry
->device_name
);
9073 myfree (tuning_db
->alias_buf
);
9074 myfree (tuning_db
->entry_buf
);
9079 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9081 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9083 int num_lines
= count_lines (fp
);
9085 // a bit over-allocated
9087 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9088 tuning_db
->alias_cnt
= 0;
9090 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9091 tuning_db
->entry_cnt
= 0;
9096 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9098 FILE *fp
= fopen (tuning_db_file
, "rb");
9102 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9107 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9117 char *line_buf
= fgets (buf
, sizeof (buf
) - 1, fp
);
9119 if (line_buf
== NULL
) break;
9123 const int line_len
= in_superchop (line_buf
);
9125 if (line_len
== 0) continue;
9127 if (line_buf
[0] == '#') continue;
9131 char *token_ptr
[7] = { NULL
};
9135 char *next
= strtok (line_buf
, "\t ");
9137 token_ptr
[token_cnt
] = next
;
9141 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9143 token_ptr
[token_cnt
] = next
;
9150 char *device_name
= token_ptr
[0];
9151 char *alias_name
= token_ptr
[1];
9153 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9155 alias
->device_name
= mystrdup (device_name
);
9156 alias
->alias_name
= mystrdup (alias_name
);
9158 tuning_db
->alias_cnt
++;
9160 else if (token_cnt
== 6)
9162 if ((token_ptr
[1][0] != '0') &&
9163 (token_ptr
[1][0] != '1') &&
9164 (token_ptr
[1][0] != '3') &&
9165 (token_ptr
[1][0] != '*'))
9167 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9172 if ((token_ptr
[3][0] != '1') &&
9173 (token_ptr
[3][0] != '2') &&
9174 (token_ptr
[3][0] != '4') &&
9175 (token_ptr
[3][0] != '8') &&
9176 (token_ptr
[3][0] != 'N'))
9178 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9183 char *device_name
= token_ptr
[0];
9185 int attack_mode
= -1;
9187 int vector_width
= -1;
9188 int kernel_accel
= -1;
9189 int kernel_loops
= -1;
9191 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9192 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9193 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9195 if (token_ptr
[4][0] != 'A')
9197 kernel_accel
= atoi (token_ptr
[4]);
9199 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9201 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9211 if (token_ptr
[5][0] != 'A')
9213 kernel_loops
= atoi (token_ptr
[5]);
9215 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9217 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9227 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9229 entry
->device_name
= mystrdup (device_name
);
9230 entry
->attack_mode
= attack_mode
;
9231 entry
->hash_type
= hash_type
;
9232 entry
->vector_width
= vector_width
;
9233 entry
->kernel_accel
= kernel_accel
;
9234 entry
->kernel_loops
= kernel_loops
;
9236 tuning_db
->entry_cnt
++;
9240 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9248 // todo: print loaded 'cnt' message
9250 // sort the database
9252 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9253 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9258 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, char *device_name
, int attack_mode
, int hash_type
)
9260 static tuning_db_entry_t s
;
9262 // first we need to convert all spaces in the device_name to underscore
9264 char *device_name_nospace
= strdup (device_name
);
9266 int device_name_length
= strlen (device_name_nospace
);
9270 for (i
= 0; i
< device_name_length
; i
++)
9272 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9275 // find out if there's an alias configured
9277 tuning_db_alias_t a
;
9279 a
.device_name
= device_name_nospace
;
9281 tuning_db_alias_t
*alias
= bsearch (&a
, tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9283 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9285 // attack-mode 6 and 7 are attack-mode 1 basically
9287 if (attack_mode
== 6) attack_mode
= 1;
9288 if (attack_mode
== 7) attack_mode
= 1;
9290 // bsearch is not ideal but fast enough
9292 s
.device_name
= device_name_nospace
;
9293 s
.attack_mode
= attack_mode
;
9294 s
.hash_type
= hash_type
;
9296 tuning_db_entry_t
*entry
= NULL
;
9298 // this will produce all 2^3 combinations required
9300 for (i
= 0; i
< 8; i
++)
9302 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9303 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9304 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9306 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9308 if (entry
!= NULL
) break;
9310 // in non-wildcard mode also check the alias_name
9312 if (((i
& 1) == 0) && (alias_name
!= NULL
))
9314 s
.device_name
= alias_name
;
9316 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9318 if (entry
!= NULL
) break;
9322 // free converted device_name
9324 myfree (device_name_nospace
);
9333 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9335 u8 tmp
[256] = { 0 };
9337 if (salt_len
> sizeof (tmp
))
9342 memcpy (tmp
, in
, salt_len
);
9344 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9346 if ((salt_len
% 2) == 0)
9348 u32 new_salt_len
= salt_len
/ 2;
9350 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9355 tmp
[i
] = hex_convert (p1
) << 0;
9356 tmp
[i
] |= hex_convert (p0
) << 4;
9359 salt_len
= new_salt_len
;
9366 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9368 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9371 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9373 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9377 u32
*tmp_uint
= (u32
*) tmp
;
9379 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9380 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9381 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9382 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9383 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9384 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9385 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9386 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9387 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9388 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9390 salt_len
= salt_len
* 2;
9398 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9400 lowercase (tmp
, salt_len
);
9403 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9405 uppercase (tmp
, salt_len
);
9410 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9415 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9420 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9422 u32
*tmp_uint
= (uint
*) tmp
;
9428 for (u32 i
= 0; i
< max
; i
++)
9430 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9433 // Important: we may need to increase the length of memcpy since
9434 // we don't want to "loose" some swapped bytes (could happen if
9435 // they do not perfectly fit in the 4-byte blocks)
9436 // Memcpy does always copy the bytes in the BE order, but since
9437 // we swapped them, some important bytes could be in positions
9438 // we normally skip with the original len
9440 if (len
% 4) len
+= 4 - (len
% 4);
9443 memcpy (out
, tmp
, len
);
9448 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9450 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9452 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9454 u32
*digest
= (u32
*) hash_buf
->digest
;
9456 salt_t
*salt
= hash_buf
->salt
;
9458 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9460 char *iter_pos
= input_buf
+ 4;
9462 salt
->salt_iter
= 1 << atoi (iter_pos
);
9464 char *salt_pos
= strchr (iter_pos
, '$');
9466 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9472 salt
->salt_len
= salt_len
;
9474 u8 tmp_buf
[100] = { 0 };
9476 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9478 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9480 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9482 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9483 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9484 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9485 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9487 char *hash_pos
= salt_pos
+ 22;
9489 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9491 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9493 memcpy (digest
, tmp_buf
, 24);
9495 digest
[0] = byte_swap_32 (digest
[0]);
9496 digest
[1] = byte_swap_32 (digest
[1]);
9497 digest
[2] = byte_swap_32 (digest
[2]);
9498 digest
[3] = byte_swap_32 (digest
[3]);
9499 digest
[4] = byte_swap_32 (digest
[4]);
9500 digest
[5] = byte_swap_32 (digest
[5]);
9502 digest
[5] &= ~0xff; // its just 23 not 24 !
9507 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9509 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9511 u32
*digest
= (u32
*) hash_buf
->digest
;
9513 u8 tmp_buf
[100] = { 0 };
9515 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9517 memcpy (digest
, tmp_buf
, 32);
9519 digest
[0] = byte_swap_32 (digest
[0]);
9520 digest
[1] = byte_swap_32 (digest
[1]);
9521 digest
[2] = byte_swap_32 (digest
[2]);
9522 digest
[3] = byte_swap_32 (digest
[3]);
9523 digest
[4] = byte_swap_32 (digest
[4]);
9524 digest
[5] = byte_swap_32 (digest
[5]);
9525 digest
[6] = byte_swap_32 (digest
[6]);
9526 digest
[7] = byte_swap_32 (digest
[7]);
9528 digest
[0] -= SHA256M_A
;
9529 digest
[1] -= SHA256M_B
;
9530 digest
[2] -= SHA256M_C
;
9531 digest
[3] -= SHA256M_D
;
9532 digest
[4] -= SHA256M_E
;
9533 digest
[5] -= SHA256M_F
;
9534 digest
[6] -= SHA256M_G
;
9535 digest
[7] -= SHA256M_H
;
9540 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9542 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9544 u32
*digest
= (u32
*) hash_buf
->digest
;
9546 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9547 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9549 digest
[0] = byte_swap_32 (digest
[0]);
9550 digest
[1] = byte_swap_32 (digest
[1]);
9554 IP (digest
[0], digest
[1], tt
);
9556 digest
[0] = digest
[0];
9557 digest
[1] = digest
[1];
9564 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9566 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9568 u32
*digest
= (u32
*) hash_buf
->digest
;
9570 salt_t
*salt
= hash_buf
->salt
;
9572 char *hash_pos
= input_buf
+ 8;
9574 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9575 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9576 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9577 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9578 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9580 digest
[0] -= SHA1M_A
;
9581 digest
[1] -= SHA1M_B
;
9582 digest
[2] -= SHA1M_C
;
9583 digest
[3] -= SHA1M_D
;
9584 digest
[4] -= SHA1M_E
;
9588 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9590 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9592 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9594 salt
->salt_len
= salt_len
;
9599 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9601 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9603 u64
*digest
= (u64
*) hash_buf
->digest
;
9605 salt_t
*salt
= hash_buf
->salt
;
9607 char *hash_pos
= input_buf
+ 8;
9609 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9610 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9611 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9612 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9613 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9614 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9615 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9616 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9618 digest
[0] -= SHA512M_A
;
9619 digest
[1] -= SHA512M_B
;
9620 digest
[2] -= SHA512M_C
;
9621 digest
[3] -= SHA512M_D
;
9622 digest
[4] -= SHA512M_E
;
9623 digest
[5] -= SHA512M_F
;
9624 digest
[6] -= SHA512M_G
;
9625 digest
[7] -= SHA512M_H
;
9629 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9631 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9633 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9635 salt
->salt_len
= salt_len
;
9640 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9642 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9644 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9648 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9651 u32
*digest
= (u32
*) hash_buf
->digest
;
9653 salt_t
*salt
= hash_buf
->salt
;
9655 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9656 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9657 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9658 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9660 digest
[0] = byte_swap_32 (digest
[0]);
9661 digest
[1] = byte_swap_32 (digest
[1]);
9662 digest
[2] = byte_swap_32 (digest
[2]);
9663 digest
[3] = byte_swap_32 (digest
[3]);
9665 digest
[0] -= MD5M_A
;
9666 digest
[1] -= MD5M_B
;
9667 digest
[2] -= MD5M_C
;
9668 digest
[3] -= MD5M_D
;
9670 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9672 uint salt_len
= input_len
- 32 - 1;
9674 char *salt_buf
= input_buf
+ 32 + 1;
9676 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9678 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9680 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9682 salt
->salt_len
= salt_len
;
9687 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9689 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9691 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9695 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9700 char clean_input_buf
[32] = { 0 };
9702 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9703 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9705 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9709 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9715 clean_input_buf
[k
] = input_buf
[i
];
9723 u32
*digest
= (u32
*) hash_buf
->digest
;
9725 salt_t
*salt
= hash_buf
->salt
;
9727 u32 a
, b
, c
, d
, e
, f
;
9729 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9730 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9731 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9732 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9733 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9734 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9736 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9737 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9739 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9740 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9741 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9742 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9743 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9744 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9746 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9747 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9749 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9750 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9751 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9752 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9753 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9754 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9756 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9757 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9759 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9760 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9761 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9762 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9763 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9764 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9766 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9767 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9769 digest
[0] = byte_swap_32 (digest
[0]);
9770 digest
[1] = byte_swap_32 (digest
[1]);
9771 digest
[2] = byte_swap_32 (digest
[2]);
9772 digest
[3] = byte_swap_32 (digest
[3]);
9774 digest
[0] -= MD5M_A
;
9775 digest
[1] -= MD5M_B
;
9776 digest
[2] -= MD5M_C
;
9777 digest
[3] -= MD5M_D
;
9779 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9781 uint salt_len
= input_len
- 30 - 1;
9783 char *salt_buf
= input_buf
+ 30 + 1;
9785 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9787 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9789 // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
9790 if (salt_len
> 10) return (PARSER_SALT_LENGTH
);
9792 salt
->salt_len
= salt_len
;
9794 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9796 salt
->salt_len
+= 22;
9801 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9803 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9805 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9809 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9812 u32
*digest
= (u32
*) hash_buf
->digest
;
9814 salt_t
*salt
= hash_buf
->salt
;
9816 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9817 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9818 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9819 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9820 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
9822 digest
[0] -= SHA1M_A
;
9823 digest
[1] -= SHA1M_B
;
9824 digest
[2] -= SHA1M_C
;
9825 digest
[3] -= SHA1M_D
;
9826 digest
[4] -= SHA1M_E
;
9828 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9830 uint salt_len
= input_len
- 40 - 1;
9832 char *salt_buf
= input_buf
+ 40 + 1;
9834 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9836 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9838 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9840 salt
->salt_len
= salt_len
;
9845 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9847 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9849 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9853 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9856 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9858 char *iter_pos
= input_buf
+ 6;
9860 salt_t
*salt
= hash_buf
->salt
;
9862 uint iter
= atoi (iter_pos
);
9869 salt
->salt_iter
= iter
- 1;
9871 char *salt_pos
= strchr (iter_pos
, '#');
9873 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9877 char *digest_pos
= strchr (salt_pos
, '#');
9879 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9883 uint salt_len
= digest_pos
- salt_pos
- 1;
9885 u32
*digest
= (u32
*) hash_buf
->digest
;
9887 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
9888 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
9889 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
9890 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
9892 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9894 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9896 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9898 salt
->salt_len
= salt_len
;
9903 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9905 u32
*digest
= (u32
*) hash_buf
->digest
;
9907 salt_t
*salt
= hash_buf
->salt
;
9909 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
9913 memcpy (&in
, input_buf
, input_len
);
9915 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
9917 memcpy (digest
, in
.keymic
, 16);
9920 http://www.one-net.eu/jsw/j_sec/m_ptype.html
9921 The phrase "Pairwise key expansion"
9922 Access Point Address (referred to as Authenticator Address AA)
9923 Supplicant Address (referred to as Supplicant Address SA)
9924 Access Point Nonce (referred to as Authenticator Anonce)
9925 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
9928 uint salt_len
= strlen (in
.essid
);
9930 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
9932 salt
->salt_len
= salt_len
;
9934 salt
->salt_iter
= ROUNDS_WPA2
- 1;
9936 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
9938 memcpy (pke_ptr
, "Pairwise key expansion", 23);
9940 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
9942 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
9943 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
9947 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
9948 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
9951 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
9953 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
9954 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
9958 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
9959 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
9962 for (int i
= 0; i
< 25; i
++)
9964 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
9967 wpa
->keyver
= in
.keyver
;
9969 if (wpa
->keyver
> 255)
9971 log_info ("ATTENTION!");
9972 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
9973 log_info (" This could be due to a recent aircrack-ng bug.");
9974 log_info (" The key version was automatically reset to a reasonable value.");
9977 wpa
->keyver
&= 0xff;
9980 wpa
->eapol_size
= in
.eapol_size
;
9982 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
9984 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
9986 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
9988 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
9990 if (wpa
->keyver
== 1)
9996 digest
[0] = byte_swap_32 (digest
[0]);
9997 digest
[1] = byte_swap_32 (digest
[1]);
9998 digest
[2] = byte_swap_32 (digest
[2]);
9999 digest
[3] = byte_swap_32 (digest
[3]);
10001 for (int i
= 0; i
< 64; i
++)
10003 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10007 salt
->salt_buf
[10] = digest
[1];
10008 salt
->salt_buf
[11] = digest
[2];
10010 return (PARSER_OK
);
10013 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10015 u32
*digest
= (u32
*) hash_buf
->digest
;
10017 salt_t
*salt
= hash_buf
->salt
;
10019 if (input_len
== 0)
10021 log_error ("Password Safe v2 container not specified");
10026 FILE *fp
= fopen (input_buf
, "rb");
10030 log_error ("%s: %s", input_buf
, strerror (errno
));
10037 memset (&buf
, 0, sizeof (psafe2_hdr
));
10039 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10043 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10045 salt
->salt_buf
[0] = buf
.random
[0];
10046 salt
->salt_buf
[1] = buf
.random
[1];
10048 salt
->salt_len
= 8;
10049 salt
->salt_iter
= 1000;
10051 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10052 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10053 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10054 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10055 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10057 return (PARSER_OK
);
10060 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10062 u32
*digest
= (u32
*) hash_buf
->digest
;
10064 salt_t
*salt
= hash_buf
->salt
;
10066 if (input_len
== 0)
10068 log_error (".psafe3 not specified");
10073 FILE *fp
= fopen (input_buf
, "rb");
10077 log_error ("%s: %s", input_buf
, strerror (errno
));
10084 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10088 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10090 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10092 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10094 salt
->salt_iter
= in
.iterations
+ 1;
10096 salt
->salt_buf
[0] = in
.salt_buf
[0];
10097 salt
->salt_buf
[1] = in
.salt_buf
[1];
10098 salt
->salt_buf
[2] = in
.salt_buf
[2];
10099 salt
->salt_buf
[3] = in
.salt_buf
[3];
10100 salt
->salt_buf
[4] = in
.salt_buf
[4];
10101 salt
->salt_buf
[5] = in
.salt_buf
[5];
10102 salt
->salt_buf
[6] = in
.salt_buf
[6];
10103 salt
->salt_buf
[7] = in
.salt_buf
[7];
10105 salt
->salt_len
= 32;
10107 digest
[0] = in
.hash_buf
[0];
10108 digest
[1] = in
.hash_buf
[1];
10109 digest
[2] = in
.hash_buf
[2];
10110 digest
[3] = in
.hash_buf
[3];
10111 digest
[4] = in
.hash_buf
[4];
10112 digest
[5] = in
.hash_buf
[5];
10113 digest
[6] = in
.hash_buf
[6];
10114 digest
[7] = in
.hash_buf
[7];
10116 digest
[0] = byte_swap_32 (digest
[0]);
10117 digest
[1] = byte_swap_32 (digest
[1]);
10118 digest
[2] = byte_swap_32 (digest
[2]);
10119 digest
[3] = byte_swap_32 (digest
[3]);
10120 digest
[4] = byte_swap_32 (digest
[4]);
10121 digest
[5] = byte_swap_32 (digest
[5]);
10122 digest
[6] = byte_swap_32 (digest
[6]);
10123 digest
[7] = byte_swap_32 (digest
[7]);
10125 return (PARSER_OK
);
10128 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10130 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10132 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10134 u32
*digest
= (u32
*) hash_buf
->digest
;
10136 salt_t
*salt
= hash_buf
->salt
;
10138 char *iter_pos
= input_buf
+ 3;
10140 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10142 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10144 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10146 salt
->salt_iter
= salt_iter
;
10148 char *salt_pos
= iter_pos
+ 1;
10152 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10154 salt
->salt_len
= salt_len
;
10156 char *hash_pos
= salt_pos
+ salt_len
;
10158 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10160 return (PARSER_OK
);
10163 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10165 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10167 u32
*digest
= (u32
*) hash_buf
->digest
;
10169 salt_t
*salt
= hash_buf
->salt
;
10171 char *salt_pos
= input_buf
+ 3;
10173 uint iterations_len
= 0;
10175 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10179 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10181 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10182 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10186 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10190 iterations_len
+= 8;
10194 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10197 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10199 char *hash_pos
= strchr (salt_pos
, '$');
10201 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10203 uint salt_len
= hash_pos
- salt_pos
;
10205 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10207 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10209 salt
->salt_len
= salt_len
;
10213 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10215 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10217 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10219 return (PARSER_OK
);
10222 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10224 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10226 u32
*digest
= (u32
*) hash_buf
->digest
;
10228 salt_t
*salt
= hash_buf
->salt
;
10230 char *salt_pos
= input_buf
+ 6;
10232 uint iterations_len
= 0;
10234 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10238 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10240 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10241 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10245 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10249 iterations_len
+= 8;
10253 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10256 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10258 char *hash_pos
= strchr (salt_pos
, '$');
10260 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10262 uint salt_len
= hash_pos
- salt_pos
;
10264 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10266 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10268 salt
->salt_len
= salt_len
;
10272 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10274 return (PARSER_OK
);
10277 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10279 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10281 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10283 u32
*digest
= (u32
*) hash_buf
->digest
;
10285 salt_t
*salt
= hash_buf
->salt
;
10287 char *salt_pos
= input_buf
+ 14;
10289 char *hash_pos
= strchr (salt_pos
, '*');
10291 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10295 uint salt_len
= hash_pos
- salt_pos
- 1;
10297 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10299 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10301 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10303 salt
->salt_len
= salt_len
;
10305 u8 tmp_buf
[100] = { 0 };
10307 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10309 memcpy (digest
, tmp_buf
, 20);
10311 digest
[0] = byte_swap_32 (digest
[0]);
10312 digest
[1] = byte_swap_32 (digest
[1]);
10313 digest
[2] = byte_swap_32 (digest
[2]);
10314 digest
[3] = byte_swap_32 (digest
[3]);
10315 digest
[4] = byte_swap_32 (digest
[4]);
10317 digest
[0] -= SHA1M_A
;
10318 digest
[1] -= SHA1M_B
;
10319 digest
[2] -= SHA1M_C
;
10320 digest
[3] -= SHA1M_D
;
10321 digest
[4] -= SHA1M_E
;
10323 return (PARSER_OK
);
10326 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10328 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10330 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10332 if (c12
& 3) return (PARSER_HASH_VALUE
);
10334 u32
*digest
= (u32
*) hash_buf
->digest
;
10336 salt_t
*salt
= hash_buf
->salt
;
10338 // for ascii_digest
10339 salt
->salt_sign
[0] = input_buf
[0];
10340 salt
->salt_sign
[1] = input_buf
[1];
10342 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10343 | itoa64_to_int (input_buf
[1]) << 6;
10345 salt
->salt_len
= 2;
10347 u8 tmp_buf
[100] = { 0 };
10349 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10351 memcpy (digest
, tmp_buf
, 8);
10355 IP (digest
[0], digest
[1], tt
);
10360 return (PARSER_OK
);
10363 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10365 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10367 u32
*digest
= (u32
*) hash_buf
->digest
;
10369 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10370 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10371 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10372 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10374 digest
[0] = byte_swap_32 (digest
[0]);
10375 digest
[1] = byte_swap_32 (digest
[1]);
10376 digest
[2] = byte_swap_32 (digest
[2]);
10377 digest
[3] = byte_swap_32 (digest
[3]);
10379 digest
[0] -= MD4M_A
;
10380 digest
[1] -= MD4M_B
;
10381 digest
[2] -= MD4M_C
;
10382 digest
[3] -= MD4M_D
;
10384 return (PARSER_OK
);
10387 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10389 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10391 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10395 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10398 u32
*digest
= (u32
*) hash_buf
->digest
;
10400 salt_t
*salt
= hash_buf
->salt
;
10402 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10403 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10404 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10405 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10407 digest
[0] = byte_swap_32 (digest
[0]);
10408 digest
[1] = byte_swap_32 (digest
[1]);
10409 digest
[2] = byte_swap_32 (digest
[2]);
10410 digest
[3] = byte_swap_32 (digest
[3]);
10412 digest
[0] -= MD4M_A
;
10413 digest
[1] -= MD4M_B
;
10414 digest
[2] -= MD4M_C
;
10415 digest
[3] -= MD4M_D
;
10417 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10419 uint salt_len
= input_len
- 32 - 1;
10421 char *salt_buf
= input_buf
+ 32 + 1;
10423 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10425 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10427 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10429 salt
->salt_len
= salt_len
;
10431 return (PARSER_OK
);
10434 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10436 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10438 u32
*digest
= (u32
*) hash_buf
->digest
;
10440 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10441 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10442 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10443 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10445 digest
[0] = byte_swap_32 (digest
[0]);
10446 digest
[1] = byte_swap_32 (digest
[1]);
10447 digest
[2] = byte_swap_32 (digest
[2]);
10448 digest
[3] = byte_swap_32 (digest
[3]);
10450 digest
[0] -= MD5M_A
;
10451 digest
[1] -= MD5M_B
;
10452 digest
[2] -= MD5M_C
;
10453 digest
[3] -= MD5M_D
;
10455 return (PARSER_OK
);
10458 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10460 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10462 u32
*digest
= (u32
*) hash_buf
->digest
;
10464 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10465 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10469 digest
[0] = byte_swap_32 (digest
[0]);
10470 digest
[1] = byte_swap_32 (digest
[1]);
10472 return (PARSER_OK
);
10475 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10477 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10479 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10483 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10486 u32
*digest
= (u32
*) hash_buf
->digest
;
10488 salt_t
*salt
= hash_buf
->salt
;
10490 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10491 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10492 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10493 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10495 digest
[0] = byte_swap_32 (digest
[0]);
10496 digest
[1] = byte_swap_32 (digest
[1]);
10497 digest
[2] = byte_swap_32 (digest
[2]);
10498 digest
[3] = byte_swap_32 (digest
[3]);
10500 digest
[0] -= MD5M_A
;
10501 digest
[1] -= MD5M_B
;
10502 digest
[2] -= MD5M_C
;
10503 digest
[3] -= MD5M_D
;
10505 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10507 uint salt_len
= input_len
- 32 - 1;
10509 char *salt_buf
= input_buf
+ 32 + 1;
10511 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10513 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10515 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10517 salt
->salt_len
= salt_len
;
10519 return (PARSER_OK
);
10522 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10524 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10526 u32
*digest
= (u32
*) hash_buf
->digest
;
10528 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10529 | itoa64_to_int (input_buf
[ 1]) << 6
10530 | itoa64_to_int (input_buf
[ 2]) << 12
10531 | itoa64_to_int (input_buf
[ 3]) << 18;
10532 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10533 | itoa64_to_int (input_buf
[ 5]) << 6
10534 | itoa64_to_int (input_buf
[ 6]) << 12
10535 | itoa64_to_int (input_buf
[ 7]) << 18;
10536 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10537 | itoa64_to_int (input_buf
[ 9]) << 6
10538 | itoa64_to_int (input_buf
[10]) << 12
10539 | itoa64_to_int (input_buf
[11]) << 18;
10540 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10541 | itoa64_to_int (input_buf
[13]) << 6
10542 | itoa64_to_int (input_buf
[14]) << 12
10543 | itoa64_to_int (input_buf
[15]) << 18;
10545 digest
[0] -= MD5M_A
;
10546 digest
[1] -= MD5M_B
;
10547 digest
[2] -= MD5M_C
;
10548 digest
[3] -= MD5M_D
;
10550 digest
[0] &= 0x00ffffff;
10551 digest
[1] &= 0x00ffffff;
10552 digest
[2] &= 0x00ffffff;
10553 digest
[3] &= 0x00ffffff;
10555 return (PARSER_OK
);
10558 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10560 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10562 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10566 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10569 u32
*digest
= (u32
*) hash_buf
->digest
;
10571 salt_t
*salt
= hash_buf
->salt
;
10573 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10574 | itoa64_to_int (input_buf
[ 1]) << 6
10575 | itoa64_to_int (input_buf
[ 2]) << 12
10576 | itoa64_to_int (input_buf
[ 3]) << 18;
10577 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10578 | itoa64_to_int (input_buf
[ 5]) << 6
10579 | itoa64_to_int (input_buf
[ 6]) << 12
10580 | itoa64_to_int (input_buf
[ 7]) << 18;
10581 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10582 | itoa64_to_int (input_buf
[ 9]) << 6
10583 | itoa64_to_int (input_buf
[10]) << 12
10584 | itoa64_to_int (input_buf
[11]) << 18;
10585 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10586 | itoa64_to_int (input_buf
[13]) << 6
10587 | itoa64_to_int (input_buf
[14]) << 12
10588 | itoa64_to_int (input_buf
[15]) << 18;
10590 digest
[0] -= MD5M_A
;
10591 digest
[1] -= MD5M_B
;
10592 digest
[2] -= MD5M_C
;
10593 digest
[3] -= MD5M_D
;
10595 digest
[0] &= 0x00ffffff;
10596 digest
[1] &= 0x00ffffff;
10597 digest
[2] &= 0x00ffffff;
10598 digest
[3] &= 0x00ffffff;
10600 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10602 uint salt_len
= input_len
- 16 - 1;
10604 char *salt_buf
= input_buf
+ 16 + 1;
10606 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10608 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10610 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10612 salt
->salt_len
= salt_len
;
10614 return (PARSER_OK
);
10617 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10619 key
[0] = (nthash
[0] >> 0);
10620 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10621 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10622 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10623 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10624 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10625 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10626 key
[7] = (nthash
[6] << 1);
10638 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10640 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10642 u32
*digest
= (u32
*) hash_buf
->digest
;
10644 salt_t
*salt
= hash_buf
->salt
;
10646 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10652 char *user_pos
= input_buf
;
10654 char *unused_pos
= strchr (user_pos
, ':');
10656 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10658 uint user_len
= unused_pos
- user_pos
;
10660 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10664 char *domain_pos
= strchr (unused_pos
, ':');
10666 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10668 uint unused_len
= domain_pos
- unused_pos
;
10670 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10674 char *srvchall_pos
= strchr (domain_pos
, ':');
10676 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10678 uint domain_len
= srvchall_pos
- domain_pos
;
10680 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10684 char *hash_pos
= strchr (srvchall_pos
, ':');
10686 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10688 uint srvchall_len
= hash_pos
- srvchall_pos
;
10690 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10694 char *clichall_pos
= strchr (hash_pos
, ':');
10696 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10698 uint hash_len
= clichall_pos
- hash_pos
;
10700 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10704 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10706 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10709 * store some data for later use
10712 netntlm
->user_len
= user_len
* 2;
10713 netntlm
->domain_len
= domain_len
* 2;
10714 netntlm
->srvchall_len
= srvchall_len
/ 2;
10715 netntlm
->clichall_len
= clichall_len
/ 2;
10717 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10718 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10721 * handle username and domainname
10724 for (uint i
= 0; i
< user_len
; i
++)
10726 *userdomain_ptr
++ = user_pos
[i
];
10727 *userdomain_ptr
++ = 0;
10730 for (uint i
= 0; i
< domain_len
; i
++)
10732 *userdomain_ptr
++ = domain_pos
[i
];
10733 *userdomain_ptr
++ = 0;
10737 * handle server challenge encoding
10740 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10742 const char p0
= srvchall_pos
[i
+ 0];
10743 const char p1
= srvchall_pos
[i
+ 1];
10745 *chall_ptr
++ = hex_convert (p1
) << 0
10746 | hex_convert (p0
) << 4;
10750 * handle client challenge encoding
10753 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10755 const char p0
= clichall_pos
[i
+ 0];
10756 const char p1
= clichall_pos
[i
+ 1];
10758 *chall_ptr
++ = hex_convert (p1
) << 0
10759 | hex_convert (p0
) << 4;
10766 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10768 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10770 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10772 salt
->salt_len
= salt_len
;
10774 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10775 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10776 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10777 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10779 digest
[0] = byte_swap_32 (digest
[0]);
10780 digest
[1] = byte_swap_32 (digest
[1]);
10781 digest
[2] = byte_swap_32 (digest
[2]);
10782 digest
[3] = byte_swap_32 (digest
[3]);
10784 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10786 uint digest_tmp
[2] = { 0 };
10788 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10789 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
10791 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10792 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10794 /* special case 2: ESS */
10796 if (srvchall_len
== 48)
10798 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10800 uint w
[16] = { 0 };
10802 w
[ 0] = netntlm
->chall_buf
[6];
10803 w
[ 1] = netntlm
->chall_buf
[7];
10804 w
[ 2] = netntlm
->chall_buf
[0];
10805 w
[ 3] = netntlm
->chall_buf
[1];
10809 uint dgst
[4] = { 0 };
10818 salt
->salt_buf
[0] = dgst
[0];
10819 salt
->salt_buf
[1] = dgst
[1];
10823 /* precompute netntlmv1 exploit start */
10825 for (uint i
= 0; i
< 0x10000; i
++)
10827 uint key_md4
[2] = { i
, 0 };
10828 uint key_des
[2] = { 0, 0 };
10830 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
10832 uint Kc
[16] = { 0 };
10833 uint Kd
[16] = { 0 };
10835 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10837 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10839 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10841 if (data3
[0] != digest_tmp
[0]) continue;
10842 if (data3
[1] != digest_tmp
[1]) continue;
10844 salt
->salt_buf
[2] = i
;
10846 salt
->salt_len
= 24;
10851 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10852 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10854 /* precompute netntlmv1 exploit stop */
10858 IP (digest
[0], digest
[1], tt
);
10859 IP (digest
[2], digest
[3], tt
);
10861 digest
[0] = rotr32 (digest
[0], 29);
10862 digest
[1] = rotr32 (digest
[1], 29);
10863 digest
[2] = rotr32 (digest
[2], 29);
10864 digest
[3] = rotr32 (digest
[3], 29);
10866 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10868 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
10869 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
10871 return (PARSER_OK
);
10874 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10876 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10878 u32
*digest
= (u32
*) hash_buf
->digest
;
10880 salt_t
*salt
= hash_buf
->salt
;
10882 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10888 char *user_pos
= input_buf
;
10890 char *unused_pos
= strchr (user_pos
, ':');
10892 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10894 uint user_len
= unused_pos
- user_pos
;
10896 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10900 char *domain_pos
= strchr (unused_pos
, ':');
10902 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10904 uint unused_len
= domain_pos
- unused_pos
;
10906 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10910 char *srvchall_pos
= strchr (domain_pos
, ':');
10912 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10914 uint domain_len
= srvchall_pos
- domain_pos
;
10916 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10920 char *hash_pos
= strchr (srvchall_pos
, ':');
10922 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10924 uint srvchall_len
= hash_pos
- srvchall_pos
;
10926 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
10930 char *clichall_pos
= strchr (hash_pos
, ':');
10932 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10934 uint hash_len
= clichall_pos
- hash_pos
;
10936 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
10940 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10942 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
10944 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
10947 * store some data for later use
10950 netntlm
->user_len
= user_len
* 2;
10951 netntlm
->domain_len
= domain_len
* 2;
10952 netntlm
->srvchall_len
= srvchall_len
/ 2;
10953 netntlm
->clichall_len
= clichall_len
/ 2;
10955 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10956 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10959 * handle username and domainname
10962 for (uint i
= 0; i
< user_len
; i
++)
10964 *userdomain_ptr
++ = toupper (user_pos
[i
]);
10965 *userdomain_ptr
++ = 0;
10968 for (uint i
= 0; i
< domain_len
; i
++)
10970 *userdomain_ptr
++ = domain_pos
[i
];
10971 *userdomain_ptr
++ = 0;
10974 *userdomain_ptr
++ = 0x80;
10977 * handle server challenge encoding
10980 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10982 const char p0
= srvchall_pos
[i
+ 0];
10983 const char p1
= srvchall_pos
[i
+ 1];
10985 *chall_ptr
++ = hex_convert (p1
) << 0
10986 | hex_convert (p0
) << 4;
10990 * handle client challenge encoding
10993 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10995 const char p0
= clichall_pos
[i
+ 0];
10996 const char p1
= clichall_pos
[i
+ 1];
10998 *chall_ptr
++ = hex_convert (p1
) << 0
10999 | hex_convert (p0
) << 4;
11002 *chall_ptr
++ = 0x80;
11005 * handle hash itself
11008 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11009 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11010 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11011 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11013 digest
[0] = byte_swap_32 (digest
[0]);
11014 digest
[1] = byte_swap_32 (digest
[1]);
11015 digest
[2] = byte_swap_32 (digest
[2]);
11016 digest
[3] = byte_swap_32 (digest
[3]);
11019 * reuse challange data as salt_buf, its the buffer that is most likely unique
11022 salt
->salt_buf
[0] = 0;
11023 salt
->salt_buf
[1] = 0;
11024 salt
->salt_buf
[2] = 0;
11025 salt
->salt_buf
[3] = 0;
11026 salt
->salt_buf
[4] = 0;
11027 salt
->salt_buf
[5] = 0;
11028 salt
->salt_buf
[6] = 0;
11029 salt
->salt_buf
[7] = 0;
11033 uptr
= (uint
*) netntlm
->userdomain_buf
;
11035 for (uint i
= 0; i
< 16; i
+= 16)
11037 md5_64 (uptr
, salt
->salt_buf
);
11040 uptr
= (uint
*) netntlm
->chall_buf
;
11042 for (uint i
= 0; i
< 256; i
+= 16)
11044 md5_64 (uptr
, salt
->salt_buf
);
11047 salt
->salt_len
= 16;
11049 return (PARSER_OK
);
11052 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11054 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11056 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11060 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11063 u32
*digest
= (u32
*) hash_buf
->digest
;
11065 salt_t
*salt
= hash_buf
->salt
;
11067 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11068 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11069 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11070 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11072 digest
[0] = byte_swap_32 (digest
[0]);
11073 digest
[1] = byte_swap_32 (digest
[1]);
11074 digest
[2] = byte_swap_32 (digest
[2]);
11075 digest
[3] = byte_swap_32 (digest
[3]);
11077 digest
[0] -= MD5M_A
;
11078 digest
[1] -= MD5M_B
;
11079 digest
[2] -= MD5M_C
;
11080 digest
[3] -= MD5M_D
;
11082 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11084 uint salt_len
= input_len
- 32 - 1;
11086 char *salt_buf
= input_buf
+ 32 + 1;
11088 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11090 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11092 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11094 salt
->salt_len
= salt_len
;
11096 return (PARSER_OK
);
11099 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11101 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11103 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11107 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11110 u32
*digest
= (u32
*) hash_buf
->digest
;
11112 salt_t
*salt
= hash_buf
->salt
;
11114 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11115 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11116 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11117 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11119 digest
[0] = byte_swap_32 (digest
[0]);
11120 digest
[1] = byte_swap_32 (digest
[1]);
11121 digest
[2] = byte_swap_32 (digest
[2]);
11122 digest
[3] = byte_swap_32 (digest
[3]);
11124 digest
[0] -= MD5M_A
;
11125 digest
[1] -= MD5M_B
;
11126 digest
[2] -= MD5M_C
;
11127 digest
[3] -= MD5M_D
;
11129 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11131 uint salt_len
= input_len
- 32 - 1;
11133 char *salt_buf
= input_buf
+ 32 + 1;
11135 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11137 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11139 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11141 salt
->salt_len
= salt_len
;
11143 return (PARSER_OK
);
11146 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11148 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11150 u32
*digest
= (u32
*) hash_buf
->digest
;
11152 salt_t
*salt
= hash_buf
->salt
;
11154 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11155 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11156 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11157 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11159 digest
[0] = byte_swap_32 (digest
[0]);
11160 digest
[1] = byte_swap_32 (digest
[1]);
11161 digest
[2] = byte_swap_32 (digest
[2]);
11162 digest
[3] = byte_swap_32 (digest
[3]);
11164 digest
[0] -= MD5M_A
;
11165 digest
[1] -= MD5M_B
;
11166 digest
[2] -= MD5M_C
;
11167 digest
[3] -= MD5M_D
;
11170 * This is a virtual salt. While the algorithm is basically not salted
11171 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11172 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11175 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11177 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11179 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11181 salt
->salt_len
= salt_len
;
11183 return (PARSER_OK
);
11186 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11188 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11190 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11194 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11197 u32
*digest
= (u32
*) hash_buf
->digest
;
11199 salt_t
*salt
= hash_buf
->salt
;
11201 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11202 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11203 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11204 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11206 digest
[0] = byte_swap_32 (digest
[0]);
11207 digest
[1] = byte_swap_32 (digest
[1]);
11208 digest
[2] = byte_swap_32 (digest
[2]);
11209 digest
[3] = byte_swap_32 (digest
[3]);
11211 digest
[0] -= MD5M_A
;
11212 digest
[1] -= MD5M_B
;
11213 digest
[2] -= MD5M_C
;
11214 digest
[3] -= MD5M_D
;
11216 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11218 uint salt_len
= input_len
- 32 - 1;
11220 char *salt_buf
= input_buf
+ 32 + 1;
11222 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11224 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11226 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11228 salt
->salt_len
= salt_len
;
11230 return (PARSER_OK
);
11233 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11235 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11237 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11241 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11244 u32
*digest
= (u32
*) hash_buf
->digest
;
11246 salt_t
*salt
= hash_buf
->salt
;
11248 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11249 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11250 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11251 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11253 digest
[0] = byte_swap_32 (digest
[0]);
11254 digest
[1] = byte_swap_32 (digest
[1]);
11255 digest
[2] = byte_swap_32 (digest
[2]);
11256 digest
[3] = byte_swap_32 (digest
[3]);
11258 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11260 uint salt_len
= input_len
- 32 - 1;
11262 char *salt_buf
= input_buf
+ 32 + 1;
11264 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11266 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11268 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11270 salt
->salt_len
= salt_len
;
11272 return (PARSER_OK
);
11275 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11277 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11279 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11283 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11286 u32
*digest
= (u32
*) hash_buf
->digest
;
11288 salt_t
*salt
= hash_buf
->salt
;
11290 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11291 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11292 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11293 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11295 digest
[0] = byte_swap_32 (digest
[0]);
11296 digest
[1] = byte_swap_32 (digest
[1]);
11297 digest
[2] = byte_swap_32 (digest
[2]);
11298 digest
[3] = byte_swap_32 (digest
[3]);
11300 digest
[0] -= MD4M_A
;
11301 digest
[1] -= MD4M_B
;
11302 digest
[2] -= MD4M_C
;
11303 digest
[3] -= MD4M_D
;
11305 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11307 uint salt_len
= input_len
- 32 - 1;
11309 char *salt_buf
= input_buf
+ 32 + 1;
11311 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11313 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11315 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11317 salt
->salt_len
= salt_len
;
11319 return (PARSER_OK
);
11322 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11324 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11326 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11330 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11333 u32
*digest
= (u32
*) hash_buf
->digest
;
11335 salt_t
*salt
= hash_buf
->salt
;
11337 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11338 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11339 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11340 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11342 digest
[0] = byte_swap_32 (digest
[0]);
11343 digest
[1] = byte_swap_32 (digest
[1]);
11344 digest
[2] = byte_swap_32 (digest
[2]);
11345 digest
[3] = byte_swap_32 (digest
[3]);
11347 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11349 uint salt_len
= input_len
- 32 - 1;
11351 char *salt_buf
= input_buf
+ 32 + 1;
11353 uint salt_pc_block
[16] = { 0 };
11355 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11357 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11359 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11361 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11363 salt_pc_block
[14] = salt_len
* 8;
11365 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11367 md5_64 (salt_pc_block
, salt_pc_digest
);
11369 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11370 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11371 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11372 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11374 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11376 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11378 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11380 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11381 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11382 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11383 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11385 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11387 return (PARSER_OK
);
11390 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11392 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11394 u32
*digest
= (u32
*) hash_buf
->digest
;
11396 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11397 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11398 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11399 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11400 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11402 digest
[0] -= SHA1M_A
;
11403 digest
[1] -= SHA1M_B
;
11404 digest
[2] -= SHA1M_C
;
11405 digest
[3] -= SHA1M_D
;
11406 digest
[4] -= SHA1M_E
;
11408 return (PARSER_OK
);
11411 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11413 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11415 u32
*digest
= (u32
*) hash_buf
->digest
;
11417 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11418 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11419 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11420 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11421 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11423 return (PARSER_OK
);
11426 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11428 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11430 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11434 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11437 u32
*digest
= (u32
*) hash_buf
->digest
;
11439 salt_t
*salt
= hash_buf
->salt
;
11441 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11442 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11443 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11444 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11445 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11447 digest
[0] -= SHA1M_A
;
11448 digest
[1] -= SHA1M_B
;
11449 digest
[2] -= SHA1M_C
;
11450 digest
[3] -= SHA1M_D
;
11451 digest
[4] -= SHA1M_E
;
11453 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11455 uint salt_len
= input_len
- 40 - 1;
11457 char *salt_buf
= input_buf
+ 40 + 1;
11459 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11461 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11463 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11465 salt
->salt_len
= salt_len
;
11467 return (PARSER_OK
);
11470 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11472 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11474 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11476 u32
*digest
= (u32
*) hash_buf
->digest
;
11478 u8 tmp_buf
[100] = { 0 };
11480 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11482 memcpy (digest
, tmp_buf
, 20);
11484 digest
[0] = byte_swap_32 (digest
[0]);
11485 digest
[1] = byte_swap_32 (digest
[1]);
11486 digest
[2] = byte_swap_32 (digest
[2]);
11487 digest
[3] = byte_swap_32 (digest
[3]);
11488 digest
[4] = byte_swap_32 (digest
[4]);
11490 digest
[0] -= SHA1M_A
;
11491 digest
[1] -= SHA1M_B
;
11492 digest
[2] -= SHA1M_C
;
11493 digest
[3] -= SHA1M_D
;
11494 digest
[4] -= SHA1M_E
;
11496 return (PARSER_OK
);
11499 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11501 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11503 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11505 u32
*digest
= (u32
*) hash_buf
->digest
;
11507 salt_t
*salt
= hash_buf
->salt
;
11509 u8 tmp_buf
[100] = { 0 };
11511 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11513 memcpy (digest
, tmp_buf
, 20);
11515 salt
->salt_len
= tmp_len
- 20;
11517 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11519 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11521 char *ptr
= (char *) salt
->salt_buf
;
11523 ptr
[salt
->salt_len
] = 0x80;
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 mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11543 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11545 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11547 u32
*digest
= (u32
*) hash_buf
->digest
;
11549 salt_t
*salt
= hash_buf
->salt
;
11551 char *salt_buf
= input_buf
+ 6;
11555 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11557 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11559 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11561 salt
->salt_len
= salt_len
;
11563 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11565 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11566 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11567 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11568 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11569 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11571 digest
[0] -= SHA1M_A
;
11572 digest
[1] -= SHA1M_B
;
11573 digest
[2] -= SHA1M_C
;
11574 digest
[3] -= SHA1M_D
;
11575 digest
[4] -= SHA1M_E
;
11577 return (PARSER_OK
);
11580 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11582 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11584 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11586 u32
*digest
= (u32
*) hash_buf
->digest
;
11588 salt_t
*salt
= hash_buf
->salt
;
11590 char *salt_buf
= input_buf
+ 6;
11594 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11596 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11598 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11600 salt
->salt_len
= salt_len
;
11602 char *hash_pos
= input_buf
+ 6 + 8;
11604 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11605 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11606 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11607 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11608 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11610 digest
[0] -= SHA1M_A
;
11611 digest
[1] -= SHA1M_B
;
11612 digest
[2] -= SHA1M_C
;
11613 digest
[3] -= SHA1M_D
;
11614 digest
[4] -= SHA1M_E
;
11616 return (PARSER_OK
);
11619 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11621 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11623 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11625 u64
*digest
= (u64
*) hash_buf
->digest
;
11627 salt_t
*salt
= hash_buf
->salt
;
11629 char *salt_buf
= input_buf
+ 6;
11633 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11635 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11637 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11639 salt
->salt_len
= salt_len
;
11641 char *hash_pos
= input_buf
+ 6 + 8;
11643 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11644 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11645 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11646 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11647 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11648 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11649 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11650 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11652 digest
[0] -= SHA512M_A
;
11653 digest
[1] -= SHA512M_B
;
11654 digest
[2] -= SHA512M_C
;
11655 digest
[3] -= SHA512M_D
;
11656 digest
[4] -= SHA512M_E
;
11657 digest
[5] -= SHA512M_F
;
11658 digest
[6] -= SHA512M_G
;
11659 digest
[7] -= SHA512M_H
;
11661 return (PARSER_OK
);
11664 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11666 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11668 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11672 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11675 u32
*digest
= (u32
*) hash_buf
->digest
;
11677 salt_t
*salt
= hash_buf
->salt
;
11679 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11680 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11684 digest
[0] = byte_swap_32 (digest
[0]);
11685 digest
[1] = byte_swap_32 (digest
[1]);
11687 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11689 uint salt_len
= input_len
- 16 - 1;
11691 char *salt_buf
= input_buf
+ 16 + 1;
11693 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11695 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11697 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11699 salt
->salt_len
= salt_len
;
11701 return (PARSER_OK
);
11704 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11706 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11708 u32
*digest
= (u32
*) hash_buf
->digest
;
11710 salt_t
*salt
= hash_buf
->salt
;
11712 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11713 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11714 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11715 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11716 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11718 digest
[0] -= SHA1M_A
;
11719 digest
[1] -= SHA1M_B
;
11720 digest
[2] -= SHA1M_C
;
11721 digest
[3] -= SHA1M_D
;
11722 digest
[4] -= SHA1M_E
;
11724 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11726 uint salt_len
= input_len
- 40 - 1;
11728 char *salt_buf
= input_buf
+ 40 + 1;
11730 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11732 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11734 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11736 salt
->salt_len
= salt_len
;
11738 return (PARSER_OK
);
11741 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11743 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11745 u32
*digest
= (u32
*) hash_buf
->digest
;
11747 salt_t
*salt
= hash_buf
->salt
;
11749 char *hash_pos
= input_buf
;
11751 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11752 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11753 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
11754 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
11755 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
11756 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
11757 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
11758 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
11759 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
11760 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
11761 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
11762 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
11763 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
11764 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
11765 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
11766 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
11768 char *salt_pos
= input_buf
+ 128;
11770 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
11771 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
11772 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
11773 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
11775 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11776 salt
->salt_len
= 16;
11778 return (PARSER_OK
);
11781 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11783 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11785 u32
*digest
= (u32
*) hash_buf
->digest
;
11787 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11788 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11789 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11790 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11791 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11792 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11793 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11794 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11796 digest
[0] -= SHA256M_A
;
11797 digest
[1] -= SHA256M_B
;
11798 digest
[2] -= SHA256M_C
;
11799 digest
[3] -= SHA256M_D
;
11800 digest
[4] -= SHA256M_E
;
11801 digest
[5] -= SHA256M_F
;
11802 digest
[6] -= SHA256M_G
;
11803 digest
[7] -= SHA256M_H
;
11805 return (PARSER_OK
);
11808 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11810 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11812 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11816 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11819 u32
*digest
= (u32
*) hash_buf
->digest
;
11821 salt_t
*salt
= hash_buf
->salt
;
11823 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11824 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11825 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11826 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11827 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11828 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11829 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11830 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11832 digest
[0] -= SHA256M_A
;
11833 digest
[1] -= SHA256M_B
;
11834 digest
[2] -= SHA256M_C
;
11835 digest
[3] -= SHA256M_D
;
11836 digest
[4] -= SHA256M_E
;
11837 digest
[5] -= SHA256M_F
;
11838 digest
[6] -= SHA256M_G
;
11839 digest
[7] -= SHA256M_H
;
11841 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11843 uint salt_len
= input_len
- 64 - 1;
11845 char *salt_buf
= input_buf
+ 64 + 1;
11847 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11849 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11851 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11853 salt
->salt_len
= salt_len
;
11855 return (PARSER_OK
);
11858 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11860 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11862 u64
*digest
= (u64
*) hash_buf
->digest
;
11864 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11865 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11866 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11867 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11868 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11869 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11873 digest
[0] -= SHA384M_A
;
11874 digest
[1] -= SHA384M_B
;
11875 digest
[2] -= SHA384M_C
;
11876 digest
[3] -= SHA384M_D
;
11877 digest
[4] -= SHA384M_E
;
11878 digest
[5] -= SHA384M_F
;
11882 return (PARSER_OK
);
11885 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11887 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
11889 u64
*digest
= (u64
*) hash_buf
->digest
;
11891 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11892 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11893 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11894 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11895 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11896 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11897 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11898 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11900 digest
[0] -= SHA512M_A
;
11901 digest
[1] -= SHA512M_B
;
11902 digest
[2] -= SHA512M_C
;
11903 digest
[3] -= SHA512M_D
;
11904 digest
[4] -= SHA512M_E
;
11905 digest
[5] -= SHA512M_F
;
11906 digest
[6] -= SHA512M_G
;
11907 digest
[7] -= SHA512M_H
;
11909 return (PARSER_OK
);
11912 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11914 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11916 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
11920 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
11923 u64
*digest
= (u64
*) hash_buf
->digest
;
11925 salt_t
*salt
= hash_buf
->salt
;
11927 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11928 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11929 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11930 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11931 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11932 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11933 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11934 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11936 digest
[0] -= SHA512M_A
;
11937 digest
[1] -= SHA512M_B
;
11938 digest
[2] -= SHA512M_C
;
11939 digest
[3] -= SHA512M_D
;
11940 digest
[4] -= SHA512M_E
;
11941 digest
[5] -= SHA512M_F
;
11942 digest
[6] -= SHA512M_G
;
11943 digest
[7] -= SHA512M_H
;
11945 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11947 uint salt_len
= input_len
- 128 - 1;
11949 char *salt_buf
= input_buf
+ 128 + 1;
11951 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11953 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11955 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11957 salt
->salt_len
= salt_len
;
11959 return (PARSER_OK
);
11962 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11964 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
11966 u64
*digest
= (u64
*) hash_buf
->digest
;
11968 salt_t
*salt
= hash_buf
->salt
;
11970 char *salt_pos
= input_buf
+ 3;
11972 uint iterations_len
= 0;
11974 if (memcmp (salt_pos
, "rounds=", 7) == 0)
11978 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
11980 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
11981 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
11985 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
11989 iterations_len
+= 8;
11993 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
11996 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
11998 char *hash_pos
= strchr (salt_pos
, '$');
12000 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12002 uint salt_len
= hash_pos
- salt_pos
;
12004 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12006 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12008 salt
->salt_len
= salt_len
;
12012 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12014 return (PARSER_OK
);
12017 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12019 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12021 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12023 u64
*digest
= (u64
*) hash_buf
->digest
;
12025 salt_t
*salt
= hash_buf
->salt
;
12027 uint keccak_mdlen
= input_len
/ 2;
12029 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12031 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12033 digest
[i
] = byte_swap_64 (digest
[i
]);
12036 salt
->keccak_mdlen
= keccak_mdlen
;
12038 return (PARSER_OK
);
12041 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12043 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12045 u32
*digest
= (u32
*) hash_buf
->digest
;
12047 salt_t
*salt
= hash_buf
->salt
;
12049 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12052 * Parse that strange long line
12057 size_t in_len
[9] = { 0 };
12059 in_off
[0] = strtok (input_buf
, ":");
12061 in_len
[0] = strlen (in_off
[0]);
12065 for (i
= 1; i
< 9; i
++)
12067 in_off
[i
] = strtok (NULL
, ":");
12069 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12071 in_len
[i
] = strlen (in_off
[i
]);
12074 char *ptr
= (char *) ikepsk
->msg_buf
;
12076 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12077 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12078 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12079 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12080 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12081 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12085 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12087 ptr
= (char *) ikepsk
->nr_buf
;
12089 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12090 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12094 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12097 * Store to database
12102 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12103 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12104 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12105 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12107 digest
[0] = byte_swap_32 (digest
[0]);
12108 digest
[1] = byte_swap_32 (digest
[1]);
12109 digest
[2] = byte_swap_32 (digest
[2]);
12110 digest
[3] = byte_swap_32 (digest
[3]);
12112 salt
->salt_len
= 32;
12114 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12115 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12116 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12117 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12118 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12119 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12120 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12121 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12123 return (PARSER_OK
);
12126 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12128 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12130 u32
*digest
= (u32
*) hash_buf
->digest
;
12132 salt_t
*salt
= hash_buf
->salt
;
12134 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12137 * Parse that strange long line
12142 size_t in_len
[9] = { 0 };
12144 in_off
[0] = strtok (input_buf
, ":");
12146 in_len
[0] = strlen (in_off
[0]);
12150 for (i
= 1; i
< 9; i
++)
12152 in_off
[i
] = strtok (NULL
, ":");
12154 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12156 in_len
[i
] = strlen (in_off
[i
]);
12159 char *ptr
= (char *) ikepsk
->msg_buf
;
12161 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12162 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12163 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12164 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12165 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12166 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12170 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12172 ptr
= (char *) ikepsk
->nr_buf
;
12174 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12175 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12179 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12182 * Store to database
12187 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12188 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12189 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12190 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12191 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12193 salt
->salt_len
= 32;
12195 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12196 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12197 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12198 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12199 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12200 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12201 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12202 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12204 return (PARSER_OK
);
12207 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12209 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12211 u32
*digest
= (u32
*) hash_buf
->digest
;
12213 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12214 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12215 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12216 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12217 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12219 digest
[0] = byte_swap_32 (digest
[0]);
12220 digest
[1] = byte_swap_32 (digest
[1]);
12221 digest
[2] = byte_swap_32 (digest
[2]);
12222 digest
[3] = byte_swap_32 (digest
[3]);
12223 digest
[4] = byte_swap_32 (digest
[4]);
12225 return (PARSER_OK
);
12228 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12230 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12232 u32
*digest
= (u32
*) hash_buf
->digest
;
12234 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12235 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12236 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12237 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12238 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12239 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12240 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12241 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12242 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12243 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12244 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12245 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12246 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12247 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12248 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12249 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12251 return (PARSER_OK
);
12254 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12256 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12258 u32
*digest
= (u32
*) hash_buf
->digest
;
12260 salt_t
*salt
= hash_buf
->salt
;
12262 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12263 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12264 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12265 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12266 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12268 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12270 uint salt_len
= input_len
- 40 - 1;
12272 char *salt_buf
= input_buf
+ 40 + 1;
12274 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12276 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12278 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12280 salt
->salt_len
= salt_len
;
12282 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12284 return (PARSER_OK
);
12287 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12289 u32
*digest
= (u32
*) hash_buf
->digest
;
12291 salt_t
*salt
= hash_buf
->salt
;
12293 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12295 if (input_len
== 0)
12297 log_error ("TrueCrypt container not specified");
12302 FILE *fp
= fopen (input_buf
, "rb");
12306 log_error ("%s: %s", input_buf
, strerror (errno
));
12311 char buf
[512] = { 0 };
12313 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12317 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12319 memcpy (tc
->salt_buf
, buf
, 64);
12321 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12323 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12325 salt
->salt_len
= 4;
12327 salt
->salt_iter
= 1000 - 1;
12329 digest
[0] = tc
->data_buf
[0];
12331 return (PARSER_OK
);
12334 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12336 u32
*digest
= (u32
*) hash_buf
->digest
;
12338 salt_t
*salt
= hash_buf
->salt
;
12340 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12342 if (input_len
== 0)
12344 log_error ("TrueCrypt container not specified");
12349 FILE *fp
= fopen (input_buf
, "rb");
12353 log_error ("%s: %s", input_buf
, strerror (errno
));
12358 char buf
[512] = { 0 };
12360 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12364 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12366 memcpy (tc
->salt_buf
, buf
, 64);
12368 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12370 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12372 salt
->salt_len
= 4;
12374 salt
->salt_iter
= 2000 - 1;
12376 digest
[0] = tc
->data_buf
[0];
12378 return (PARSER_OK
);
12381 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12383 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12385 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12387 u32
*digest
= (u32
*) hash_buf
->digest
;
12389 salt_t
*salt
= hash_buf
->salt
;
12391 char *salt_pos
= input_buf
+ 6;
12393 char *hash_pos
= strchr (salt_pos
, '$');
12395 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12397 uint salt_len
= hash_pos
- salt_pos
;
12399 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12401 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12403 salt
->salt_len
= salt_len
;
12405 salt
->salt_iter
= 1000;
12409 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12411 return (PARSER_OK
);
12414 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12416 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12418 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12420 u32
*digest
= (u32
*) hash_buf
->digest
;
12422 salt_t
*salt
= hash_buf
->salt
;
12424 char *iter_pos
= input_buf
+ 7;
12426 char *salt_pos
= strchr (iter_pos
, '$');
12428 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12432 char *hash_pos
= strchr (salt_pos
, '$');
12434 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12436 uint salt_len
= hash_pos
- salt_pos
;
12438 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12440 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12442 salt
->salt_len
= salt_len
;
12444 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12446 salt
->salt_sign
[0] = atoi (salt_iter
);
12448 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12452 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12454 digest
[0] = byte_swap_32 (digest
[0]);
12455 digest
[1] = byte_swap_32 (digest
[1]);
12456 digest
[2] = byte_swap_32 (digest
[2]);
12457 digest
[3] = byte_swap_32 (digest
[3]);
12458 digest
[4] = byte_swap_32 (digest
[4]);
12460 return (PARSER_OK
);
12463 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12465 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12467 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12469 u32
*digest
= (u32
*) hash_buf
->digest
;
12471 salt_t
*salt
= hash_buf
->salt
;
12473 char *iter_pos
= input_buf
+ 9;
12475 char *salt_pos
= strchr (iter_pos
, '$');
12477 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12481 char *hash_pos
= strchr (salt_pos
, '$');
12483 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12485 uint salt_len
= hash_pos
- salt_pos
;
12487 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12489 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12491 salt
->salt_len
= salt_len
;
12493 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12495 salt
->salt_sign
[0] = atoi (salt_iter
);
12497 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12501 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12503 digest
[0] = byte_swap_32 (digest
[0]);
12504 digest
[1] = byte_swap_32 (digest
[1]);
12505 digest
[2] = byte_swap_32 (digest
[2]);
12506 digest
[3] = byte_swap_32 (digest
[3]);
12507 digest
[4] = byte_swap_32 (digest
[4]);
12508 digest
[5] = byte_swap_32 (digest
[5]);
12509 digest
[6] = byte_swap_32 (digest
[6]);
12510 digest
[7] = byte_swap_32 (digest
[7]);
12512 return (PARSER_OK
);
12515 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12517 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12519 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12521 u64
*digest
= (u64
*) hash_buf
->digest
;
12523 salt_t
*salt
= hash_buf
->salt
;
12525 char *iter_pos
= input_buf
+ 9;
12527 char *salt_pos
= strchr (iter_pos
, '$');
12529 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12533 char *hash_pos
= strchr (salt_pos
, '$');
12535 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12537 uint salt_len
= hash_pos
- salt_pos
;
12539 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12541 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12543 salt
->salt_len
= salt_len
;
12545 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12547 salt
->salt_sign
[0] = atoi (salt_iter
);
12549 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12553 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12555 digest
[0] = byte_swap_64 (digest
[0]);
12556 digest
[1] = byte_swap_64 (digest
[1]);
12557 digest
[2] = byte_swap_64 (digest
[2]);
12558 digest
[3] = byte_swap_64 (digest
[3]);
12559 digest
[4] = byte_swap_64 (digest
[4]);
12560 digest
[5] = byte_swap_64 (digest
[5]);
12561 digest
[6] = byte_swap_64 (digest
[6]);
12562 digest
[7] = byte_swap_64 (digest
[7]);
12564 return (PARSER_OK
);
12567 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12569 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12571 u32
*digest
= (u32
*) hash_buf
->digest
;
12573 salt_t
*salt
= hash_buf
->salt
;
12575 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12581 char *iterations_pos
= input_buf
;
12583 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12585 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12587 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12589 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12593 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12595 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12597 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12599 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12601 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12603 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12608 * pbkdf2 iterations
12611 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12614 * handle salt encoding
12617 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12619 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12621 const char p0
= saltbuf_pos
[i
+ 0];
12622 const char p1
= saltbuf_pos
[i
+ 1];
12624 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12625 | hex_convert (p0
) << 4;
12628 salt
->salt_len
= saltbuf_len
/ 2;
12631 * handle cipher encoding
12634 uint
*tmp
= (uint
*) mymalloc (32);
12636 char *cipherbuf_ptr
= (char *) tmp
;
12638 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12640 const char p0
= cipherbuf_pos
[i
+ 0];
12641 const char p1
= cipherbuf_pos
[i
+ 1];
12643 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12644 | hex_convert (p0
) << 4;
12647 // iv is stored at salt_buf 4 (length 16)
12648 // data is stored at salt_buf 8 (length 16)
12650 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12651 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12652 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12653 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12655 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12656 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12657 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12658 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12662 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12664 const char p0
= cipherbuf_pos
[j
+ 0];
12665 const char p1
= cipherbuf_pos
[j
+ 1];
12667 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12668 | hex_convert (p0
) << 4;
12675 digest
[0] = 0x10101010;
12676 digest
[1] = 0x10101010;
12677 digest
[2] = 0x10101010;
12678 digest
[3] = 0x10101010;
12680 return (PARSER_OK
);
12683 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12685 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12687 u32
*digest
= (u32
*) hash_buf
->digest
;
12689 salt_t
*salt
= hash_buf
->salt
;
12691 char *hashbuf_pos
= input_buf
;
12693 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12695 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12697 uint hash_len
= iterations_pos
- hashbuf_pos
;
12699 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12703 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12705 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12707 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12711 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12713 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12715 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12717 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12719 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12721 salt
->salt_len
= salt_len
;
12723 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12725 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
12726 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
12727 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
12728 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
12730 return (PARSER_OK
);
12733 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12735 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12737 u32
*digest
= (u32
*) hash_buf
->digest
;
12739 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12740 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12741 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12742 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12743 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12744 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12745 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12746 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12748 digest
[0] = byte_swap_32 (digest
[0]);
12749 digest
[1] = byte_swap_32 (digest
[1]);
12750 digest
[2] = byte_swap_32 (digest
[2]);
12751 digest
[3] = byte_swap_32 (digest
[3]);
12752 digest
[4] = byte_swap_32 (digest
[4]);
12753 digest
[5] = byte_swap_32 (digest
[5]);
12754 digest
[6] = byte_swap_32 (digest
[6]);
12755 digest
[7] = byte_swap_32 (digest
[7]);
12757 return (PARSER_OK
);
12760 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12762 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12764 u32
*digest
= (u32
*) hash_buf
->digest
;
12766 salt_t
*salt
= hash_buf
->salt
;
12768 char *salt_pos
= input_buf
+ 3;
12770 uint iterations_len
= 0;
12772 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12776 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12778 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12779 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12783 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12787 iterations_len
+= 8;
12791 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12794 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12796 char *hash_pos
= strchr (salt_pos
, '$');
12798 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12800 uint salt_len
= hash_pos
- salt_pos
;
12802 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12804 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12806 salt
->salt_len
= salt_len
;
12810 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12812 return (PARSER_OK
);
12815 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12817 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12819 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12821 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12823 u64
*digest
= (u64
*) hash_buf
->digest
;
12825 salt_t
*salt
= hash_buf
->salt
;
12827 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12829 char *iter_pos
= input_buf
+ 4;
12831 char *salt_pos
= strchr (iter_pos
, '$');
12833 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12837 char *hash_pos
= strchr (salt_pos
, '$');
12839 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12841 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12845 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12846 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12847 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12848 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12849 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12850 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12851 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12852 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12854 uint salt_len
= hash_pos
- salt_pos
- 1;
12856 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12858 salt
->salt_len
= salt_len
/ 2;
12860 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12861 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12862 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12863 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12864 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
12865 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
12866 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
12867 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
12869 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12870 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12871 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12872 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12873 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12874 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12875 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12876 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12877 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12878 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12880 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12882 salt
->salt_iter
= atoi (iter_pos
) - 1;
12884 return (PARSER_OK
);
12887 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12889 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12891 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12893 u32
*digest
= (u32
*) hash_buf
->digest
;
12895 salt_t
*salt
= hash_buf
->salt
;
12897 char *salt_pos
= input_buf
+ 14;
12899 char *hash_pos
= strchr (salt_pos
, '*');
12901 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12905 uint salt_len
= hash_pos
- salt_pos
- 1;
12907 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12909 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
12911 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12913 salt
->salt_len
= salt_len
;
12915 u8 tmp_buf
[100] = { 0 };
12917 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
12919 memcpy (digest
, tmp_buf
, 32);
12921 digest
[0] = byte_swap_32 (digest
[0]);
12922 digest
[1] = byte_swap_32 (digest
[1]);
12923 digest
[2] = byte_swap_32 (digest
[2]);
12924 digest
[3] = byte_swap_32 (digest
[3]);
12925 digest
[4] = byte_swap_32 (digest
[4]);
12926 digest
[5] = byte_swap_32 (digest
[5]);
12927 digest
[6] = byte_swap_32 (digest
[6]);
12928 digest
[7] = byte_swap_32 (digest
[7]);
12930 digest
[0] -= SHA256M_A
;
12931 digest
[1] -= SHA256M_B
;
12932 digest
[2] -= SHA256M_C
;
12933 digest
[3] -= SHA256M_D
;
12934 digest
[4] -= SHA256M_E
;
12935 digest
[5] -= SHA256M_F
;
12936 digest
[6] -= SHA256M_G
;
12937 digest
[7] -= SHA256M_H
;
12939 return (PARSER_OK
);
12942 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12944 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
12946 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12948 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
12950 u64
*digest
= (u64
*) hash_buf
->digest
;
12952 salt_t
*salt
= hash_buf
->salt
;
12954 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12956 char *iter_pos
= input_buf
+ 19;
12958 char *salt_pos
= strchr (iter_pos
, '.');
12960 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12964 char *hash_pos
= strchr (salt_pos
, '.');
12966 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12968 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12972 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12973 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12974 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12975 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12976 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12977 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12978 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12979 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12981 uint salt_len
= hash_pos
- salt_pos
- 1;
12985 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
12989 for (i
= 0; i
< salt_len
; i
++)
12991 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
12994 salt_buf_ptr
[salt_len
+ 3] = 0x01;
12995 salt_buf_ptr
[salt_len
+ 4] = 0x80;
12997 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12999 salt
->salt_len
= salt_len
;
13001 salt
->salt_iter
= atoi (iter_pos
) - 1;
13003 return (PARSER_OK
);
13006 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13008 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13010 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13012 u64
*digest
= (u64
*) hash_buf
->digest
;
13014 salt_t
*salt
= hash_buf
->salt
;
13016 u8 tmp_buf
[120] = { 0 };
13018 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13020 memcpy (digest
, tmp_buf
, 64);
13022 digest
[0] = byte_swap_64 (digest
[0]);
13023 digest
[1] = byte_swap_64 (digest
[1]);
13024 digest
[2] = byte_swap_64 (digest
[2]);
13025 digest
[3] = byte_swap_64 (digest
[3]);
13026 digest
[4] = byte_swap_64 (digest
[4]);
13027 digest
[5] = byte_swap_64 (digest
[5]);
13028 digest
[6] = byte_swap_64 (digest
[6]);
13029 digest
[7] = byte_swap_64 (digest
[7]);
13031 digest
[0] -= SHA512M_A
;
13032 digest
[1] -= SHA512M_B
;
13033 digest
[2] -= SHA512M_C
;
13034 digest
[3] -= SHA512M_D
;
13035 digest
[4] -= SHA512M_E
;
13036 digest
[5] -= SHA512M_F
;
13037 digest
[6] -= SHA512M_G
;
13038 digest
[7] -= SHA512M_H
;
13040 salt
->salt_len
= tmp_len
- 64;
13042 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13044 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13046 char *ptr
= (char *) salt
->salt_buf
;
13048 ptr
[salt
->salt_len
] = 0x80;
13051 return (PARSER_OK
);
13054 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13056 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13058 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13062 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13065 u32
*digest
= (u32
*) hash_buf
->digest
;
13067 salt_t
*salt
= hash_buf
->salt
;
13069 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13070 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13071 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13072 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13074 digest
[0] = byte_swap_32 (digest
[0]);
13075 digest
[1] = byte_swap_32 (digest
[1]);
13076 digest
[2] = byte_swap_32 (digest
[2]);
13077 digest
[3] = byte_swap_32 (digest
[3]);
13079 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13081 uint salt_len
= input_len
- 32 - 1;
13083 char *salt_buf
= input_buf
+ 32 + 1;
13085 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13087 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13089 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13091 salt
->salt_len
= salt_len
;
13093 return (PARSER_OK
);
13096 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13098 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13100 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13104 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13107 u32
*digest
= (u32
*) hash_buf
->digest
;
13109 salt_t
*salt
= hash_buf
->salt
;
13111 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13112 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13113 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13114 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13115 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13117 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13119 uint salt_len
= input_len
- 40 - 1;
13121 char *salt_buf
= input_buf
+ 40 + 1;
13123 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13125 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13127 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13129 salt
->salt_len
= salt_len
;
13131 return (PARSER_OK
);
13134 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13136 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13138 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13142 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13145 u32
*digest
= (u32
*) hash_buf
->digest
;
13147 salt_t
*salt
= hash_buf
->salt
;
13149 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13150 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13151 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13152 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13153 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13154 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13155 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13156 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13158 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13160 uint salt_len
= input_len
- 64 - 1;
13162 char *salt_buf
= input_buf
+ 64 + 1;
13164 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13166 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13168 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13170 salt
->salt_len
= salt_len
;
13172 return (PARSER_OK
);
13175 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13177 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13179 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13183 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13186 u64
*digest
= (u64
*) hash_buf
->digest
;
13188 salt_t
*salt
= hash_buf
->salt
;
13190 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13191 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13192 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13193 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13194 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13195 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13196 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13197 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13199 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13201 uint salt_len
= input_len
- 128 - 1;
13203 char *salt_buf
= input_buf
+ 128 + 1;
13205 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13207 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13209 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13211 salt
->salt_len
= salt_len
;
13213 return (PARSER_OK
);
13216 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13218 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13220 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13222 u32
*digest
= (u32
*) hash_buf
->digest
;
13224 salt_t
*salt
= hash_buf
->salt
;
13226 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13232 char *user_pos
= input_buf
+ 10 + 1;
13234 char *realm_pos
= strchr (user_pos
, '$');
13236 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13238 uint user_len
= realm_pos
- user_pos
;
13240 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13244 char *salt_pos
= strchr (realm_pos
, '$');
13246 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13248 uint realm_len
= salt_pos
- realm_pos
;
13250 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13254 char *data_pos
= strchr (salt_pos
, '$');
13256 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13258 uint salt_len
= data_pos
- salt_pos
;
13260 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13264 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13266 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13272 memcpy (krb5pa
->user
, user_pos
, user_len
);
13273 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13274 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13276 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13278 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13280 const char p0
= data_pos
[i
+ 0];
13281 const char p1
= data_pos
[i
+ 1];
13283 *timestamp_ptr
++ = hex_convert (p1
) << 0
13284 | hex_convert (p0
) << 4;
13287 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13289 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13291 const char p0
= data_pos
[i
+ 0];
13292 const char p1
= data_pos
[i
+ 1];
13294 *checksum_ptr
++ = hex_convert (p1
) << 0
13295 | hex_convert (p0
) << 4;
13299 * copy some data to generic buffers to make sorting happy
13302 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13303 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13304 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13305 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13306 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13307 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13308 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13309 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13310 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13312 salt
->salt_len
= 36;
13314 digest
[0] = krb5pa
->checksum
[0];
13315 digest
[1] = krb5pa
->checksum
[1];
13316 digest
[2] = krb5pa
->checksum
[2];
13317 digest
[3] = krb5pa
->checksum
[3];
13319 return (PARSER_OK
);
13322 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13324 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13326 u32
*digest
= (u32
*) hash_buf
->digest
;
13328 salt_t
*salt
= hash_buf
->salt
;
13334 char *salt_pos
= input_buf
;
13336 char *hash_pos
= strchr (salt_pos
, '$');
13338 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13340 uint salt_len
= hash_pos
- salt_pos
;
13342 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13346 uint hash_len
= input_len
- 1 - salt_len
;
13348 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13356 for (uint i
= 0; i
< salt_len
; i
++)
13358 if (salt_pos
[i
] == ' ') continue;
13363 // SAP user names cannot be longer than 12 characters
13364 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13366 // SAP user name cannot start with ! or ?
13367 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13373 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13375 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13377 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13379 salt
->salt_len
= salt_len
;
13381 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13382 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13386 digest
[0] = byte_swap_32 (digest
[0]);
13387 digest
[1] = byte_swap_32 (digest
[1]);
13389 return (PARSER_OK
);
13392 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13394 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13396 u32
*digest
= (u32
*) hash_buf
->digest
;
13398 salt_t
*salt
= hash_buf
->salt
;
13404 char *salt_pos
= input_buf
;
13406 char *hash_pos
= strchr (salt_pos
, '$');
13408 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13410 uint salt_len
= hash_pos
- salt_pos
;
13412 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13416 uint hash_len
= input_len
- 1 - salt_len
;
13418 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13426 for (uint i
= 0; i
< salt_len
; i
++)
13428 if (salt_pos
[i
] == ' ') continue;
13433 // SAP user names cannot be longer than 12 characters
13434 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13435 // so far nobody complained so we stay with this because it helps in optimization
13436 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13438 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13440 // SAP user name cannot start with ! or ?
13441 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13447 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13449 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13451 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13453 salt
->salt_len
= salt_len
;
13455 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13456 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13457 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13458 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13459 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13461 return (PARSER_OK
);
13464 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13466 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13468 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13470 u64
*digest
= (u64
*) hash_buf
->digest
;
13472 salt_t
*salt
= hash_buf
->salt
;
13474 char *iter_pos
= input_buf
+ 3;
13476 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13478 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13480 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13482 salt
->salt_iter
= salt_iter
;
13484 char *salt_pos
= iter_pos
+ 1;
13488 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13490 salt
->salt_len
= salt_len
;
13492 char *hash_pos
= salt_pos
+ salt_len
;
13494 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13498 char *tmp
= (char *) salt
->salt_buf_pc
;
13500 tmp
[0] = hash_pos
[42];
13504 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13505 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13506 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13507 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13513 return (PARSER_OK
);
13516 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13518 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13520 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13522 u32
*digest
= (u32
*) hash_buf
->digest
;
13524 salt_t
*salt
= hash_buf
->salt
;
13526 char *salt_buf
= input_buf
+ 6;
13528 uint salt_len
= 16;
13530 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13532 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13534 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13536 salt
->salt_len
= salt_len
;
13538 char *hash_pos
= input_buf
+ 6 + 16;
13540 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13541 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13542 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13543 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13544 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13545 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13546 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13547 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13549 return (PARSER_OK
);
13552 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13554 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13556 u32
*digest
= (u32
*) hash_buf
->digest
;
13558 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13559 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13563 return (PARSER_OK
);
13566 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13568 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13570 u32
*digest
= (u32
*) hash_buf
->digest
;
13572 salt_t
*salt
= hash_buf
->salt
;
13574 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13576 char *saltbuf_pos
= input_buf
;
13578 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13580 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13582 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13584 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13585 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13587 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13591 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13593 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13595 char *salt_ptr
= (char *) saltbuf_pos
;
13596 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13601 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13603 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13606 rakp_ptr
[j
] = 0x80;
13608 rakp
->salt_len
= j
;
13610 for (i
= 0; i
< 64; i
++)
13612 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13615 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13616 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13617 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13618 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13619 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13620 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13621 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13622 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13624 salt
->salt_len
= 32; // muss min. 32 haben
13626 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13627 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13628 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13629 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13630 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13632 return (PARSER_OK
);
13635 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13637 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13639 u32
*digest
= (u32
*) hash_buf
->digest
;
13641 salt_t
*salt
= hash_buf
->salt
;
13643 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13645 char *salt_pos
= input_buf
+ 1;
13647 memcpy (salt
->salt_buf
, salt_pos
, 8);
13649 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13650 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13652 salt
->salt_len
= 8;
13654 char *hash_pos
= salt_pos
+ 8;
13656 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13657 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13658 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13659 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13660 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13662 digest
[0] -= SHA1M_A
;
13663 digest
[1] -= SHA1M_B
;
13664 digest
[2] -= SHA1M_C
;
13665 digest
[3] -= SHA1M_D
;
13666 digest
[4] -= SHA1M_E
;
13668 return (PARSER_OK
);
13671 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13673 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13675 u32
*digest
= (u32
*) hash_buf
->digest
;
13677 salt_t
*salt
= hash_buf
->salt
;
13679 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13680 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13681 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13682 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13684 digest
[0] = byte_swap_32 (digest
[0]);
13685 digest
[1] = byte_swap_32 (digest
[1]);
13686 digest
[2] = byte_swap_32 (digest
[2]);
13687 digest
[3] = byte_swap_32 (digest
[3]);
13689 digest
[0] -= MD5M_A
;
13690 digest
[1] -= MD5M_B
;
13691 digest
[2] -= MD5M_C
;
13692 digest
[3] -= MD5M_D
;
13694 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13696 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13698 u32
*salt_buf
= salt
->salt_buf
;
13700 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
13701 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
13702 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
13703 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
13705 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13706 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13707 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13708 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13710 salt
->salt_len
= 16 + 1;
13712 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13714 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13716 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
13718 return (PARSER_OK
);
13721 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13723 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13725 u32
*digest
= (u32
*) hash_buf
->digest
;
13727 salt_t
*salt
= hash_buf
->salt
;
13729 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13735 char *hashbuf_pos
= input_buf
;
13737 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13739 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13741 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13743 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13747 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13749 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13751 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13753 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13757 char *databuf_pos
= strchr (iteration_pos
, ':');
13759 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13761 const uint iteration_len
= databuf_pos
- iteration_pos
;
13763 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13764 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13766 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13768 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13769 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13775 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13776 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13777 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13778 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13779 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13780 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
13781 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
13782 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
13786 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13788 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13790 const char p0
= saltbuf_pos
[i
+ 0];
13791 const char p1
= saltbuf_pos
[i
+ 1];
13793 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13794 | hex_convert (p0
) << 4;
13797 salt
->salt_buf
[4] = 0x01000000;
13798 salt
->salt_buf
[5] = 0x80;
13800 salt
->salt_len
= saltbuf_len
/ 2;
13804 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13808 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13810 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13812 const char p0
= databuf_pos
[i
+ 0];
13813 const char p1
= databuf_pos
[i
+ 1];
13815 *databuf_ptr
++ = hex_convert (p1
) << 0
13816 | hex_convert (p0
) << 4;
13819 *databuf_ptr
++ = 0x80;
13821 for (uint i
= 0; i
< 512; i
++)
13823 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13826 cloudkey
->data_len
= databuf_len
/ 2;
13828 return (PARSER_OK
);
13831 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13833 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13835 u32
*digest
= (u32
*) hash_buf
->digest
;
13837 salt_t
*salt
= hash_buf
->salt
;
13843 char *hashbuf_pos
= input_buf
;
13845 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13847 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13849 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13851 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13855 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13857 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13859 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13861 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13863 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13867 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13869 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13871 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13873 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13875 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13879 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13881 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13882 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13884 // ok, the plan for this algorithm is the following:
13885 // we have 2 salts here, the domain-name and a random salt
13886 // while both are used in the initial transformation,
13887 // only the random salt is used in the following iterations
13888 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13889 // and one that includes only the real salt (stored into salt_buf[]).
13890 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13892 u8 tmp_buf
[100] = { 0 };
13894 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
13896 memcpy (digest
, tmp_buf
, 20);
13898 digest
[0] = byte_swap_32 (digest
[0]);
13899 digest
[1] = byte_swap_32 (digest
[1]);
13900 digest
[2] = byte_swap_32 (digest
[2]);
13901 digest
[3] = byte_swap_32 (digest
[3]);
13902 digest
[4] = byte_swap_32 (digest
[4]);
13906 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13908 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
13910 char *len_ptr
= NULL
;
13912 for (uint i
= 0; i
< domainbuf_len
; i
++)
13914 if (salt_buf_pc_ptr
[i
] == '.')
13916 len_ptr
= &salt_buf_pc_ptr
[i
];
13926 salt
->salt_buf_pc
[7] = domainbuf_len
;
13930 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13932 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
13934 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13936 salt
->salt_len
= salt_len
;
13940 salt
->salt_iter
= atoi (iteration_pos
);
13942 return (PARSER_OK
);
13945 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13947 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
13949 u32
*digest
= (u32
*) hash_buf
->digest
;
13951 salt_t
*salt
= hash_buf
->salt
;
13953 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13954 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13955 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13956 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13957 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13959 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13961 uint salt_len
= input_len
- 40 - 1;
13963 char *salt_buf
= input_buf
+ 40 + 1;
13965 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13967 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13969 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13971 salt
->salt_len
= salt_len
;
13973 return (PARSER_OK
);
13976 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13978 const u8 ascii_to_ebcdic
[] =
13980 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
13981 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
13982 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
13983 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
13984 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
13985 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
13986 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
13987 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
13988 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
13989 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
13990 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
13991 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
13992 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
13993 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
13994 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
13995 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
13998 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14000 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14002 u32
*digest
= (u32
*) hash_buf
->digest
;
14004 salt_t
*salt
= hash_buf
->salt
;
14006 char *salt_pos
= input_buf
+ 6 + 1;
14008 char *digest_pos
= strchr (salt_pos
, '*');
14010 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14012 uint salt_len
= digest_pos
- salt_pos
;
14014 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14016 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14018 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14022 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14023 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14025 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14027 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14029 salt
->salt_len
= salt_len
;
14031 for (uint i
= 0; i
< salt_len
; i
++)
14033 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14035 for (uint i
= salt_len
; i
< 8; i
++)
14037 salt_buf_pc_ptr
[i
] = 0x40;
14042 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14044 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14045 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14047 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14048 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14050 digest
[0] = byte_swap_32 (digest
[0]);
14051 digest
[1] = byte_swap_32 (digest
[1]);
14053 IP (digest
[0], digest
[1], tt
);
14055 digest
[0] = rotr32 (digest
[0], 29);
14056 digest
[1] = rotr32 (digest
[1], 29);
14060 return (PARSER_OK
);
14063 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14065 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14067 u32
*digest
= (u32
*) hash_buf
->digest
;
14069 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14070 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14071 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14072 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14074 digest
[0] = byte_swap_32 (digest
[0]);
14075 digest
[1] = byte_swap_32 (digest
[1]);
14076 digest
[2] = byte_swap_32 (digest
[2]);
14077 digest
[3] = byte_swap_32 (digest
[3]);
14079 return (PARSER_OK
);
14082 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14084 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14086 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14088 u32
*digest
= (u32
*) hash_buf
->digest
;
14090 salt_t
*salt
= hash_buf
->salt
;
14092 u8 tmp_buf
[120] = { 0 };
14094 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14096 tmp_buf
[3] += -4; // dont ask!
14098 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14100 salt
->salt_len
= 5;
14102 memcpy (digest
, tmp_buf
+ 5, 9);
14104 // yes, only 9 byte are needed to crack, but 10 to display
14106 salt
->salt_buf_pc
[7] = input_buf
[20];
14108 return (PARSER_OK
);
14111 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14113 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14115 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14117 u32
*digest
= (u32
*) hash_buf
->digest
;
14119 salt_t
*salt
= hash_buf
->salt
;
14121 u8 tmp_buf
[120] = { 0 };
14123 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14125 tmp_buf
[3] += -4; // dont ask!
14129 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14131 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)
14135 char tmp_iter_buf
[11] = { 0 };
14137 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14139 tmp_iter_buf
[10] = 0;
14141 salt
->salt_iter
= atoi (tmp_iter_buf
);
14143 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14145 return (PARSER_SALT_ITERATION
);
14148 salt
->salt_iter
--; // first round in init
14150 // 2 additional bytes for display only
14152 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14153 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14157 memcpy (digest
, tmp_buf
+ 28, 8);
14159 digest
[0] = byte_swap_32 (digest
[0]);
14160 digest
[1] = byte_swap_32 (digest
[1]);
14164 return (PARSER_OK
);
14167 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14169 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14171 u32
*digest
= (u32
*) hash_buf
->digest
;
14173 salt_t
*salt
= hash_buf
->salt
;
14175 char *salt_buf_pos
= input_buf
;
14177 char *hash_buf_pos
= salt_buf_pos
+ 6;
14179 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14180 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14181 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14182 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14183 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14184 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14185 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14186 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14188 digest
[0] -= SHA256M_A
;
14189 digest
[1] -= SHA256M_B
;
14190 digest
[2] -= SHA256M_C
;
14191 digest
[3] -= SHA256M_D
;
14192 digest
[4] -= SHA256M_E
;
14193 digest
[5] -= SHA256M_F
;
14194 digest
[6] -= SHA256M_G
;
14195 digest
[7] -= SHA256M_H
;
14197 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14199 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14201 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14203 salt
->salt_len
= salt_len
;
14205 return (PARSER_OK
);
14208 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14210 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14212 u32
*digest
= (u32
*) hash_buf
->digest
;
14214 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14216 salt_t
*salt
= hash_buf
->salt
;
14218 char *salt_buf
= input_buf
+ 6;
14220 char *digest_buf
= strchr (salt_buf
, '$');
14222 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14224 uint salt_len
= digest_buf
- salt_buf
;
14226 digest_buf
++; // skip the '$' symbol
14228 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14230 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14232 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14234 salt
->salt_len
= salt_len
;
14236 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14237 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14238 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14239 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14241 digest
[0] = byte_swap_32 (digest
[0]);
14242 digest
[1] = byte_swap_32 (digest
[1]);
14243 digest
[2] = byte_swap_32 (digest
[2]);
14244 digest
[3] = byte_swap_32 (digest
[3]);
14246 digest
[0] -= MD5M_A
;
14247 digest
[1] -= MD5M_B
;
14248 digest
[2] -= MD5M_C
;
14249 digest
[3] -= MD5M_D
;
14251 return (PARSER_OK
);
14254 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14256 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14258 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14260 u32
*digest
= (u32
*) hash_buf
->digest
;
14262 salt_t
*salt
= hash_buf
->salt
;
14264 char *salt_buf
= input_buf
+ 3;
14266 char *digest_buf
= strchr (salt_buf
, '$');
14268 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14270 uint salt_len
= digest_buf
- salt_buf
;
14272 digest_buf
++; // skip the '$' symbol
14274 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14276 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14278 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14280 salt_buf_ptr
[salt_len
] = 0x2d;
14282 salt
->salt_len
= salt_len
+ 1;
14284 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14285 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14286 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14287 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14289 digest
[0] = byte_swap_32 (digest
[0]);
14290 digest
[1] = byte_swap_32 (digest
[1]);
14291 digest
[2] = byte_swap_32 (digest
[2]);
14292 digest
[3] = byte_swap_32 (digest
[3]);
14294 digest
[0] -= MD5M_A
;
14295 digest
[1] -= MD5M_B
;
14296 digest
[2] -= MD5M_C
;
14297 digest
[3] -= MD5M_D
;
14299 return (PARSER_OK
);
14302 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14304 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14306 u32
*digest
= (u32
*) hash_buf
->digest
;
14308 u8 tmp_buf
[100] = { 0 };
14310 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14312 memcpy (digest
, tmp_buf
, 20);
14314 digest
[0] = byte_swap_32 (digest
[0]);
14315 digest
[1] = byte_swap_32 (digest
[1]);
14316 digest
[2] = byte_swap_32 (digest
[2]);
14317 digest
[3] = byte_swap_32 (digest
[3]);
14318 digest
[4] = byte_swap_32 (digest
[4]);
14320 digest
[0] -= SHA1M_A
;
14321 digest
[1] -= SHA1M_B
;
14322 digest
[2] -= SHA1M_C
;
14323 digest
[3] -= SHA1M_D
;
14324 digest
[4] -= SHA1M_E
;
14326 return (PARSER_OK
);
14329 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14331 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14333 u32
*digest
= (u32
*) hash_buf
->digest
;
14335 salt_t
*salt
= hash_buf
->salt
;
14337 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14338 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14339 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14340 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14342 digest
[0] = byte_swap_32 (digest
[0]);
14343 digest
[1] = byte_swap_32 (digest
[1]);
14344 digest
[2] = byte_swap_32 (digest
[2]);
14345 digest
[3] = byte_swap_32 (digest
[3]);
14347 digest
[0] -= MD5M_A
;
14348 digest
[1] -= MD5M_B
;
14349 digest
[2] -= MD5M_C
;
14350 digest
[3] -= MD5M_D
;
14352 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14354 uint salt_len
= input_len
- 32 - 1;
14356 char *salt_buf
= input_buf
+ 32 + 1;
14358 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14360 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14362 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14365 * add static "salt" part
14368 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14372 salt
->salt_len
= salt_len
;
14374 return (PARSER_OK
);
14377 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14379 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14381 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14383 u32
*digest
= (u32
*) hash_buf
->digest
;
14385 salt_t
*salt
= hash_buf
->salt
;
14387 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14393 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14395 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14397 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14399 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14401 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14405 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14407 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14409 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14411 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14415 char *keybuf_pos
= strchr (keylen_pos
, '$');
14417 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14419 uint keylen_len
= keybuf_pos
- keylen_pos
;
14421 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14425 char *databuf_pos
= strchr (keybuf_pos
, '$');
14427 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14429 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14431 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14435 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14437 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14443 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14444 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14445 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14446 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14448 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14449 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14450 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14451 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14453 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14454 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14455 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14456 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14458 salt
->salt_len
= 16;
14459 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14461 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14463 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14466 return (PARSER_OK
);
14469 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14471 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14473 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14475 u32
*digest
= (u32
*) hash_buf
->digest
;
14477 salt_t
*salt
= hash_buf
->salt
;
14483 // first is the N salt parameter
14485 char *N_pos
= input_buf
+ 6;
14487 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14491 salt
->scrypt_N
= atoi (N_pos
);
14495 char *r_pos
= strchr (N_pos
, ':');
14497 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14501 salt
->scrypt_r
= atoi (r_pos
);
14505 char *p_pos
= strchr (r_pos
, ':');
14507 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14511 salt
->scrypt_p
= atoi (p_pos
);
14515 char *saltbuf_pos
= strchr (p_pos
, ':');
14517 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14521 char *hash_pos
= strchr (saltbuf_pos
, ':');
14523 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14529 u8 tmp_buf
[33] = { 0 };
14531 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14533 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14535 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14537 salt
->salt_len
= tmp_len
;
14538 salt
->salt_iter
= 1;
14540 // digest - base64 decode
14542 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14544 tmp_len
= input_len
- (hash_pos
- input_buf
);
14546 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14548 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14550 memcpy (digest
, tmp_buf
, 32);
14552 return (PARSER_OK
);
14555 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14557 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14559 u32
*digest
= (u32
*) hash_buf
->digest
;
14561 salt_t
*salt
= hash_buf
->salt
;
14567 char decrypted
[76] = { 0 }; // iv + hash
14569 juniper_decrypt_hash (input_buf
, decrypted
);
14571 char *md5crypt_hash
= decrypted
+ 12;
14573 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14575 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14577 char *salt_pos
= md5crypt_hash
+ 3;
14579 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14581 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14583 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14587 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14589 return (PARSER_OK
);
14592 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14594 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14596 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14598 u32
*digest
= (u32
*) hash_buf
->digest
;
14600 salt_t
*salt
= hash_buf
->salt
;
14602 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14608 // first is *raw* salt
14610 char *salt_pos
= input_buf
+ 3;
14612 char *hash_pos
= strchr (salt_pos
, '$');
14614 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14616 uint salt_len
= hash_pos
- salt_pos
;
14618 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14622 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14624 memcpy (salt_buf_ptr
, salt_pos
, 14);
14626 salt_buf_ptr
[17] = 0x01;
14627 salt_buf_ptr
[18] = 0x80;
14629 // add some stuff to normal salt to make sorted happy
14631 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14632 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14633 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14634 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14636 salt
->salt_len
= salt_len
;
14637 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14639 // base64 decode hash
14641 u8 tmp_buf
[100] = { 0 };
14643 uint hash_len
= input_len
- 3 - salt_len
- 1;
14645 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14647 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14649 memcpy (digest
, tmp_buf
, 32);
14651 digest
[0] = byte_swap_32 (digest
[0]);
14652 digest
[1] = byte_swap_32 (digest
[1]);
14653 digest
[2] = byte_swap_32 (digest
[2]);
14654 digest
[3] = byte_swap_32 (digest
[3]);
14655 digest
[4] = byte_swap_32 (digest
[4]);
14656 digest
[5] = byte_swap_32 (digest
[5]);
14657 digest
[6] = byte_swap_32 (digest
[6]);
14658 digest
[7] = byte_swap_32 (digest
[7]);
14660 return (PARSER_OK
);
14663 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14665 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14667 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14669 u32
*digest
= (u32
*) hash_buf
->digest
;
14671 salt_t
*salt
= hash_buf
->salt
;
14677 // first is *raw* salt
14679 char *salt_pos
= input_buf
+ 3;
14681 char *hash_pos
= strchr (salt_pos
, '$');
14683 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14685 uint salt_len
= hash_pos
- salt_pos
;
14687 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14689 salt
->salt_len
= salt_len
;
14692 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14694 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14695 salt_buf_ptr
[salt_len
] = 0;
14697 // base64 decode hash
14699 u8 tmp_buf
[100] = { 0 };
14701 uint hash_len
= input_len
- 3 - salt_len
- 1;
14703 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14705 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14707 memcpy (digest
, tmp_buf
, 32);
14710 salt
->scrypt_N
= 16384;
14711 salt
->scrypt_r
= 1;
14712 salt
->scrypt_p
= 1;
14713 salt
->salt_iter
= 1;
14715 return (PARSER_OK
);
14718 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14720 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14722 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14724 u32
*digest
= (u32
*) hash_buf
->digest
;
14726 salt_t
*salt
= hash_buf
->salt
;
14728 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14734 char *version_pos
= input_buf
+ 8 + 1;
14736 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14738 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14740 u32 version_len
= verifierHashSize_pos
- version_pos
;
14742 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14744 verifierHashSize_pos
++;
14746 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14748 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14750 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14752 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14756 char *saltSize_pos
= strchr (keySize_pos
, '*');
14758 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14760 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14762 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14766 char *osalt_pos
= strchr (saltSize_pos
, '*');
14768 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14770 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14772 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14776 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14778 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14780 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14782 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14784 encryptedVerifier_pos
++;
14786 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14788 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14790 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14792 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14794 encryptedVerifierHash_pos
++;
14796 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;
14798 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14800 const uint version
= atoi (version_pos
);
14802 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14804 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14806 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14808 const uint keySize
= atoi (keySize_pos
);
14810 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14812 office2007
->keySize
= keySize
;
14814 const uint saltSize
= atoi (saltSize_pos
);
14816 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14822 salt
->salt_len
= 16;
14823 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14825 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
14826 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
14827 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
14828 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
14834 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
14835 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
14836 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
14837 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
14839 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
14840 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
14841 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
14842 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
14843 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
14849 digest
[0] = office2007
->encryptedVerifierHash
[0];
14850 digest
[1] = office2007
->encryptedVerifierHash
[1];
14851 digest
[2] = office2007
->encryptedVerifierHash
[2];
14852 digest
[3] = office2007
->encryptedVerifierHash
[3];
14854 return (PARSER_OK
);
14857 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14859 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14861 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14863 u32
*digest
= (u32
*) hash_buf
->digest
;
14865 salt_t
*salt
= hash_buf
->salt
;
14867 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14873 char *version_pos
= input_buf
+ 8 + 1;
14875 char *spinCount_pos
= strchr (version_pos
, '*');
14877 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14879 u32 version_len
= spinCount_pos
- version_pos
;
14881 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14885 char *keySize_pos
= strchr (spinCount_pos
, '*');
14887 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14889 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
14891 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14895 char *saltSize_pos
= strchr (keySize_pos
, '*');
14897 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14899 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14901 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14905 char *osalt_pos
= strchr (saltSize_pos
, '*');
14907 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14909 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14911 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14915 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14917 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14919 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14921 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14923 encryptedVerifier_pos
++;
14925 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14927 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14929 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14931 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14933 encryptedVerifierHash_pos
++;
14935 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;
14937 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14939 const uint version
= atoi (version_pos
);
14941 if (version
!= 2010) return (PARSER_SALT_VALUE
);
14943 const uint spinCount
= atoi (spinCount_pos
);
14945 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
14947 const uint keySize
= atoi (keySize_pos
);
14949 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
14951 const uint saltSize
= atoi (saltSize_pos
);
14953 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14959 salt
->salt_len
= 16;
14960 salt
->salt_iter
= spinCount
;
14962 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
14963 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
14964 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
14965 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
14971 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
14972 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
14973 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
14974 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
14976 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
14977 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
14978 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
14979 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
14980 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
14981 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
14982 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
14983 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
14989 digest
[0] = office2010
->encryptedVerifierHash
[0];
14990 digest
[1] = office2010
->encryptedVerifierHash
[1];
14991 digest
[2] = office2010
->encryptedVerifierHash
[2];
14992 digest
[3] = office2010
->encryptedVerifierHash
[3];
14994 return (PARSER_OK
);
14997 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14999 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15001 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15003 u32
*digest
= (u32
*) hash_buf
->digest
;
15005 salt_t
*salt
= hash_buf
->salt
;
15007 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15013 char *version_pos
= input_buf
+ 8 + 1;
15015 char *spinCount_pos
= strchr (version_pos
, '*');
15017 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15019 u32 version_len
= spinCount_pos
- version_pos
;
15021 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15025 char *keySize_pos
= strchr (spinCount_pos
, '*');
15027 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15029 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15031 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15035 char *saltSize_pos
= strchr (keySize_pos
, '*');
15037 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15039 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15041 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15045 char *osalt_pos
= strchr (saltSize_pos
, '*');
15047 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15049 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15051 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15055 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15057 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15059 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15061 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15063 encryptedVerifier_pos
++;
15065 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15067 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15069 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15071 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15073 encryptedVerifierHash_pos
++;
15075 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;
15077 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15079 const uint version
= atoi (version_pos
);
15081 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15083 const uint spinCount
= atoi (spinCount_pos
);
15085 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15087 const uint keySize
= atoi (keySize_pos
);
15089 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15091 const uint saltSize
= atoi (saltSize_pos
);
15093 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15099 salt
->salt_len
= 16;
15100 salt
->salt_iter
= spinCount
;
15102 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15103 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15104 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15105 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15111 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15112 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15113 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15114 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15116 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15117 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15118 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15119 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15120 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15121 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15122 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15123 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15129 digest
[0] = office2013
->encryptedVerifierHash
[0];
15130 digest
[1] = office2013
->encryptedVerifierHash
[1];
15131 digest
[2] = office2013
->encryptedVerifierHash
[2];
15132 digest
[3] = office2013
->encryptedVerifierHash
[3];
15134 return (PARSER_OK
);
15137 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15139 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15141 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15143 u32
*digest
= (u32
*) hash_buf
->digest
;
15145 salt_t
*salt
= hash_buf
->salt
;
15147 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15153 char *version_pos
= input_buf
+ 11;
15155 char *osalt_pos
= strchr (version_pos
, '*');
15157 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15159 u32 version_len
= osalt_pos
- version_pos
;
15161 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15165 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15167 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15169 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15171 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15173 encryptedVerifier_pos
++;
15175 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15177 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15179 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15181 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15183 encryptedVerifierHash_pos
++;
15185 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15187 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15189 const uint version
= *version_pos
- 0x30;
15191 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15197 oldoffice01
->version
= version
;
15199 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15200 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15201 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15202 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15204 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15205 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15206 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15207 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15209 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15210 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15211 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15212 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15214 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15215 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15216 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15217 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15223 salt
->salt_len
= 16;
15225 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15226 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15227 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15228 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15230 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15231 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15232 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15233 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15235 // this is a workaround as office produces multiple documents with the same salt
15237 salt
->salt_len
+= 32;
15239 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15240 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15241 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15242 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15243 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15244 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15245 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15246 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15252 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15253 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15254 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15255 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15257 return (PARSER_OK
);
15260 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15262 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15265 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15267 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15269 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15271 u32
*digest
= (u32
*) hash_buf
->digest
;
15273 salt_t
*salt
= hash_buf
->salt
;
15275 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15281 char *version_pos
= input_buf
+ 11;
15283 char *osalt_pos
= strchr (version_pos
, '*');
15285 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15287 u32 version_len
= osalt_pos
- version_pos
;
15289 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15293 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15295 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15297 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15299 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15301 encryptedVerifier_pos
++;
15303 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15305 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15307 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15309 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15311 encryptedVerifierHash_pos
++;
15313 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15315 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15317 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15319 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15323 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15325 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15327 const uint version
= *version_pos
- 0x30;
15329 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15335 oldoffice01
->version
= version
;
15337 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15338 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15339 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15340 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15342 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15343 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15344 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15345 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15347 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15348 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15349 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15350 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15352 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15353 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15354 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15355 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15357 oldoffice01
->rc4key
[1] = 0;
15358 oldoffice01
->rc4key
[0] = 0;
15360 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15361 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15362 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15363 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15364 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15365 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15366 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15367 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15368 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15369 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15371 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15372 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15378 salt
->salt_len
= 16;
15380 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15381 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15382 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15383 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15385 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15386 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15387 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15388 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15390 // this is a workaround as office produces multiple documents with the same salt
15392 salt
->salt_len
+= 32;
15394 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15395 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15396 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15397 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15398 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15399 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15400 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15401 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15407 digest
[0] = oldoffice01
->rc4key
[0];
15408 digest
[1] = oldoffice01
->rc4key
[1];
15412 return (PARSER_OK
);
15415 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15417 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15419 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15421 u32
*digest
= (u32
*) hash_buf
->digest
;
15423 salt_t
*salt
= hash_buf
->salt
;
15425 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15431 char *version_pos
= input_buf
+ 11;
15433 char *osalt_pos
= strchr (version_pos
, '*');
15435 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15437 u32 version_len
= osalt_pos
- version_pos
;
15439 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15443 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15445 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15447 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15449 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15451 encryptedVerifier_pos
++;
15453 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15455 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15457 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15459 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15461 encryptedVerifierHash_pos
++;
15463 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15465 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15467 const uint version
= *version_pos
- 0x30;
15469 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15475 oldoffice34
->version
= version
;
15477 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15478 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15479 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15480 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15482 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15483 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15484 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15485 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15487 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15488 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15489 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15490 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15491 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15493 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15494 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15495 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15496 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15497 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15503 salt
->salt_len
= 16;
15505 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15506 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15507 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15508 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15510 // this is a workaround as office produces multiple documents with the same salt
15512 salt
->salt_len
+= 32;
15514 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15515 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15516 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15517 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15518 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15519 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15520 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15521 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15527 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15528 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15529 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15530 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15532 return (PARSER_OK
);
15535 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15537 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15539 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15542 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15544 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15546 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15548 u32
*digest
= (u32
*) hash_buf
->digest
;
15550 salt_t
*salt
= hash_buf
->salt
;
15552 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15558 char *version_pos
= input_buf
+ 11;
15560 char *osalt_pos
= strchr (version_pos
, '*');
15562 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15564 u32 version_len
= osalt_pos
- version_pos
;
15566 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15570 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15572 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15574 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15576 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15578 encryptedVerifier_pos
++;
15580 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15582 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15584 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15586 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15588 encryptedVerifierHash_pos
++;
15590 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15592 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15594 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15596 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15600 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15602 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15604 const uint version
= *version_pos
- 0x30;
15606 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15612 oldoffice34
->version
= version
;
15614 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15615 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15616 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15617 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15619 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15620 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15621 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15622 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15624 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15625 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15626 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15627 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15628 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15630 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15631 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15632 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15633 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15634 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15636 oldoffice34
->rc4key
[1] = 0;
15637 oldoffice34
->rc4key
[0] = 0;
15639 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15640 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15641 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15642 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15643 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15644 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15645 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15646 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15647 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15648 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15650 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15651 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15657 salt
->salt_len
= 16;
15659 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15660 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15661 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15662 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15664 // this is a workaround as office produces multiple documents with the same salt
15666 salt
->salt_len
+= 32;
15668 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15669 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15670 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15671 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15672 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15673 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15674 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15675 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15681 digest
[0] = oldoffice34
->rc4key
[0];
15682 digest
[1] = oldoffice34
->rc4key
[1];
15686 return (PARSER_OK
);
15689 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15691 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15693 u32
*digest
= (u32
*) hash_buf
->digest
;
15695 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15696 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15697 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15698 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15700 digest
[0] = byte_swap_32 (digest
[0]);
15701 digest
[1] = byte_swap_32 (digest
[1]);
15702 digest
[2] = byte_swap_32 (digest
[2]);
15703 digest
[3] = byte_swap_32 (digest
[3]);
15705 return (PARSER_OK
);
15708 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15710 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15712 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15714 u32
*digest
= (u32
*) hash_buf
->digest
;
15716 salt_t
*salt
= hash_buf
->salt
;
15718 char *signature_pos
= input_buf
;
15720 char *salt_pos
= strchr (signature_pos
, '$');
15722 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15724 u32 signature_len
= salt_pos
- signature_pos
;
15726 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15730 char *hash_pos
= strchr (salt_pos
, '$');
15732 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15734 u32 salt_len
= hash_pos
- salt_pos
;
15736 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15740 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15742 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15744 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
15745 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
15746 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
15747 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
15748 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
15750 digest
[0] -= SHA1M_A
;
15751 digest
[1] -= SHA1M_B
;
15752 digest
[2] -= SHA1M_C
;
15753 digest
[3] -= SHA1M_D
;
15754 digest
[4] -= SHA1M_E
;
15756 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15758 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15760 salt
->salt_len
= salt_len
;
15762 return (PARSER_OK
);
15765 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15767 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15769 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15771 u32
*digest
= (u32
*) hash_buf
->digest
;
15773 salt_t
*salt
= hash_buf
->salt
;
15775 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15781 char *iter_pos
= input_buf
+ 14;
15783 const int iter
= atoi (iter_pos
);
15785 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15787 salt
->salt_iter
= iter
- 1;
15789 char *salt_pos
= strchr (iter_pos
, '$');
15791 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15795 char *hash_pos
= strchr (salt_pos
, '$');
15797 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15799 const uint salt_len
= hash_pos
- salt_pos
;
15803 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15805 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15807 salt
->salt_len
= salt_len
;
15809 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15810 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15812 // add some stuff to normal salt to make sorted happy
15814 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15815 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15816 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15817 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15818 salt
->salt_buf
[4] = salt
->salt_iter
;
15820 // base64 decode hash
15822 u8 tmp_buf
[100] = { 0 };
15824 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15826 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15828 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15830 memcpy (digest
, tmp_buf
, 32);
15832 digest
[0] = byte_swap_32 (digest
[0]);
15833 digest
[1] = byte_swap_32 (digest
[1]);
15834 digest
[2] = byte_swap_32 (digest
[2]);
15835 digest
[3] = byte_swap_32 (digest
[3]);
15836 digest
[4] = byte_swap_32 (digest
[4]);
15837 digest
[5] = byte_swap_32 (digest
[5]);
15838 digest
[6] = byte_swap_32 (digest
[6]);
15839 digest
[7] = byte_swap_32 (digest
[7]);
15841 return (PARSER_OK
);
15844 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15846 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15848 u32
*digest
= (u32
*) hash_buf
->digest
;
15850 salt_t
*salt
= hash_buf
->salt
;
15852 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15853 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15857 digest
[0] = byte_swap_32 (digest
[0]);
15858 digest
[1] = byte_swap_32 (digest
[1]);
15860 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15861 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15862 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15864 char iter_c
= input_buf
[17];
15865 char iter_d
= input_buf
[19];
15867 // atm only defaults, let's see if there's more request
15868 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15869 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15871 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15873 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
15874 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
15875 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
15876 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
15878 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15879 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15880 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15881 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15883 salt
->salt_len
= 16;
15885 return (PARSER_OK
);
15888 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15890 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
15892 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15894 u32
*digest
= (u32
*) hash_buf
->digest
;
15896 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
15898 salt_t
*salt
= hash_buf
->salt
;
15900 char *salt_pos
= input_buf
+ 10;
15902 char *hash_pos
= strchr (salt_pos
, '$');
15904 uint salt_len
= hash_pos
- salt_pos
;
15906 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15910 uint hash_len
= input_len
- 10 - salt_len
- 1;
15912 // base64 decode salt
15914 u8 tmp_buf
[100] = { 0 };
15916 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
15918 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
15920 tmp_buf
[salt_len
] = 0x80;
15922 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
15924 salt
->salt_len
= salt_len
;
15926 // base64 decode salt
15928 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15930 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15932 uint user_len
= hash_len
- 32;
15934 const u8
*tmp_hash
= tmp_buf
+ user_len
;
15936 user_len
--; // skip the trailing space
15938 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
15939 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
15940 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
15941 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
15943 digest
[0] = byte_swap_32 (digest
[0]);
15944 digest
[1] = byte_swap_32 (digest
[1]);
15945 digest
[2] = byte_swap_32 (digest
[2]);
15946 digest
[3] = byte_swap_32 (digest
[3]);
15948 // store username for host only (output hash if cracked)
15950 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
15951 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
15953 return (PARSER_OK
);
15956 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15958 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
15960 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15962 u32
*digest
= (u32
*) hash_buf
->digest
;
15964 salt_t
*salt
= hash_buf
->salt
;
15966 char *iter_pos
= input_buf
+ 10;
15968 u32 iter
= atoi (iter_pos
);
15972 return (PARSER_SALT_ITERATION
);
15975 iter
--; // first iteration is special
15977 salt
->salt_iter
= iter
;
15979 char *base64_pos
= strchr (iter_pos
, '}');
15981 if (base64_pos
== NULL
)
15983 return (PARSER_SIGNATURE_UNMATCHED
);
15988 // base64 decode salt
15990 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
15992 u8 tmp_buf
[100] = { 0 };
15994 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
15996 if (decoded_len
< 24)
15998 return (PARSER_SALT_LENGTH
);
16003 uint salt_len
= decoded_len
- 20;
16005 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16006 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16008 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16010 salt
->salt_len
= salt_len
;
16014 u32
*digest_ptr
= (u32
*) tmp_buf
;
16016 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16017 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16018 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16019 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16020 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16022 return (PARSER_OK
);
16025 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16027 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16029 u32
*digest
= (u32
*) hash_buf
->digest
;
16031 salt_t
*salt
= hash_buf
->salt
;
16033 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16034 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16035 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16036 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16037 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16039 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16041 uint salt_len
= input_len
- 40 - 1;
16043 char *salt_buf
= input_buf
+ 40 + 1;
16045 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16047 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16049 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16051 salt
->salt_len
= salt_len
;
16053 return (PARSER_OK
);
16056 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16058 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16060 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16062 u32
*digest
= (u32
*) hash_buf
->digest
;
16064 salt_t
*salt
= hash_buf
->salt
;
16066 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16072 char *V_pos
= input_buf
+ 5;
16074 char *R_pos
= strchr (V_pos
, '*');
16076 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16078 u32 V_len
= R_pos
- V_pos
;
16082 char *bits_pos
= strchr (R_pos
, '*');
16084 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16086 u32 R_len
= bits_pos
- R_pos
;
16090 char *P_pos
= strchr (bits_pos
, '*');
16092 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16094 u32 bits_len
= P_pos
- bits_pos
;
16098 char *enc_md_pos
= strchr (P_pos
, '*');
16100 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16102 u32 P_len
= enc_md_pos
- P_pos
;
16106 char *id_len_pos
= strchr (enc_md_pos
, '*');
16108 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16110 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16114 char *id_buf_pos
= strchr (id_len_pos
, '*');
16116 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16118 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16122 char *u_len_pos
= strchr (id_buf_pos
, '*');
16124 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16126 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16128 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16132 char *u_buf_pos
= strchr (u_len_pos
, '*');
16134 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16136 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16140 char *o_len_pos
= strchr (u_buf_pos
, '*');
16142 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16144 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16146 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16150 char *o_buf_pos
= strchr (o_len_pos
, '*');
16152 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16154 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16158 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;
16160 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16164 const int V
= atoi (V_pos
);
16165 const int R
= atoi (R_pos
);
16166 const int P
= atoi (P_pos
);
16168 if (V
!= 1) return (PARSER_SALT_VALUE
);
16169 if (R
!= 2) return (PARSER_SALT_VALUE
);
16171 const int enc_md
= atoi (enc_md_pos
);
16173 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16175 const int id_len
= atoi (id_len_pos
);
16176 const int u_len
= atoi (u_len_pos
);
16177 const int o_len
= atoi (o_len_pos
);
16179 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16180 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16181 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16183 const int bits
= atoi (bits_pos
);
16185 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16187 // copy data to esalt
16193 pdf
->enc_md
= enc_md
;
16195 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16196 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16197 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16198 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16199 pdf
->id_len
= id_len
;
16201 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16202 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16203 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16204 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16205 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16206 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16207 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16208 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16209 pdf
->u_len
= u_len
;
16211 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16212 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16213 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16214 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16215 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16216 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16217 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16218 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16219 pdf
->o_len
= o_len
;
16221 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16222 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16223 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16224 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16226 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16227 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16228 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16229 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16230 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16231 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16232 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16233 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16235 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16236 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16237 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16238 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16239 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16240 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16241 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16242 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16244 // we use ID for salt, maybe needs to change, we will see...
16246 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16247 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16248 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16249 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16250 salt
->salt_len
= pdf
->id_len
;
16252 digest
[0] = pdf
->u_buf
[0];
16253 digest
[1] = pdf
->u_buf
[1];
16254 digest
[2] = pdf
->u_buf
[2];
16255 digest
[3] = pdf
->u_buf
[3];
16257 return (PARSER_OK
);
16260 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16262 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16265 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16267 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16269 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16271 u32
*digest
= (u32
*) hash_buf
->digest
;
16273 salt_t
*salt
= hash_buf
->salt
;
16275 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16281 char *V_pos
= input_buf
+ 5;
16283 char *R_pos
= strchr (V_pos
, '*');
16285 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16287 u32 V_len
= R_pos
- V_pos
;
16291 char *bits_pos
= strchr (R_pos
, '*');
16293 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16295 u32 R_len
= bits_pos
- R_pos
;
16299 char *P_pos
= strchr (bits_pos
, '*');
16301 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16303 u32 bits_len
= P_pos
- bits_pos
;
16307 char *enc_md_pos
= strchr (P_pos
, '*');
16309 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16311 u32 P_len
= enc_md_pos
- P_pos
;
16315 char *id_len_pos
= strchr (enc_md_pos
, '*');
16317 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16319 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16323 char *id_buf_pos
= strchr (id_len_pos
, '*');
16325 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16327 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16331 char *u_len_pos
= strchr (id_buf_pos
, '*');
16333 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16335 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16337 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16341 char *u_buf_pos
= strchr (u_len_pos
, '*');
16343 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16345 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16349 char *o_len_pos
= strchr (u_buf_pos
, '*');
16351 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16353 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16355 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16359 char *o_buf_pos
= strchr (o_len_pos
, '*');
16361 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16363 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16367 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16369 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16371 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16373 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16377 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;
16379 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16383 const int V
= atoi (V_pos
);
16384 const int R
= atoi (R_pos
);
16385 const int P
= atoi (P_pos
);
16387 if (V
!= 1) return (PARSER_SALT_VALUE
);
16388 if (R
!= 2) return (PARSER_SALT_VALUE
);
16390 const int enc_md
= atoi (enc_md_pos
);
16392 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16394 const int id_len
= atoi (id_len_pos
);
16395 const int u_len
= atoi (u_len_pos
);
16396 const int o_len
= atoi (o_len_pos
);
16398 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16399 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16400 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16402 const int bits
= atoi (bits_pos
);
16404 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16406 // copy data to esalt
16412 pdf
->enc_md
= enc_md
;
16414 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16415 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16416 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16417 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16418 pdf
->id_len
= id_len
;
16420 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16421 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16422 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16423 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16424 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16425 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16426 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16427 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16428 pdf
->u_len
= u_len
;
16430 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16431 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16432 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16433 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16434 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16435 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16436 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16437 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16438 pdf
->o_len
= o_len
;
16440 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16441 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16442 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16443 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16445 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16446 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16447 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16448 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16449 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16450 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16451 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16452 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16454 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16455 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16456 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16457 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16458 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16459 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16460 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16461 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16463 pdf
->rc4key
[1] = 0;
16464 pdf
->rc4key
[0] = 0;
16466 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16467 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16468 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16469 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16470 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16471 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16472 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16473 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16474 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16475 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16477 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16478 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16480 // we use ID for salt, maybe needs to change, we will see...
16482 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16483 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16484 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16485 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16486 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16487 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16488 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16489 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16490 salt
->salt_len
= pdf
->id_len
+ 16;
16492 digest
[0] = pdf
->rc4key
[0];
16493 digest
[1] = pdf
->rc4key
[1];
16497 return (PARSER_OK
);
16500 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16502 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16504 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16506 u32
*digest
= (u32
*) hash_buf
->digest
;
16508 salt_t
*salt
= hash_buf
->salt
;
16510 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16516 char *V_pos
= input_buf
+ 5;
16518 char *R_pos
= strchr (V_pos
, '*');
16520 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16522 u32 V_len
= R_pos
- V_pos
;
16526 char *bits_pos
= strchr (R_pos
, '*');
16528 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16530 u32 R_len
= bits_pos
- R_pos
;
16534 char *P_pos
= strchr (bits_pos
, '*');
16536 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16538 u32 bits_len
= P_pos
- bits_pos
;
16542 char *enc_md_pos
= strchr (P_pos
, '*');
16544 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16546 u32 P_len
= enc_md_pos
- P_pos
;
16550 char *id_len_pos
= strchr (enc_md_pos
, '*');
16552 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16554 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16558 char *id_buf_pos
= strchr (id_len_pos
, '*');
16560 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16562 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16566 char *u_len_pos
= strchr (id_buf_pos
, '*');
16568 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16570 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16572 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16576 char *u_buf_pos
= strchr (u_len_pos
, '*');
16578 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16580 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16584 char *o_len_pos
= strchr (u_buf_pos
, '*');
16586 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16588 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16590 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16594 char *o_buf_pos
= strchr (o_len_pos
, '*');
16596 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16598 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16602 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;
16604 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16608 const int V
= atoi (V_pos
);
16609 const int R
= atoi (R_pos
);
16610 const int P
= atoi (P_pos
);
16614 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16615 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16617 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16619 const int id_len
= atoi (id_len_pos
);
16620 const int u_len
= atoi (u_len_pos
);
16621 const int o_len
= atoi (o_len_pos
);
16623 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16625 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16626 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16628 const int bits
= atoi (bits_pos
);
16630 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16636 enc_md
= atoi (enc_md_pos
);
16639 // copy data to esalt
16645 pdf
->enc_md
= enc_md
;
16647 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16648 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16649 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16650 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16654 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
16655 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
16656 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
16657 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
16660 pdf
->id_len
= id_len
;
16662 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16663 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16664 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16665 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16666 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16667 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16668 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16669 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16670 pdf
->u_len
= u_len
;
16672 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16673 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16674 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16675 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16676 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16677 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16678 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16679 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16680 pdf
->o_len
= o_len
;
16682 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16683 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16684 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16685 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16689 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16690 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16691 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16692 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16695 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16696 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16697 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16698 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16699 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16700 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16701 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16702 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16704 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16705 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16706 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16707 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16708 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16709 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16710 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16711 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16713 // precompute rc4 data for later use
16729 uint salt_pc_block
[32] = { 0 };
16731 char *salt_pc_ptr
= (char *) salt_pc_block
;
16733 memcpy (salt_pc_ptr
, padding
, 32);
16734 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16736 uint salt_pc_digest
[4] = { 0 };
16738 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16740 pdf
->rc4data
[0] = salt_pc_digest
[0];
16741 pdf
->rc4data
[1] = salt_pc_digest
[1];
16743 // we use ID for salt, maybe needs to change, we will see...
16745 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16746 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16747 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16748 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16749 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16750 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16751 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16752 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16753 salt
->salt_len
= pdf
->id_len
+ 16;
16755 salt
->salt_iter
= ROUNDS_PDF14
;
16757 digest
[0] = pdf
->u_buf
[0];
16758 digest
[1] = pdf
->u_buf
[1];
16762 return (PARSER_OK
);
16765 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16767 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16769 if (ret
!= PARSER_OK
)
16774 u32
*digest
= (u32
*) hash_buf
->digest
;
16776 salt_t
*salt
= hash_buf
->salt
;
16778 digest
[0] -= SHA256M_A
;
16779 digest
[1] -= SHA256M_B
;
16780 digest
[2] -= SHA256M_C
;
16781 digest
[3] -= SHA256M_D
;
16782 digest
[4] -= SHA256M_E
;
16783 digest
[5] -= SHA256M_F
;
16784 digest
[6] -= SHA256M_G
;
16785 digest
[7] -= SHA256M_H
;
16787 salt
->salt_buf
[2] = 0x80;
16789 return (PARSER_OK
);
16792 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16794 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16796 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16798 u32
*digest
= (u32
*) hash_buf
->digest
;
16800 salt_t
*salt
= hash_buf
->salt
;
16802 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16808 char *V_pos
= input_buf
+ 5;
16810 char *R_pos
= strchr (V_pos
, '*');
16812 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16814 u32 V_len
= R_pos
- V_pos
;
16818 char *bits_pos
= strchr (R_pos
, '*');
16820 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16822 u32 R_len
= bits_pos
- R_pos
;
16826 char *P_pos
= strchr (bits_pos
, '*');
16828 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16830 u32 bits_len
= P_pos
- bits_pos
;
16834 char *enc_md_pos
= strchr (P_pos
, '*');
16836 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16838 u32 P_len
= enc_md_pos
- P_pos
;
16842 char *id_len_pos
= strchr (enc_md_pos
, '*');
16844 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16846 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16850 char *id_buf_pos
= strchr (id_len_pos
, '*');
16852 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16854 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16858 char *u_len_pos
= strchr (id_buf_pos
, '*');
16860 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16862 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16866 char *u_buf_pos
= strchr (u_len_pos
, '*');
16868 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16870 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16874 char *o_len_pos
= strchr (u_buf_pos
, '*');
16876 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16878 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16882 char *o_buf_pos
= strchr (o_len_pos
, '*');
16884 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16886 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16890 char *last
= strchr (o_buf_pos
, '*');
16892 if (last
== NULL
) last
= input_buf
+ input_len
;
16894 u32 o_buf_len
= last
- o_buf_pos
;
16898 const int V
= atoi (V_pos
);
16899 const int R
= atoi (R_pos
);
16903 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
16904 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
16906 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16908 const int bits
= atoi (bits_pos
);
16910 if (bits
!= 256) return (PARSER_SALT_VALUE
);
16912 int enc_md
= atoi (enc_md_pos
);
16914 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
16916 const uint id_len
= atoi (id_len_pos
);
16917 const uint u_len
= atoi (u_len_pos
);
16918 const uint o_len
= atoi (o_len_pos
);
16920 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
16921 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
16922 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
16923 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
16924 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
16925 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
16926 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
16927 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
16929 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
16930 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
16931 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
16933 // copy data to esalt
16935 if (u_len
< 40) return (PARSER_SALT_VALUE
);
16937 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
16939 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
16942 salt
->salt_buf
[0] = pdf
->u_buf
[8];
16943 salt
->salt_buf
[1] = pdf
->u_buf
[9];
16945 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16946 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16948 salt
->salt_len
= 8;
16949 salt
->salt_iter
= ROUNDS_PDF17L8
;
16951 digest
[0] = pdf
->u_buf
[0];
16952 digest
[1] = pdf
->u_buf
[1];
16953 digest
[2] = pdf
->u_buf
[2];
16954 digest
[3] = pdf
->u_buf
[3];
16955 digest
[4] = pdf
->u_buf
[4];
16956 digest
[5] = pdf
->u_buf
[5];
16957 digest
[6] = pdf
->u_buf
[6];
16958 digest
[7] = pdf
->u_buf
[7];
16960 return (PARSER_OK
);
16963 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16965 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
16967 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
16969 u32
*digest
= (u32
*) hash_buf
->digest
;
16971 salt_t
*salt
= hash_buf
->salt
;
16973 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16981 char *iter_pos
= input_buf
+ 7;
16983 u32 iter
= atoi (iter_pos
);
16985 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16986 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
16988 // first is *raw* salt
16990 char *salt_pos
= strchr (iter_pos
, ':');
16992 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16996 char *hash_pos
= strchr (salt_pos
, ':');
16998 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17000 u32 salt_len
= hash_pos
- salt_pos
;
17002 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17006 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17008 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17012 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17014 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17016 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17018 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17019 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17021 salt
->salt_len
= salt_len
;
17022 salt
->salt_iter
= iter
- 1;
17026 u8 tmp_buf
[100] = { 0 };
17028 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17030 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17032 memcpy (digest
, tmp_buf
, 16);
17034 digest
[0] = byte_swap_32 (digest
[0]);
17035 digest
[1] = byte_swap_32 (digest
[1]);
17036 digest
[2] = byte_swap_32 (digest
[2]);
17037 digest
[3] = byte_swap_32 (digest
[3]);
17039 // add some stuff to normal salt to make sorted happy
17041 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17042 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17043 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17044 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17045 salt
->salt_buf
[4] = salt
->salt_iter
;
17047 return (PARSER_OK
);
17050 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17052 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17054 u32
*digest
= (u32
*) hash_buf
->digest
;
17056 salt_t
*salt
= hash_buf
->salt
;
17058 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17059 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17060 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17061 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17063 digest
[0] = byte_swap_32 (digest
[0]);
17064 digest
[1] = byte_swap_32 (digest
[1]);
17065 digest
[2] = byte_swap_32 (digest
[2]);
17066 digest
[3] = byte_swap_32 (digest
[3]);
17068 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17070 uint salt_len
= input_len
- 32 - 1;
17072 char *salt_buf
= input_buf
+ 32 + 1;
17074 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17076 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17078 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17080 salt
->salt_len
= salt_len
;
17082 return (PARSER_OK
);
17085 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17087 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17089 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17091 u32
*digest
= (u32
*) hash_buf
->digest
;
17093 salt_t
*salt
= hash_buf
->salt
;
17095 char *user_pos
= input_buf
+ 10;
17097 char *salt_pos
= strchr (user_pos
, '*');
17099 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17103 char *hash_pos
= strchr (salt_pos
, '*');
17107 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17109 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17111 uint user_len
= salt_pos
- user_pos
- 1;
17113 uint salt_len
= hash_pos
- salt_pos
- 1;
17115 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17121 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17122 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17123 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17124 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17126 digest
[0] = byte_swap_32 (digest
[0]);
17127 digest
[1] = byte_swap_32 (digest
[1]);
17128 digest
[2] = byte_swap_32 (digest
[2]);
17129 digest
[3] = byte_swap_32 (digest
[3]);
17131 digest
[0] -= MD5M_A
;
17132 digest
[1] -= MD5M_B
;
17133 digest
[2] -= MD5M_C
;
17134 digest
[3] -= MD5M_D
;
17140 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17142 // first 4 bytes are the "challenge"
17144 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17145 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17146 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17147 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17149 // append the user name
17151 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17153 salt
->salt_len
= 4 + user_len
;
17155 return (PARSER_OK
);
17158 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17160 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17162 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17164 u32
*digest
= (u32
*) hash_buf
->digest
;
17166 salt_t
*salt
= hash_buf
->salt
;
17168 char *salt_pos
= input_buf
+ 9;
17170 char *hash_pos
= strchr (salt_pos
, '*');
17172 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17176 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17178 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17180 uint salt_len
= hash_pos
- salt_pos
- 1;
17182 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17188 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17189 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17190 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17191 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17192 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17198 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17200 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17202 salt
->salt_len
= salt_len
;
17204 return (PARSER_OK
);
17207 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17209 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17211 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17213 u32
*digest
= (u32
*) hash_buf
->digest
;
17215 salt_t
*salt
= hash_buf
->salt
;
17217 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17223 char *cry_master_len_pos
= input_buf
+ 9;
17225 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17227 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17229 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17231 cry_master_buf_pos
++;
17233 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17235 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17237 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17239 cry_salt_len_pos
++;
17241 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17243 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17245 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17247 cry_salt_buf_pos
++;
17249 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17251 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17253 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17257 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17259 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17261 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17265 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17267 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17269 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17273 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17275 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17277 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17279 public_key_len_pos
++;
17281 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17283 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17285 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17287 public_key_buf_pos
++;
17289 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;
17291 const uint cry_master_len
= atoi (cry_master_len_pos
);
17292 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17293 const uint ckey_len
= atoi (ckey_len_pos
);
17294 const uint public_key_len
= atoi (public_key_len_pos
);
17296 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17297 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17298 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17299 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17301 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17303 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17305 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17308 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17310 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17312 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17315 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17317 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17319 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17322 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17323 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17324 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17327 * store digest (should be unique enought, hopefully)
17330 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17331 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17332 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17333 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17339 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17341 const uint cry_rounds
= atoi (cry_rounds_pos
);
17343 salt
->salt_iter
= cry_rounds
- 1;
17345 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17347 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17349 salt
->salt_len
= salt_len
;
17351 return (PARSER_OK
);
17354 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17356 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17358 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17360 u32
*digest
= (u32
*) hash_buf
->digest
;
17362 salt_t
*salt
= hash_buf
->salt
;
17364 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17366 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17368 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17370 memcpy (temp_input_buf
, input_buf
, input_len
);
17374 char *URI_server_pos
= temp_input_buf
+ 6;
17376 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17378 if (URI_client_pos
== NULL
)
17380 myfree (temp_input_buf
);
17382 return (PARSER_SEPARATOR_UNMATCHED
);
17385 URI_client_pos
[0] = 0;
17388 uint URI_server_len
= strlen (URI_server_pos
);
17390 if (URI_server_len
> 512)
17392 myfree (temp_input_buf
);
17394 return (PARSER_SALT_LENGTH
);
17399 char *user_pos
= strchr (URI_client_pos
, '*');
17401 if (user_pos
== NULL
)
17403 myfree (temp_input_buf
);
17405 return (PARSER_SEPARATOR_UNMATCHED
);
17411 uint URI_client_len
= strlen (URI_client_pos
);
17413 if (URI_client_len
> 512)
17415 myfree (temp_input_buf
);
17417 return (PARSER_SALT_LENGTH
);
17422 char *realm_pos
= strchr (user_pos
, '*');
17424 if (realm_pos
== NULL
)
17426 myfree (temp_input_buf
);
17428 return (PARSER_SEPARATOR_UNMATCHED
);
17434 uint user_len
= strlen (user_pos
);
17436 if (user_len
> 116)
17438 myfree (temp_input_buf
);
17440 return (PARSER_SALT_LENGTH
);
17445 char *method_pos
= strchr (realm_pos
, '*');
17447 if (method_pos
== NULL
)
17449 myfree (temp_input_buf
);
17451 return (PARSER_SEPARATOR_UNMATCHED
);
17457 uint realm_len
= strlen (realm_pos
);
17459 if (realm_len
> 116)
17461 myfree (temp_input_buf
);
17463 return (PARSER_SALT_LENGTH
);
17468 char *URI_prefix_pos
= strchr (method_pos
, '*');
17470 if (URI_prefix_pos
== NULL
)
17472 myfree (temp_input_buf
);
17474 return (PARSER_SEPARATOR_UNMATCHED
);
17477 URI_prefix_pos
[0] = 0;
17480 uint method_len
= strlen (method_pos
);
17482 if (method_len
> 246)
17484 myfree (temp_input_buf
);
17486 return (PARSER_SALT_LENGTH
);
17491 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17493 if (URI_resource_pos
== NULL
)
17495 myfree (temp_input_buf
);
17497 return (PARSER_SEPARATOR_UNMATCHED
);
17500 URI_resource_pos
[0] = 0;
17501 URI_resource_pos
++;
17503 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17505 if (URI_prefix_len
> 245)
17507 myfree (temp_input_buf
);
17509 return (PARSER_SALT_LENGTH
);
17514 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17516 if (URI_suffix_pos
== NULL
)
17518 myfree (temp_input_buf
);
17520 return (PARSER_SEPARATOR_UNMATCHED
);
17523 URI_suffix_pos
[0] = 0;
17526 uint URI_resource_len
= strlen (URI_resource_pos
);
17528 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17530 myfree (temp_input_buf
);
17532 return (PARSER_SALT_LENGTH
);
17537 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17539 if (nonce_pos
== NULL
)
17541 myfree (temp_input_buf
);
17543 return (PARSER_SEPARATOR_UNMATCHED
);
17549 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17551 if (URI_suffix_len
> 245)
17553 myfree (temp_input_buf
);
17555 return (PARSER_SALT_LENGTH
);
17560 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17562 if (nonce_client_pos
== NULL
)
17564 myfree (temp_input_buf
);
17566 return (PARSER_SEPARATOR_UNMATCHED
);
17569 nonce_client_pos
[0] = 0;
17570 nonce_client_pos
++;
17572 uint nonce_len
= strlen (nonce_pos
);
17574 if (nonce_len
< 1 || nonce_len
> 50)
17576 myfree (temp_input_buf
);
17578 return (PARSER_SALT_LENGTH
);
17583 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17585 if (nonce_count_pos
== NULL
)
17587 myfree (temp_input_buf
);
17589 return (PARSER_SEPARATOR_UNMATCHED
);
17592 nonce_count_pos
[0] = 0;
17595 uint nonce_client_len
= strlen (nonce_client_pos
);
17597 if (nonce_client_len
> 50)
17599 myfree (temp_input_buf
);
17601 return (PARSER_SALT_LENGTH
);
17606 char *qop_pos
= strchr (nonce_count_pos
, '*');
17608 if (qop_pos
== NULL
)
17610 myfree (temp_input_buf
);
17612 return (PARSER_SEPARATOR_UNMATCHED
);
17618 uint nonce_count_len
= strlen (nonce_count_pos
);
17620 if (nonce_count_len
> 50)
17622 myfree (temp_input_buf
);
17624 return (PARSER_SALT_LENGTH
);
17629 char *directive_pos
= strchr (qop_pos
, '*');
17631 if (directive_pos
== NULL
)
17633 myfree (temp_input_buf
);
17635 return (PARSER_SEPARATOR_UNMATCHED
);
17638 directive_pos
[0] = 0;
17641 uint qop_len
= strlen (qop_pos
);
17645 myfree (temp_input_buf
);
17647 return (PARSER_SALT_LENGTH
);
17652 char *digest_pos
= strchr (directive_pos
, '*');
17654 if (digest_pos
== NULL
)
17656 myfree (temp_input_buf
);
17658 return (PARSER_SEPARATOR_UNMATCHED
);
17664 uint directive_len
= strlen (directive_pos
);
17666 if (directive_len
!= 3)
17668 myfree (temp_input_buf
);
17670 return (PARSER_SALT_LENGTH
);
17673 if (memcmp (directive_pos
, "MD5", 3))
17675 log_info ("ERROR: only the MD5 directive is currently supported\n");
17677 myfree (temp_input_buf
);
17679 return (PARSER_SIP_AUTH_DIRECTIVE
);
17683 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17688 uint md5_max_len
= 4 * 64;
17690 uint md5_remaining_len
= md5_max_len
;
17692 uint tmp_md5_buf
[64] = { 0 };
17694 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17696 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17698 md5_len
+= method_len
+ 1;
17699 tmp_md5_ptr
+= method_len
+ 1;
17701 if (URI_prefix_len
> 0)
17703 md5_remaining_len
= md5_max_len
- md5_len
;
17705 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17707 md5_len
+= URI_prefix_len
+ 1;
17708 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17711 md5_remaining_len
= md5_max_len
- md5_len
;
17713 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17715 md5_len
+= URI_resource_len
;
17716 tmp_md5_ptr
+= URI_resource_len
;
17718 if (URI_suffix_len
> 0)
17720 md5_remaining_len
= md5_max_len
- md5_len
;
17722 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17724 md5_len
+= 1 + URI_suffix_len
;
17727 uint tmp_digest
[4] = { 0 };
17729 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17731 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17732 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17733 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17734 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17740 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17742 uint esalt_len
= 0;
17744 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17746 // there are 2 possibilities for the esalt:
17748 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17750 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17752 if (esalt_len
> max_esalt_len
)
17754 myfree (temp_input_buf
);
17756 return (PARSER_SALT_LENGTH
);
17759 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17771 esalt_len
= 1 + nonce_len
+ 1 + 32;
17773 if (esalt_len
> max_esalt_len
)
17775 myfree (temp_input_buf
);
17777 return (PARSER_SALT_LENGTH
);
17780 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17788 // add 0x80 to esalt
17790 esalt_buf_ptr
[esalt_len
] = 0x80;
17792 sip
->esalt_len
= esalt_len
;
17798 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17800 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17802 uint max_salt_len
= 119;
17804 if (salt_len
> max_salt_len
)
17806 myfree (temp_input_buf
);
17808 return (PARSER_SALT_LENGTH
);
17811 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17813 sip
->salt_len
= salt_len
;
17816 * fake salt (for sorting)
17819 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17823 uint fake_salt_len
= salt_len
;
17825 if (fake_salt_len
> max_salt_len
)
17827 fake_salt_len
= max_salt_len
;
17830 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17832 salt
->salt_len
= fake_salt_len
;
17838 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
17839 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
17840 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
17841 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
17843 digest
[0] = byte_swap_32 (digest
[0]);
17844 digest
[1] = byte_swap_32 (digest
[1]);
17845 digest
[2] = byte_swap_32 (digest
[2]);
17846 digest
[3] = byte_swap_32 (digest
[3]);
17848 myfree (temp_input_buf
);
17850 return (PARSER_OK
);
17853 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17855 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17857 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17859 u32
*digest
= (u32
*) hash_buf
->digest
;
17861 salt_t
*salt
= hash_buf
->salt
;
17865 char *digest_pos
= input_buf
;
17867 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
17874 char *salt_buf
= input_buf
+ 8 + 1;
17878 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17880 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17882 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17884 salt
->salt_len
= salt_len
;
17886 return (PARSER_OK
);
17889 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17891 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
17893 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17895 u32
*digest
= (u32
*) hash_buf
->digest
;
17897 salt_t
*salt
= hash_buf
->salt
;
17899 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
17905 char *p_buf_pos
= input_buf
+ 4;
17907 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
17909 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17911 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
17913 NumCyclesPower_pos
++;
17915 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
17917 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17919 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
17923 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
17925 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17927 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
17931 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
17933 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17935 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
17939 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
17941 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17943 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
17947 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
17949 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17951 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
17955 char *data_len_pos
= strchr (crc_buf_pos
, '$');
17957 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17959 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
17963 char *unpack_size_pos
= strchr (data_len_pos
, '$');
17965 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17967 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
17971 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
17973 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17975 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
17979 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;
17981 const uint iter
= atoi (NumCyclesPower_pos
);
17982 const uint crc
= atoi (crc_buf_pos
);
17983 const uint p_buf
= atoi (p_buf_pos
);
17984 const uint salt_len
= atoi (salt_len_pos
);
17985 const uint iv_len
= atoi (iv_len_pos
);
17986 const uint unpack_size
= atoi (unpack_size_pos
);
17987 const uint data_len
= atoi (data_len_pos
);
17993 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
17994 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
17996 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
17998 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18000 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18006 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18007 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18008 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18009 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18011 seven_zip
->iv_len
= iv_len
;
18013 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18015 seven_zip
->salt_len
= 0;
18017 seven_zip
->crc
= crc
;
18019 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18021 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18023 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18026 seven_zip
->data_len
= data_len
;
18028 seven_zip
->unpack_size
= unpack_size
;
18032 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18033 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18034 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18035 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18037 salt
->salt_len
= 16;
18039 salt
->salt_sign
[0] = iter
;
18041 salt
->salt_iter
= 1 << iter
;
18052 return (PARSER_OK
);
18055 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18057 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18059 u32
*digest
= (u32
*) hash_buf
->digest
;
18061 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18062 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18063 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18064 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18065 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18066 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18067 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18068 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18070 digest
[0] = byte_swap_32 (digest
[0]);
18071 digest
[1] = byte_swap_32 (digest
[1]);
18072 digest
[2] = byte_swap_32 (digest
[2]);
18073 digest
[3] = byte_swap_32 (digest
[3]);
18074 digest
[4] = byte_swap_32 (digest
[4]);
18075 digest
[5] = byte_swap_32 (digest
[5]);
18076 digest
[6] = byte_swap_32 (digest
[6]);
18077 digest
[7] = byte_swap_32 (digest
[7]);
18079 return (PARSER_OK
);
18082 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18084 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18086 u32
*digest
= (u32
*) hash_buf
->digest
;
18088 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18089 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18090 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18091 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18092 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18093 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18094 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18095 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18096 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18097 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18098 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18099 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18100 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18101 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18102 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18103 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18105 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18106 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18107 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18108 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18109 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18110 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18111 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18112 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18113 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18114 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18115 digest
[10] = byte_swap_32 (digest
[10]);
18116 digest
[11] = byte_swap_32 (digest
[11]);
18117 digest
[12] = byte_swap_32 (digest
[12]);
18118 digest
[13] = byte_swap_32 (digest
[13]);
18119 digest
[14] = byte_swap_32 (digest
[14]);
18120 digest
[15] = byte_swap_32 (digest
[15]);
18122 return (PARSER_OK
);
18125 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18127 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18129 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18131 u32
*digest
= (u32
*) hash_buf
->digest
;
18133 salt_t
*salt
= hash_buf
->salt
;
18135 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18143 char *iter_pos
= input_buf
+ 4;
18145 u32 iter
= atoi (iter_pos
);
18147 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18148 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18150 // first is *raw* salt
18152 char *salt_pos
= strchr (iter_pos
, ':');
18154 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18158 char *hash_pos
= strchr (salt_pos
, ':');
18160 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18162 u32 salt_len
= hash_pos
- salt_pos
;
18164 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18168 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18170 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18174 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18176 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18178 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18180 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18181 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18183 salt
->salt_len
= salt_len
;
18184 salt
->salt_iter
= iter
- 1;
18188 u8 tmp_buf
[100] = { 0 };
18190 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18192 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18194 memcpy (digest
, tmp_buf
, 16);
18196 // add some stuff to normal salt to make sorted happy
18198 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18199 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18200 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18201 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18202 salt
->salt_buf
[4] = salt
->salt_iter
;
18204 return (PARSER_OK
);
18207 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18209 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18211 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18213 u32
*digest
= (u32
*) hash_buf
->digest
;
18215 salt_t
*salt
= hash_buf
->salt
;
18217 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18225 char *iter_pos
= input_buf
+ 5;
18227 u32 iter
= atoi (iter_pos
);
18229 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18230 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18232 // first is *raw* salt
18234 char *salt_pos
= strchr (iter_pos
, ':');
18236 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18240 char *hash_pos
= strchr (salt_pos
, ':');
18242 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18244 u32 salt_len
= hash_pos
- salt_pos
;
18246 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18250 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18252 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18256 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18258 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18260 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18262 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18263 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18265 salt
->salt_len
= salt_len
;
18266 salt
->salt_iter
= iter
- 1;
18270 u8 tmp_buf
[100] = { 0 };
18272 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18274 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18276 memcpy (digest
, tmp_buf
, 16);
18278 digest
[0] = byte_swap_32 (digest
[0]);
18279 digest
[1] = byte_swap_32 (digest
[1]);
18280 digest
[2] = byte_swap_32 (digest
[2]);
18281 digest
[3] = byte_swap_32 (digest
[3]);
18283 // add some stuff to normal salt to make sorted happy
18285 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18286 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18287 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18288 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18289 salt
->salt_buf
[4] = salt
->salt_iter
;
18291 return (PARSER_OK
);
18294 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18296 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18298 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18300 u64
*digest
= (u64
*) hash_buf
->digest
;
18302 salt_t
*salt
= hash_buf
->salt
;
18304 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18312 char *iter_pos
= input_buf
+ 7;
18314 u32 iter
= atoi (iter_pos
);
18316 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18317 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18319 // first is *raw* salt
18321 char *salt_pos
= strchr (iter_pos
, ':');
18323 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18327 char *hash_pos
= strchr (salt_pos
, ':');
18329 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18331 u32 salt_len
= hash_pos
- salt_pos
;
18333 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18337 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18339 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18343 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18345 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18347 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18349 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18350 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18352 salt
->salt_len
= salt_len
;
18353 salt
->salt_iter
= iter
- 1;
18357 u8 tmp_buf
[100] = { 0 };
18359 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18361 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18363 memcpy (digest
, tmp_buf
, 64);
18365 digest
[0] = byte_swap_64 (digest
[0]);
18366 digest
[1] = byte_swap_64 (digest
[1]);
18367 digest
[2] = byte_swap_64 (digest
[2]);
18368 digest
[3] = byte_swap_64 (digest
[3]);
18369 digest
[4] = byte_swap_64 (digest
[4]);
18370 digest
[5] = byte_swap_64 (digest
[5]);
18371 digest
[6] = byte_swap_64 (digest
[6]);
18372 digest
[7] = byte_swap_64 (digest
[7]);
18374 // add some stuff to normal salt to make sorted happy
18376 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18377 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18378 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18379 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18380 salt
->salt_buf
[4] = salt
->salt_iter
;
18382 return (PARSER_OK
);
18385 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18387 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18389 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18391 uint
*digest
= (uint
*) hash_buf
->digest
;
18393 salt_t
*salt
= hash_buf
->salt
;
18399 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18401 char *hash_pos
= strchr (salt_pos
, '$');
18403 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18405 u32 salt_len
= hash_pos
- salt_pos
;
18407 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18411 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18413 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18417 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18418 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18436 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18437 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18439 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18440 salt
->salt_len
= 8;
18442 return (PARSER_OK
);
18445 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18447 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18449 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18451 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18453 if (c19
& 3) return (PARSER_HASH_VALUE
);
18455 salt_t
*salt
= hash_buf
->salt
;
18457 u32
*digest
= (u32
*) hash_buf
->digest
;
18461 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18462 | itoa64_to_int (input_buf
[2]) << 6
18463 | itoa64_to_int (input_buf
[3]) << 12
18464 | itoa64_to_int (input_buf
[4]) << 18;
18468 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18469 | itoa64_to_int (input_buf
[6]) << 6
18470 | itoa64_to_int (input_buf
[7]) << 12
18471 | itoa64_to_int (input_buf
[8]) << 18;
18473 salt
->salt_len
= 4;
18475 u8 tmp_buf
[100] = { 0 };
18477 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18479 memcpy (digest
, tmp_buf
, 8);
18483 IP (digest
[0], digest
[1], tt
);
18485 digest
[0] = rotr32 (digest
[0], 31);
18486 digest
[1] = rotr32 (digest
[1], 31);
18490 return (PARSER_OK
);
18493 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18495 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18497 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18499 u32
*digest
= (u32
*) hash_buf
->digest
;
18501 salt_t
*salt
= hash_buf
->salt
;
18507 char *type_pos
= input_buf
+ 6 + 1;
18509 char *salt_pos
= strchr (type_pos
, '*');
18511 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18513 u32 type_len
= salt_pos
- type_pos
;
18515 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18519 char *crypted_pos
= strchr (salt_pos
, '*');
18521 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18523 u32 salt_len
= crypted_pos
- salt_pos
;
18525 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18529 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18531 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18537 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18538 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18540 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18541 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18543 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18544 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18545 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18546 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18548 salt
->salt_len
= 24;
18549 salt
->salt_iter
= ROUNDS_RAR3
;
18551 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18552 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18554 digest
[0] = 0xc43d7b00;
18555 digest
[1] = 0x40070000;
18559 return (PARSER_OK
);
18562 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18564 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18566 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18568 u32
*digest
= (u32
*) hash_buf
->digest
;
18570 salt_t
*salt
= hash_buf
->salt
;
18572 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18578 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18580 char *param1_pos
= strchr (param0_pos
, '$');
18582 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18584 u32 param0_len
= param1_pos
- param0_pos
;
18588 char *param2_pos
= strchr (param1_pos
, '$');
18590 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18592 u32 param1_len
= param2_pos
- param1_pos
;
18596 char *param3_pos
= strchr (param2_pos
, '$');
18598 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18600 u32 param2_len
= param3_pos
- param2_pos
;
18604 char *param4_pos
= strchr (param3_pos
, '$');
18606 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18608 u32 param3_len
= param4_pos
- param3_pos
;
18612 char *param5_pos
= strchr (param4_pos
, '$');
18614 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18616 u32 param4_len
= param5_pos
- param4_pos
;
18620 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18622 char *salt_buf
= param1_pos
;
18623 char *iv
= param3_pos
;
18624 char *pswcheck
= param5_pos
;
18626 const uint salt_len
= atoi (param0_pos
);
18627 const uint iterations
= atoi (param2_pos
);
18628 const uint pswcheck_len
= atoi (param4_pos
);
18634 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18635 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18636 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18638 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18639 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18640 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18646 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18647 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18648 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18649 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
18651 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
18652 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
18653 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
18654 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
18656 salt
->salt_len
= 16;
18658 salt
->salt_sign
[0] = iterations
;
18660 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18666 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
18667 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
18671 return (PARSER_OK
);
18674 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18676 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18678 u32
*digest
= (u32
*) hash_buf
->digest
;
18680 salt_t
*salt
= hash_buf
->salt
;
18682 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18683 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18684 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18685 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18686 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18687 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18688 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18689 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18691 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18693 uint salt_len
= input_len
- 64 - 1;
18695 char *salt_buf
= input_buf
+ 64 + 1;
18697 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18699 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18701 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18703 salt
->salt_len
= salt_len
;
18706 * we can precompute the first sha256 transform
18709 uint w
[16] = { 0 };
18711 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18712 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18713 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18714 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18715 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18716 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18717 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18718 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18719 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18720 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18721 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18722 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18723 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18724 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18725 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18726 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18728 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
18730 sha256_64 (w
, pc256
);
18732 salt
->salt_buf_pc
[0] = pc256
[0];
18733 salt
->salt_buf_pc
[1] = pc256
[1];
18734 salt
->salt_buf_pc
[2] = pc256
[2];
18735 salt
->salt_buf_pc
[3] = pc256
[3];
18736 salt
->salt_buf_pc
[4] = pc256
[4];
18737 salt
->salt_buf_pc
[5] = pc256
[5];
18738 salt
->salt_buf_pc
[6] = pc256
[6];
18739 salt
->salt_buf_pc
[7] = pc256
[7];
18741 digest
[0] -= pc256
[0];
18742 digest
[1] -= pc256
[1];
18743 digest
[2] -= pc256
[2];
18744 digest
[3] -= pc256
[3];
18745 digest
[4] -= pc256
[4];
18746 digest
[5] -= pc256
[5];
18747 digest
[6] -= pc256
[6];
18748 digest
[7] -= pc256
[7];
18750 return (PARSER_OK
);
18753 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18755 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18757 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18759 u32
*digest
= (u32
*) hash_buf
->digest
;
18761 salt_t
*salt
= hash_buf
->salt
;
18767 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18769 char *data_buf_pos
= strchr (data_len_pos
, '$');
18771 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18773 u32 data_len_len
= data_buf_pos
- data_len_pos
;
18775 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18776 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18780 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18782 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
18784 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
18786 u32 data_len
= atoi (data_len_pos
);
18788 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
18794 char *salt_pos
= data_buf_pos
;
18796 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18797 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18798 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
18799 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
18801 // this is actually the CT, which is also the hash later (if matched)
18803 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
18804 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
18805 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
18806 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
18808 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
18810 salt
->salt_iter
= 10 - 1;
18816 digest
[0] = salt
->salt_buf
[4];
18817 digest
[1] = salt
->salt_buf
[5];
18818 digest
[2] = salt
->salt_buf
[6];
18819 digest
[3] = salt
->salt_buf
[7];
18821 return (PARSER_OK
);
18824 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18826 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
18828 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18830 u32
*digest
= (u32
*) hash_buf
->digest
;
18832 salt_t
*salt
= hash_buf
->salt
;
18838 char *salt_pos
= input_buf
+ 11 + 1;
18840 char *iter_pos
= strchr (salt_pos
, ',');
18842 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18844 u32 salt_len
= iter_pos
- salt_pos
;
18846 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
18850 char *hash_pos
= strchr (iter_pos
, ',');
18852 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18854 u32 iter_len
= hash_pos
- iter_pos
;
18856 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
18860 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
18862 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
18868 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18869 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18870 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
18871 salt
->salt_buf
[3] = 0x00018000;
18873 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18874 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18875 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
18876 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
18878 salt
->salt_len
= salt_len
/ 2;
18880 salt
->salt_iter
= atoi (iter_pos
) - 1;
18886 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18887 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18888 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18889 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18890 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18891 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
18892 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
18893 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
18895 return (PARSER_OK
);
18898 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18900 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
18902 u32
*digest
= (u32
*) hash_buf
->digest
;
18904 salt_t
*salt
= hash_buf
->salt
;
18910 char *hash_pos
= input_buf
+ 64;
18911 char *salt1_pos
= input_buf
+ 128;
18912 char *salt2_pos
= input_buf
;
18918 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
18919 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
18920 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
18921 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
18923 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
18924 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
18925 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
18926 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
18928 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
18929 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
18930 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
18931 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
18933 salt
->salt_len
= 48;
18935 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
18941 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18942 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18943 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18944 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18945 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18946 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
18947 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
18948 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
18950 return (PARSER_OK
);
18954 * parallel running threads
18959 BOOL WINAPI
sigHandler_default (DWORD sig
)
18963 case CTRL_CLOSE_EVENT
:
18966 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
18967 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
18968 * function otherwise it is too late (e.g. after returning from this function)
18973 SetConsoleCtrlHandler (NULL
, TRUE
);
18980 case CTRL_LOGOFF_EVENT
:
18981 case CTRL_SHUTDOWN_EVENT
:
18985 SetConsoleCtrlHandler (NULL
, TRUE
);
18993 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
18997 case CTRL_CLOSE_EVENT
:
19001 SetConsoleCtrlHandler (NULL
, TRUE
);
19008 case CTRL_LOGOFF_EVENT
:
19009 case CTRL_SHUTDOWN_EVENT
:
19013 SetConsoleCtrlHandler (NULL
, TRUE
);
19021 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19023 if (callback
== NULL
)
19025 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19029 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19035 void sigHandler_default (int sig
)
19039 signal (sig
, NULL
);
19042 void sigHandler_benchmark (int sig
)
19046 signal (sig
, NULL
);
19049 void hc_signal (void (callback
) (int))
19051 if (callback
== NULL
) callback
= SIG_DFL
;
19053 signal (SIGINT
, callback
);
19054 signal (SIGTERM
, callback
);
19055 signal (SIGABRT
, callback
);
19060 void status_display ();
19062 void *thread_keypress (void *p
)
19064 int benchmark
= *((int *) p
);
19066 uint quiet
= data
.quiet
;
19070 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19072 int ch
= tty_getchar();
19074 if (ch
== -1) break;
19076 if (ch
== 0) continue;
19082 hc_thread_mutex_lock (mux_display
);
19097 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19098 if (quiet
== 0) fflush (stdout
);
19110 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19111 if (quiet
== 0) fflush (stdout
);
19123 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19124 if (quiet
== 0) fflush (stdout
);
19136 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19137 if (quiet
== 0) fflush (stdout
);
19145 if (benchmark
== 1) break;
19147 stop_at_checkpoint ();
19151 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19152 if (quiet
== 0) fflush (stdout
);
19160 if (benchmark
== 1)
19172 hc_thread_mutex_unlock (mux_display
);
19184 bool class_num (const u8 c
)
19186 return ((c
>= '0') && (c
<= '9'));
19189 bool class_lower (const u8 c
)
19191 return ((c
>= 'a') && (c
<= 'z'));
19194 bool class_upper (const u8 c
)
19196 return ((c
>= 'A') && (c
<= 'Z'));
19199 bool class_alpha (const u8 c
)
19201 return (class_lower (c
) || class_upper (c
));
19204 int conv_ctoi (const u8 c
)
19210 else if (class_upper (c
))
19212 return c
- 'A' + 10;
19218 int conv_itoc (const u8 c
)
19226 return c
+ 'A' - 10;
19236 #define INCR_POS if (++rule_pos == rule_len) return (-1)
19237 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
19238 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
19239 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
19240 #define MAX_KERNEL_RULES 255
19241 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
19242 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19243 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19245 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
19246 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
19247 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19248 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19250 int cpu_rule_to_kernel_rule (char rule_buf
[BUFSIZ
], uint rule_len
, kernel_rule_t
*rule
)
19255 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19257 switch (rule_buf
[rule_pos
])
19263 case RULE_OP_MANGLE_NOOP
:
19264 SET_NAME (rule
, rule_buf
[rule_pos
]);
19267 case RULE_OP_MANGLE_LREST
:
19268 SET_NAME (rule
, rule_buf
[rule_pos
]);
19271 case RULE_OP_MANGLE_UREST
:
19272 SET_NAME (rule
, rule_buf
[rule_pos
]);
19275 case RULE_OP_MANGLE_LREST_UFIRST
:
19276 SET_NAME (rule
, rule_buf
[rule_pos
]);
19279 case RULE_OP_MANGLE_UREST_LFIRST
:
19280 SET_NAME (rule
, rule_buf
[rule_pos
]);
19283 case RULE_OP_MANGLE_TREST
:
19284 SET_NAME (rule
, rule_buf
[rule_pos
]);
19287 case RULE_OP_MANGLE_TOGGLE_AT
:
19288 SET_NAME (rule
, rule_buf
[rule_pos
]);
19289 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19292 case RULE_OP_MANGLE_REVERSE
:
19293 SET_NAME (rule
, rule_buf
[rule_pos
]);
19296 case RULE_OP_MANGLE_DUPEWORD
:
19297 SET_NAME (rule
, rule_buf
[rule_pos
]);
19300 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19301 SET_NAME (rule
, rule_buf
[rule_pos
]);
19302 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19305 case RULE_OP_MANGLE_REFLECT
:
19306 SET_NAME (rule
, rule_buf
[rule_pos
]);
19309 case RULE_OP_MANGLE_ROTATE_LEFT
:
19310 SET_NAME (rule
, rule_buf
[rule_pos
]);
19313 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19314 SET_NAME (rule
, rule_buf
[rule_pos
]);
19317 case RULE_OP_MANGLE_APPEND
:
19318 SET_NAME (rule
, rule_buf
[rule_pos
]);
19319 SET_P0 (rule
, rule_buf
[rule_pos
]);
19322 case RULE_OP_MANGLE_PREPEND
:
19323 SET_NAME (rule
, rule_buf
[rule_pos
]);
19324 SET_P0 (rule
, rule_buf
[rule_pos
]);
19327 case RULE_OP_MANGLE_DELETE_FIRST
:
19328 SET_NAME (rule
, rule_buf
[rule_pos
]);
19331 case RULE_OP_MANGLE_DELETE_LAST
:
19332 SET_NAME (rule
, rule_buf
[rule_pos
]);
19335 case RULE_OP_MANGLE_DELETE_AT
:
19336 SET_NAME (rule
, rule_buf
[rule_pos
]);
19337 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19340 case RULE_OP_MANGLE_EXTRACT
:
19341 SET_NAME (rule
, rule_buf
[rule_pos
]);
19342 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19343 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19346 case RULE_OP_MANGLE_OMIT
:
19347 SET_NAME (rule
, rule_buf
[rule_pos
]);
19348 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19349 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19352 case RULE_OP_MANGLE_INSERT
:
19353 SET_NAME (rule
, rule_buf
[rule_pos
]);
19354 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19355 SET_P1 (rule
, rule_buf
[rule_pos
]);
19358 case RULE_OP_MANGLE_OVERSTRIKE
:
19359 SET_NAME (rule
, rule_buf
[rule_pos
]);
19360 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19361 SET_P1 (rule
, rule_buf
[rule_pos
]);
19364 case RULE_OP_MANGLE_TRUNCATE_AT
:
19365 SET_NAME (rule
, rule_buf
[rule_pos
]);
19366 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19369 case RULE_OP_MANGLE_REPLACE
:
19370 SET_NAME (rule
, rule_buf
[rule_pos
]);
19371 SET_P0 (rule
, rule_buf
[rule_pos
]);
19372 SET_P1 (rule
, rule_buf
[rule_pos
]);
19375 case RULE_OP_MANGLE_PURGECHAR
:
19379 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19383 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19384 SET_NAME (rule
, rule_buf
[rule_pos
]);
19385 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19388 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19389 SET_NAME (rule
, rule_buf
[rule_pos
]);
19390 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19393 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19394 SET_NAME (rule
, rule_buf
[rule_pos
]);
19397 case RULE_OP_MANGLE_SWITCH_FIRST
:
19398 SET_NAME (rule
, rule_buf
[rule_pos
]);
19401 case RULE_OP_MANGLE_SWITCH_LAST
:
19402 SET_NAME (rule
, rule_buf
[rule_pos
]);
19405 case RULE_OP_MANGLE_SWITCH_AT
:
19406 SET_NAME (rule
, rule_buf
[rule_pos
]);
19407 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19408 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19411 case RULE_OP_MANGLE_CHR_SHIFTL
:
19412 SET_NAME (rule
, rule_buf
[rule_pos
]);
19413 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19416 case RULE_OP_MANGLE_CHR_SHIFTR
:
19417 SET_NAME (rule
, rule_buf
[rule_pos
]);
19418 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19421 case RULE_OP_MANGLE_CHR_INCR
:
19422 SET_NAME (rule
, rule_buf
[rule_pos
]);
19423 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19426 case RULE_OP_MANGLE_CHR_DECR
:
19427 SET_NAME (rule
, rule_buf
[rule_pos
]);
19428 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19431 case RULE_OP_MANGLE_REPLACE_NP1
:
19432 SET_NAME (rule
, rule_buf
[rule_pos
]);
19433 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19436 case RULE_OP_MANGLE_REPLACE_NM1
:
19437 SET_NAME (rule
, rule_buf
[rule_pos
]);
19438 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19441 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19442 SET_NAME (rule
, rule_buf
[rule_pos
]);
19443 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19446 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19447 SET_NAME (rule
, rule_buf
[rule_pos
]);
19448 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19451 case RULE_OP_MANGLE_TITLE
:
19452 SET_NAME (rule
, rule_buf
[rule_pos
]);
19461 if (rule_pos
< rule_len
) return (-1);
19466 int kernel_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], kernel_rule_t
*rule
)
19470 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19474 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19478 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19482 case RULE_OP_MANGLE_NOOP
:
19483 rule_buf
[rule_pos
] = rule_cmd
;
19486 case RULE_OP_MANGLE_LREST
:
19487 rule_buf
[rule_pos
] = rule_cmd
;
19490 case RULE_OP_MANGLE_UREST
:
19491 rule_buf
[rule_pos
] = rule_cmd
;
19494 case RULE_OP_MANGLE_LREST_UFIRST
:
19495 rule_buf
[rule_pos
] = rule_cmd
;
19498 case RULE_OP_MANGLE_UREST_LFIRST
:
19499 rule_buf
[rule_pos
] = rule_cmd
;
19502 case RULE_OP_MANGLE_TREST
:
19503 rule_buf
[rule_pos
] = rule_cmd
;
19506 case RULE_OP_MANGLE_TOGGLE_AT
:
19507 rule_buf
[rule_pos
] = rule_cmd
;
19508 GET_P0_CONV (rule
);
19511 case RULE_OP_MANGLE_REVERSE
:
19512 rule_buf
[rule_pos
] = rule_cmd
;
19515 case RULE_OP_MANGLE_DUPEWORD
:
19516 rule_buf
[rule_pos
] = rule_cmd
;
19519 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19520 rule_buf
[rule_pos
] = rule_cmd
;
19521 GET_P0_CONV (rule
);
19524 case RULE_OP_MANGLE_REFLECT
:
19525 rule_buf
[rule_pos
] = rule_cmd
;
19528 case RULE_OP_MANGLE_ROTATE_LEFT
:
19529 rule_buf
[rule_pos
] = rule_cmd
;
19532 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19533 rule_buf
[rule_pos
] = rule_cmd
;
19536 case RULE_OP_MANGLE_APPEND
:
19537 rule_buf
[rule_pos
] = rule_cmd
;
19541 case RULE_OP_MANGLE_PREPEND
:
19542 rule_buf
[rule_pos
] = rule_cmd
;
19546 case RULE_OP_MANGLE_DELETE_FIRST
:
19547 rule_buf
[rule_pos
] = rule_cmd
;
19550 case RULE_OP_MANGLE_DELETE_LAST
:
19551 rule_buf
[rule_pos
] = rule_cmd
;
19554 case RULE_OP_MANGLE_DELETE_AT
:
19555 rule_buf
[rule_pos
] = rule_cmd
;
19556 GET_P0_CONV (rule
);
19559 case RULE_OP_MANGLE_EXTRACT
:
19560 rule_buf
[rule_pos
] = rule_cmd
;
19561 GET_P0_CONV (rule
);
19562 GET_P1_CONV (rule
);
19565 case RULE_OP_MANGLE_OMIT
:
19566 rule_buf
[rule_pos
] = rule_cmd
;
19567 GET_P0_CONV (rule
);
19568 GET_P1_CONV (rule
);
19571 case RULE_OP_MANGLE_INSERT
:
19572 rule_buf
[rule_pos
] = rule_cmd
;
19573 GET_P0_CONV (rule
);
19577 case RULE_OP_MANGLE_OVERSTRIKE
:
19578 rule_buf
[rule_pos
] = rule_cmd
;
19579 GET_P0_CONV (rule
);
19583 case RULE_OP_MANGLE_TRUNCATE_AT
:
19584 rule_buf
[rule_pos
] = rule_cmd
;
19585 GET_P0_CONV (rule
);
19588 case RULE_OP_MANGLE_REPLACE
:
19589 rule_buf
[rule_pos
] = rule_cmd
;
19594 case RULE_OP_MANGLE_PURGECHAR
:
19598 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19602 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19603 rule_buf
[rule_pos
] = rule_cmd
;
19604 GET_P0_CONV (rule
);
19607 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19608 rule_buf
[rule_pos
] = rule_cmd
;
19609 GET_P0_CONV (rule
);
19612 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19613 rule_buf
[rule_pos
] = rule_cmd
;
19616 case RULE_OP_MANGLE_SWITCH_FIRST
:
19617 rule_buf
[rule_pos
] = rule_cmd
;
19620 case RULE_OP_MANGLE_SWITCH_LAST
:
19621 rule_buf
[rule_pos
] = rule_cmd
;
19624 case RULE_OP_MANGLE_SWITCH_AT
:
19625 rule_buf
[rule_pos
] = rule_cmd
;
19626 GET_P0_CONV (rule
);
19627 GET_P1_CONV (rule
);
19630 case RULE_OP_MANGLE_CHR_SHIFTL
:
19631 rule_buf
[rule_pos
] = rule_cmd
;
19632 GET_P0_CONV (rule
);
19635 case RULE_OP_MANGLE_CHR_SHIFTR
:
19636 rule_buf
[rule_pos
] = rule_cmd
;
19637 GET_P0_CONV (rule
);
19640 case RULE_OP_MANGLE_CHR_INCR
:
19641 rule_buf
[rule_pos
] = rule_cmd
;
19642 GET_P0_CONV (rule
);
19645 case RULE_OP_MANGLE_CHR_DECR
:
19646 rule_buf
[rule_pos
] = rule_cmd
;
19647 GET_P0_CONV (rule
);
19650 case RULE_OP_MANGLE_REPLACE_NP1
:
19651 rule_buf
[rule_pos
] = rule_cmd
;
19652 GET_P0_CONV (rule
);
19655 case RULE_OP_MANGLE_REPLACE_NM1
:
19656 rule_buf
[rule_pos
] = rule_cmd
;
19657 GET_P0_CONV (rule
);
19660 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19661 rule_buf
[rule_pos
] = rule_cmd
;
19662 GET_P0_CONV (rule
);
19665 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19666 rule_buf
[rule_pos
] = rule_cmd
;
19667 GET_P0_CONV (rule
);
19670 case RULE_OP_MANGLE_TITLE
:
19671 rule_buf
[rule_pos
] = rule_cmd
;
19675 return rule_pos
- 1;
19693 * CPU rules : this is from hashcat sources, cpu based rules
19696 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19697 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19699 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19700 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19701 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19703 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19704 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19705 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19707 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19711 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19716 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19720 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19725 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19729 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19734 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19739 for (l
= 0; l
< arr_len
; l
++)
19741 r
= arr_len
- 1 - l
;
19745 MANGLE_SWITCH (arr
, l
, r
);
19751 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19753 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19755 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19757 return (arr_len
* 2);
19760 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19762 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19764 int orig_len
= arr_len
;
19768 for (i
= 0; i
< times
; i
++)
19770 memcpy (&arr
[arr_len
], arr
, orig_len
);
19772 arr_len
+= orig_len
;
19778 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19780 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19782 mangle_double (arr
, arr_len
);
19784 mangle_reverse (arr
+ arr_len
, arr_len
);
19786 return (arr_len
* 2);
19789 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
19794 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
19796 MANGLE_SWITCH (arr
, l
, r
);
19802 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
19807 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
19809 MANGLE_SWITCH (arr
, l
, r
);
19815 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19817 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19821 return (arr_len
+ 1);
19824 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19826 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19830 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19832 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19837 return (arr_len
+ 1);
19840 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19842 if (upos
>= arr_len
) return (arr_len
);
19846 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
19848 arr
[arr_pos
] = arr
[arr_pos
+ 1];
19851 return (arr_len
- 1);
19854 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19856 if (upos
>= arr_len
) return (arr_len
);
19858 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
19862 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
19864 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
19870 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19872 if (upos
>= arr_len
) return (arr_len
);
19874 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
19878 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
19880 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
19883 return (arr_len
- ulen
);
19886 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19888 if (upos
>= arr_len
) return (arr_len
);
19890 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19894 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
19896 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19901 return (arr_len
+ 1);
19904 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
)
19906 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
19908 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
19910 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
19912 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
19914 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
19916 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
19918 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
19920 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
19922 return (arr_len
+ arr2_cpy
);
19925 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19927 if (upos
>= arr_len
) return (arr_len
);
19934 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19936 if (upos
>= arr_len
) return (arr_len
);
19938 memset (arr
+ upos
, 0, arr_len
- upos
);
19943 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
19947 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19949 if (arr
[arr_pos
] != oldc
) continue;
19951 arr
[arr_pos
] = newc
;
19957 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19963 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19965 if (arr
[arr_pos
] == c
) continue;
19967 arr
[ret_len
] = arr
[arr_pos
];
19975 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19977 if (ulen
> arr_len
) return (arr_len
);
19979 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19981 char cs
[100] = { 0 };
19983 memcpy (cs
, arr
, ulen
);
19987 for (i
= 0; i
< ulen
; i
++)
19991 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
19997 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19999 if (ulen
> arr_len
) return (arr_len
);
20001 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20003 int upos
= arr_len
- ulen
;
20007 for (i
= 0; i
< ulen
; i
++)
20009 char c
= arr
[upos
+ i
];
20011 arr_len
= mangle_append (arr
, arr_len
, c
);
20017 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20019 if ( arr_len
== 0) return (arr_len
);
20020 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20022 char c
= arr
[upos
];
20026 for (i
= 0; i
< ulen
; i
++)
20028 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20034 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20036 if ( arr_len
== 0) return (arr_len
);
20037 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20041 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20043 int new_pos
= arr_pos
* 2;
20045 arr
[new_pos
] = arr
[arr_pos
];
20047 arr
[new_pos
+ 1] = arr
[arr_pos
];
20050 return (arr_len
* 2);
20053 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20055 if (upos
>= arr_len
) return (arr_len
);
20056 if (upos2
>= arr_len
) return (arr_len
);
20058 MANGLE_SWITCH (arr
, upos
, upos2
);
20063 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20065 MANGLE_SWITCH (arr
, upos
, upos2
);
20070 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20072 if (upos
>= arr_len
) return (arr_len
);
20079 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20081 if (upos
>= arr_len
) return (arr_len
);
20088 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20090 if (upos
>= arr_len
) return (arr_len
);
20097 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20099 if (upos
>= arr_len
) return (arr_len
);
20106 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20108 int upper_next
= 1;
20112 for (pos
= 0; pos
< arr_len
; pos
++)
20114 if (arr
[pos
] == ' ')
20125 MANGLE_UPPER_AT (arr
, pos
);
20129 MANGLE_LOWER_AT (arr
, pos
);
20136 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20138 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20144 for (j
= 0; j
< rp_gen_num
; j
++)
20151 switch ((char) get_random_num (0, 9))
20154 r
= get_random_num (0, sizeof (grp_op_nop
));
20155 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20159 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20160 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20161 p1
= get_random_num (0, sizeof (grp_pos
));
20162 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20166 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20167 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20168 p1
= get_random_num (1, 6);
20169 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20173 r
= get_random_num (0, sizeof (grp_op_chr
));
20174 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20175 p1
= get_random_num (0x20, 0x7e);
20176 rule_buf
[rule_pos
++] = (char) p1
;
20180 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20181 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20182 p1
= get_random_num (0x20, 0x7e);
20183 rule_buf
[rule_pos
++] = (char) p1
;
20184 p2
= get_random_num (0x20, 0x7e);
20186 p2
= get_random_num (0x20, 0x7e);
20187 rule_buf
[rule_pos
++] = (char) p2
;
20191 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20192 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20193 p1
= get_random_num (0, sizeof (grp_pos
));
20194 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20195 p2
= get_random_num (0x20, 0x7e);
20196 rule_buf
[rule_pos
++] = (char) p2
;
20200 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20201 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20202 p1
= get_random_num (0, sizeof (grp_pos
));
20203 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20204 p2
= get_random_num (0, sizeof (grp_pos
));
20206 p2
= get_random_num (0, sizeof (grp_pos
));
20207 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20211 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20212 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
20213 p1
= get_random_num (0, sizeof (grp_pos
));
20214 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20215 p2
= get_random_num (1, sizeof (grp_pos
));
20217 p2
= get_random_num (1, sizeof (grp_pos
));
20218 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20222 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
20223 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
20224 p1
= get_random_num (0, sizeof (grp_pos
));
20225 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20226 p2
= get_random_num (1, sizeof (grp_pos
));
20227 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20228 p3
= get_random_num (0, sizeof (grp_pos
));
20229 rule_buf
[rule_pos
++] = grp_pos
[p3
];
20237 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
20239 char mem
[BLOCK_SIZE
] = { 0 };
20241 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
20243 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
20245 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20247 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
20249 int out_len
= in_len
;
20250 int mem_len
= in_len
;
20252 memcpy (out
, in
, out_len
);
20256 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
20261 switch (rule
[rule_pos
])
20266 case RULE_OP_MANGLE_NOOP
:
20269 case RULE_OP_MANGLE_LREST
:
20270 out_len
= mangle_lrest (out
, out_len
);
20273 case RULE_OP_MANGLE_UREST
:
20274 out_len
= mangle_urest (out
, out_len
);
20277 case RULE_OP_MANGLE_LREST_UFIRST
:
20278 out_len
= mangle_lrest (out
, out_len
);
20279 if (out_len
) MANGLE_UPPER_AT (out
, 0);
20282 case RULE_OP_MANGLE_UREST_LFIRST
:
20283 out_len
= mangle_urest (out
, out_len
);
20284 if (out_len
) MANGLE_LOWER_AT (out
, 0);
20287 case RULE_OP_MANGLE_TREST
:
20288 out_len
= mangle_trest (out
, out_len
);
20291 case RULE_OP_MANGLE_TOGGLE_AT
:
20292 NEXT_RULEPOS (rule_pos
);
20293 NEXT_RPTOI (rule
, rule_pos
, upos
);
20294 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
20297 case RULE_OP_MANGLE_REVERSE
:
20298 out_len
= mangle_reverse (out
, out_len
);
20301 case RULE_OP_MANGLE_DUPEWORD
:
20302 out_len
= mangle_double (out
, out_len
);
20305 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20306 NEXT_RULEPOS (rule_pos
);
20307 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20308 out_len
= mangle_double_times (out
, out_len
, ulen
);
20311 case RULE_OP_MANGLE_REFLECT
:
20312 out_len
= mangle_reflect (out
, out_len
);
20315 case RULE_OP_MANGLE_ROTATE_LEFT
:
20316 mangle_rotate_left (out
, out_len
);
20319 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20320 mangle_rotate_right (out
, out_len
);
20323 case RULE_OP_MANGLE_APPEND
:
20324 NEXT_RULEPOS (rule_pos
);
20325 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
20328 case RULE_OP_MANGLE_PREPEND
:
20329 NEXT_RULEPOS (rule_pos
);
20330 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
20333 case RULE_OP_MANGLE_DELETE_FIRST
:
20334 out_len
= mangle_delete_at (out
, out_len
, 0);
20337 case RULE_OP_MANGLE_DELETE_LAST
:
20338 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
20341 case RULE_OP_MANGLE_DELETE_AT
:
20342 NEXT_RULEPOS (rule_pos
);
20343 NEXT_RPTOI (rule
, rule_pos
, upos
);
20344 out_len
= mangle_delete_at (out
, out_len
, upos
);
20347 case RULE_OP_MANGLE_EXTRACT
:
20348 NEXT_RULEPOS (rule_pos
);
20349 NEXT_RPTOI (rule
, rule_pos
, upos
);
20350 NEXT_RULEPOS (rule_pos
);
20351 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20352 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
20355 case RULE_OP_MANGLE_OMIT
:
20356 NEXT_RULEPOS (rule_pos
);
20357 NEXT_RPTOI (rule
, rule_pos
, upos
);
20358 NEXT_RULEPOS (rule_pos
);
20359 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20360 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
20363 case RULE_OP_MANGLE_INSERT
:
20364 NEXT_RULEPOS (rule_pos
);
20365 NEXT_RPTOI (rule
, rule_pos
, upos
);
20366 NEXT_RULEPOS (rule_pos
);
20367 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
20370 case RULE_OP_MANGLE_OVERSTRIKE
:
20371 NEXT_RULEPOS (rule_pos
);
20372 NEXT_RPTOI (rule
, rule_pos
, upos
);
20373 NEXT_RULEPOS (rule_pos
);
20374 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20377 case RULE_OP_MANGLE_TRUNCATE_AT
:
20378 NEXT_RULEPOS (rule_pos
);
20379 NEXT_RPTOI (rule
, rule_pos
, upos
);
20380 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20383 case RULE_OP_MANGLE_REPLACE
:
20384 NEXT_RULEPOS (rule_pos
);
20385 NEXT_RULEPOS (rule_pos
);
20386 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20389 case RULE_OP_MANGLE_PURGECHAR
:
20390 NEXT_RULEPOS (rule_pos
);
20391 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20394 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20398 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20399 NEXT_RULEPOS (rule_pos
);
20400 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20401 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20404 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20405 NEXT_RULEPOS (rule_pos
);
20406 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20407 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20410 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20411 out_len
= mangle_dupechar (out
, out_len
);
20414 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20415 NEXT_RULEPOS (rule_pos
);
20416 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20417 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20420 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20421 NEXT_RULEPOS (rule_pos
);
20422 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20423 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20426 case RULE_OP_MANGLE_SWITCH_FIRST
:
20427 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20430 case RULE_OP_MANGLE_SWITCH_LAST
:
20431 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20434 case RULE_OP_MANGLE_SWITCH_AT
:
20435 NEXT_RULEPOS (rule_pos
);
20436 NEXT_RPTOI (rule
, rule_pos
, upos
);
20437 NEXT_RULEPOS (rule_pos
);
20438 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20439 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20442 case RULE_OP_MANGLE_CHR_SHIFTL
:
20443 NEXT_RULEPOS (rule_pos
);
20444 NEXT_RPTOI (rule
, rule_pos
, upos
);
20445 mangle_chr_shiftl (out
, out_len
, upos
);
20448 case RULE_OP_MANGLE_CHR_SHIFTR
:
20449 NEXT_RULEPOS (rule_pos
);
20450 NEXT_RPTOI (rule
, rule_pos
, upos
);
20451 mangle_chr_shiftr (out
, out_len
, upos
);
20454 case RULE_OP_MANGLE_CHR_INCR
:
20455 NEXT_RULEPOS (rule_pos
);
20456 NEXT_RPTOI (rule
, rule_pos
, upos
);
20457 mangle_chr_incr (out
, out_len
, upos
);
20460 case RULE_OP_MANGLE_CHR_DECR
:
20461 NEXT_RULEPOS (rule_pos
);
20462 NEXT_RPTOI (rule
, rule_pos
, upos
);
20463 mangle_chr_decr (out
, out_len
, upos
);
20466 case RULE_OP_MANGLE_REPLACE_NP1
:
20467 NEXT_RULEPOS (rule_pos
);
20468 NEXT_RPTOI (rule
, rule_pos
, upos
);
20469 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20472 case RULE_OP_MANGLE_REPLACE_NM1
:
20473 NEXT_RULEPOS (rule_pos
);
20474 NEXT_RPTOI (rule
, rule_pos
, upos
);
20475 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20478 case RULE_OP_MANGLE_TITLE
:
20479 out_len
= mangle_title (out
, out_len
);
20482 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20483 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20484 NEXT_RULEPOS (rule_pos
);
20485 NEXT_RPTOI (rule
, rule_pos
, upos
);
20486 NEXT_RULEPOS (rule_pos
);
20487 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20488 NEXT_RULEPOS (rule_pos
);
20489 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20490 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20493 case RULE_OP_MANGLE_APPEND_MEMORY
:
20494 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20495 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20496 memcpy (out
+ out_len
, mem
, mem_len
);
20497 out_len
+= mem_len
;
20500 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20501 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20502 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20503 memcpy (mem
+ mem_len
, out
, out_len
);
20504 out_len
+= mem_len
;
20505 memcpy (out
, mem
, out_len
);
20508 case RULE_OP_MEMORIZE_WORD
:
20509 memcpy (mem
, out
, out_len
);
20513 case RULE_OP_REJECT_LESS
:
20514 NEXT_RULEPOS (rule_pos
);
20515 NEXT_RPTOI (rule
, rule_pos
, upos
);
20516 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20519 case RULE_OP_REJECT_GREATER
:
20520 NEXT_RULEPOS (rule_pos
);
20521 NEXT_RPTOI (rule
, rule_pos
, upos
);
20522 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20525 case RULE_OP_REJECT_CONTAIN
:
20526 NEXT_RULEPOS (rule_pos
);
20527 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20530 case RULE_OP_REJECT_NOT_CONTAIN
:
20531 NEXT_RULEPOS (rule_pos
);
20532 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20535 case RULE_OP_REJECT_EQUAL_FIRST
:
20536 NEXT_RULEPOS (rule_pos
);
20537 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20540 case RULE_OP_REJECT_EQUAL_LAST
:
20541 NEXT_RULEPOS (rule_pos
);
20542 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20545 case RULE_OP_REJECT_EQUAL_AT
:
20546 NEXT_RULEPOS (rule_pos
);
20547 NEXT_RPTOI (rule
, rule_pos
, upos
);
20548 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20549 NEXT_RULEPOS (rule_pos
);
20550 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20553 case RULE_OP_REJECT_CONTAINS
:
20554 NEXT_RULEPOS (rule_pos
);
20555 NEXT_RPTOI (rule
, rule_pos
, upos
);
20556 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20557 NEXT_RULEPOS (rule_pos
);
20558 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20559 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20562 case RULE_OP_REJECT_MEMORY
:
20563 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20567 return (RULE_RC_SYNTAX_ERROR
);
20572 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);