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;
5837 case 13100: return ((char *) HT_13100
); break;
5840 return ((char *) "Unknown");
5843 char *strstatus (const uint devices_status
)
5845 switch (devices_status
)
5847 case STATUS_INIT
: return ((char *) ST_0000
); break;
5848 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5849 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5850 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5851 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5852 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5853 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5854 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5855 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5856 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5857 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
5860 return ((char *) "Unknown");
5863 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5865 uint hash_type
= data
.hash_type
;
5866 uint hash_mode
= data
.hash_mode
;
5867 uint salt_type
= data
.salt_type
;
5868 uint opts_type
= data
.opts_type
;
5869 uint opti_type
= data
.opti_type
;
5870 uint dgst_size
= data
.dgst_size
;
5872 char *hashfile
= data
.hashfile
;
5876 uint digest_buf
[64] = { 0 };
5878 u64
*digest_buf64
= (u64
*) digest_buf
;
5880 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5882 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5884 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5890 case HASH_TYPE_DESCRYPT
:
5891 FP (digest_buf
[1], digest_buf
[0], tt
);
5894 case HASH_TYPE_DESRACF
:
5895 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5896 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5898 FP (digest_buf
[1], digest_buf
[0], tt
);
5902 FP (digest_buf
[1], digest_buf
[0], tt
);
5905 case HASH_TYPE_NETNTLM
:
5906 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5907 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5908 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5909 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5911 FP (digest_buf
[1], digest_buf
[0], tt
);
5912 FP (digest_buf
[3], digest_buf
[2], tt
);
5915 case HASH_TYPE_BSDICRYPT
:
5916 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5917 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5919 FP (digest_buf
[1], digest_buf
[0], tt
);
5924 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5929 digest_buf
[0] += MD4M_A
;
5930 digest_buf
[1] += MD4M_B
;
5931 digest_buf
[2] += MD4M_C
;
5932 digest_buf
[3] += MD4M_D
;
5936 digest_buf
[0] += MD5M_A
;
5937 digest_buf
[1] += MD5M_B
;
5938 digest_buf
[2] += MD5M_C
;
5939 digest_buf
[3] += MD5M_D
;
5942 case HASH_TYPE_SHA1
:
5943 digest_buf
[0] += SHA1M_A
;
5944 digest_buf
[1] += SHA1M_B
;
5945 digest_buf
[2] += SHA1M_C
;
5946 digest_buf
[3] += SHA1M_D
;
5947 digest_buf
[4] += SHA1M_E
;
5950 case HASH_TYPE_SHA256
:
5951 digest_buf
[0] += SHA256M_A
;
5952 digest_buf
[1] += SHA256M_B
;
5953 digest_buf
[2] += SHA256M_C
;
5954 digest_buf
[3] += SHA256M_D
;
5955 digest_buf
[4] += SHA256M_E
;
5956 digest_buf
[5] += SHA256M_F
;
5957 digest_buf
[6] += SHA256M_G
;
5958 digest_buf
[7] += SHA256M_H
;
5961 case HASH_TYPE_SHA384
:
5962 digest_buf64
[0] += SHA384M_A
;
5963 digest_buf64
[1] += SHA384M_B
;
5964 digest_buf64
[2] += SHA384M_C
;
5965 digest_buf64
[3] += SHA384M_D
;
5966 digest_buf64
[4] += SHA384M_E
;
5967 digest_buf64
[5] += SHA384M_F
;
5968 digest_buf64
[6] += 0;
5969 digest_buf64
[7] += 0;
5972 case HASH_TYPE_SHA512
:
5973 digest_buf64
[0] += SHA512M_A
;
5974 digest_buf64
[1] += SHA512M_B
;
5975 digest_buf64
[2] += SHA512M_C
;
5976 digest_buf64
[3] += SHA512M_D
;
5977 digest_buf64
[4] += SHA512M_E
;
5978 digest_buf64
[5] += SHA512M_F
;
5979 digest_buf64
[6] += SHA512M_G
;
5980 digest_buf64
[7] += SHA512M_H
;
5985 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
5987 if (dgst_size
== DGST_SIZE_4_2
)
5989 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5991 else if (dgst_size
== DGST_SIZE_4_4
)
5993 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5995 else if (dgst_size
== DGST_SIZE_4_5
)
5997 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5999 else if (dgst_size
== DGST_SIZE_4_6
)
6001 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6003 else if (dgst_size
== DGST_SIZE_4_8
)
6005 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6007 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6009 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6011 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6013 else if (hash_type
== HASH_TYPE_SHA384
)
6015 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6017 else if (hash_type
== HASH_TYPE_SHA512
)
6019 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6021 else if (hash_type
== HASH_TYPE_GOST
)
6023 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6026 else if (dgst_size
== DGST_SIZE_4_64
)
6028 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6030 else if (dgst_size
== DGST_SIZE_8_25
)
6032 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6036 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6037 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6038 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6044 memset (&salt
, 0, sizeof (salt_t
));
6046 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6048 char *ptr
= (char *) salt
.salt_buf
;
6050 uint len
= salt
.salt_len
;
6052 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6058 case HASH_TYPE_NETNTLM
:
6060 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6061 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6063 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6069 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6071 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6079 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6081 uint max
= salt
.salt_len
/ 4;
6085 for (uint i
= 0; i
< max
; i
++)
6087 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6091 if (opts_type
& OPTS_TYPE_ST_HEX
)
6093 char tmp
[64] = { 0 };
6095 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6097 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6102 memcpy (ptr
, tmp
, len
);
6105 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6107 memset (ptr
+ len
, 0, memset_size
);
6109 salt
.salt_len
= len
;
6113 // some modes require special encoding
6116 uint out_buf_plain
[256] = { 0 };
6117 uint out_buf_salt
[256] = { 0 };
6119 char tmp_buf
[1024] = { 0 };
6121 char *ptr_plain
= (char *) out_buf_plain
;
6122 char *ptr_salt
= (char *) out_buf_salt
;
6124 if (hash_mode
== 22)
6126 char username
[30] = { 0 };
6128 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6130 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6132 u16
*ptr
= (u16
*) digest_buf
;
6134 tmp_buf
[ 0] = sig
[0];
6135 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6136 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6137 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6138 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6139 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6140 tmp_buf
[ 6] = sig
[1];
6141 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6142 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6143 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6144 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6145 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6146 tmp_buf
[12] = sig
[2];
6147 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6148 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6149 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6150 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6151 tmp_buf
[17] = sig
[3];
6152 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6153 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6154 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6155 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6156 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6157 tmp_buf
[23] = sig
[4];
6158 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6159 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6160 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6161 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6162 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6163 tmp_buf
[29] = sig
[5];
6165 snprintf (out_buf
, len
-1, "%s:%s",
6169 else if (hash_mode
== 23)
6171 // do not show the \nskyper\n part in output
6173 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6175 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6177 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6184 else if (hash_mode
== 101)
6186 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6188 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6189 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6190 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6191 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6192 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6194 memcpy (tmp_buf
, digest_buf
, 20);
6196 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6198 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6200 else if (hash_mode
== 111)
6202 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6204 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6205 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6206 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6207 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6208 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6210 memcpy (tmp_buf
, digest_buf
, 20);
6211 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6213 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6215 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6217 else if (hash_mode
== 122)
6219 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6220 (char *) salt
.salt_buf
,
6227 else if (hash_mode
== 124)
6229 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6230 (char *) salt
.salt_buf
,
6237 else if (hash_mode
== 131)
6239 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6240 (char *) salt
.salt_buf
,
6248 else if (hash_mode
== 132)
6250 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6251 (char *) salt
.salt_buf
,
6258 else if (hash_mode
== 133)
6260 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6262 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6263 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6264 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6265 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6266 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6268 memcpy (tmp_buf
, digest_buf
, 20);
6270 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6272 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6274 else if (hash_mode
== 141)
6276 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6278 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6280 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6282 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6284 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6285 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6286 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6287 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6288 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6290 memcpy (tmp_buf
, digest_buf
, 20);
6292 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6296 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6298 else if (hash_mode
== 400)
6300 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6302 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6303 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6304 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6305 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6307 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6309 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6311 else if (hash_mode
== 500)
6313 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6315 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6316 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6317 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6318 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6320 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6322 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6324 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6328 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6331 else if (hash_mode
== 501)
6333 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6335 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6336 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6338 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6340 else if (hash_mode
== 1421)
6342 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6344 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6360 else if (hash_mode
== 1441)
6362 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6364 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6366 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6368 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6370 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6371 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6372 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6373 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6374 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6375 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6376 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6377 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6379 memcpy (tmp_buf
, digest_buf
, 32);
6381 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6385 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6387 else if (hash_mode
== 1500)
6389 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6390 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6391 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6392 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6393 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6395 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6397 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6399 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6400 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6402 memcpy (tmp_buf
, digest_buf
, 8);
6404 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6406 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6410 else if (hash_mode
== 1600)
6412 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6414 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6415 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6416 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6417 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6419 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6421 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6423 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6427 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6430 else if (hash_mode
== 1711)
6432 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6434 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6435 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6436 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6437 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6438 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6439 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6440 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6441 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6443 memcpy (tmp_buf
, digest_buf
, 64);
6444 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6446 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6448 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6450 else if (hash_mode
== 1722)
6452 uint
*ptr
= digest_buf
;
6454 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6455 (unsigned char *) salt
.salt_buf
,
6465 else if (hash_mode
== 1731)
6467 uint
*ptr
= digest_buf
;
6469 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6470 (unsigned char *) salt
.salt_buf
,
6480 else if (hash_mode
== 1800)
6484 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6485 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6486 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6487 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6488 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6489 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6490 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6491 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6493 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6495 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6497 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6501 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6504 else if (hash_mode
== 2100)
6508 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6510 salt
.salt_iter
+ 1);
6512 uint signature_len
= strlen (out_buf
);
6514 pos
+= signature_len
;
6515 len
-= signature_len
;
6517 char *salt_ptr
= (char *) salt
.salt_buf
;
6519 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6521 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6522 byte_swap_32 (digest_buf
[0]),
6523 byte_swap_32 (digest_buf
[1]),
6524 byte_swap_32 (digest_buf
[2]),
6525 byte_swap_32 (digest_buf
[3]));
6527 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6529 memcpy (tmp_buf
, digest_buf
, 16);
6531 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6533 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6534 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6535 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6536 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6538 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6539 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6540 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6541 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6543 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6544 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6545 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6546 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6548 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6549 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6550 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6551 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6553 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6554 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6555 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6556 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6560 else if (hash_mode
== 2500)
6562 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6564 wpa_t
*wpa
= &wpas
[salt_pos
];
6566 uint pke
[25] = { 0 };
6568 char *pke_ptr
= (char *) pke
;
6570 for (uint i
= 0; i
< 25; i
++)
6572 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6575 unsigned char mac1
[6] = { 0 };
6576 unsigned char mac2
[6] = { 0 };
6578 memcpy (mac1
, pke_ptr
+ 23, 6);
6579 memcpy (mac2
, pke_ptr
+ 29, 6);
6581 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6582 (char *) salt
.salt_buf
,
6596 else if (hash_mode
== 4400)
6598 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6599 byte_swap_32 (digest_buf
[0]),
6600 byte_swap_32 (digest_buf
[1]),
6601 byte_swap_32 (digest_buf
[2]),
6602 byte_swap_32 (digest_buf
[3]));
6604 else if (hash_mode
== 4700)
6606 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6607 byte_swap_32 (digest_buf
[0]),
6608 byte_swap_32 (digest_buf
[1]),
6609 byte_swap_32 (digest_buf
[2]),
6610 byte_swap_32 (digest_buf
[3]),
6611 byte_swap_32 (digest_buf
[4]));
6613 else if (hash_mode
== 4800)
6615 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6617 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6622 byte_swap_32 (salt
.salt_buf
[0]),
6623 byte_swap_32 (salt
.salt_buf
[1]),
6624 byte_swap_32 (salt
.salt_buf
[2]),
6625 byte_swap_32 (salt
.salt_buf
[3]),
6628 else if (hash_mode
== 4900)
6630 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6631 byte_swap_32 (digest_buf
[0]),
6632 byte_swap_32 (digest_buf
[1]),
6633 byte_swap_32 (digest_buf
[2]),
6634 byte_swap_32 (digest_buf
[3]),
6635 byte_swap_32 (digest_buf
[4]));
6637 else if (hash_mode
== 5100)
6639 snprintf (out_buf
, len
-1, "%08x%08x",
6643 else if (hash_mode
== 5200)
6645 snprintf (out_buf
, len
-1, "%s", hashfile
);
6647 else if (hash_mode
== 5300)
6649 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6651 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6653 int buf_len
= len
-1;
6657 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6659 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6661 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6663 snprintf (out_buf
, buf_len
, ":");
6669 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6677 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6679 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6681 if ((i
== 0) || (i
== 5))
6683 snprintf (out_buf
, buf_len
, ":");
6689 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6697 for (uint i
= 0; i
< 4; i
++)
6701 snprintf (out_buf
, buf_len
, ":");
6707 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6713 else if (hash_mode
== 5400)
6715 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6717 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6719 int buf_len
= len
-1;
6723 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6725 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6727 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6729 snprintf (out_buf
, buf_len
, ":");
6735 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6743 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6745 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6747 if ((i
== 0) || (i
== 5))
6749 snprintf (out_buf
, buf_len
, ":");
6755 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6763 for (uint i
= 0; i
< 5; i
++)
6767 snprintf (out_buf
, buf_len
, ":");
6773 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6779 else if (hash_mode
== 5500)
6781 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6783 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6785 char user_buf
[64] = { 0 };
6786 char domain_buf
[64] = { 0 };
6787 char srvchall_buf
[1024] = { 0 };
6788 char clichall_buf
[1024] = { 0 };
6790 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6792 char *ptr
= (char *) netntlm
->userdomain_buf
;
6794 user_buf
[i
] = ptr
[j
];
6797 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6799 char *ptr
= (char *) netntlm
->userdomain_buf
;
6801 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6804 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6806 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6808 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6811 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6813 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6815 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6818 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6826 byte_swap_32 (salt
.salt_buf_pc
[0]),
6827 byte_swap_32 (salt
.salt_buf_pc
[1]),
6830 else if (hash_mode
== 5600)
6832 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6834 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6836 char user_buf
[64] = { 0 };
6837 char domain_buf
[64] = { 0 };
6838 char srvchall_buf
[1024] = { 0 };
6839 char clichall_buf
[1024] = { 0 };
6841 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6843 char *ptr
= (char *) netntlm
->userdomain_buf
;
6845 user_buf
[i
] = ptr
[j
];
6848 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6850 char *ptr
= (char *) netntlm
->userdomain_buf
;
6852 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6855 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6857 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6859 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6862 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6864 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6866 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6869 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6879 else if (hash_mode
== 5700)
6881 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6883 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6884 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6885 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6886 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6887 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6888 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6889 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6890 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6892 memcpy (tmp_buf
, digest_buf
, 32);
6894 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6898 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6900 else if (hash_mode
== 5800)
6902 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6903 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6904 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6905 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6906 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6908 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6915 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6917 snprintf (out_buf
, len
-1, "%s", hashfile
);
6919 else if (hash_mode
== 6300)
6921 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6923 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6924 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6925 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6926 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6928 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6930 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6932 else if (hash_mode
== 6400)
6934 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6936 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6938 else if (hash_mode
== 6500)
6940 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6942 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6944 else if (hash_mode
== 6600)
6946 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6948 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6950 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6951 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6953 uint buf_len
= len
- 1;
6955 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6958 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6960 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6965 else if (hash_mode
== 6700)
6967 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6969 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6971 else if (hash_mode
== 6800)
6973 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6975 else if (hash_mode
== 7100)
6977 uint
*ptr
= digest_buf
;
6979 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6981 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6983 uint esalt
[8] = { 0 };
6985 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6986 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6987 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6988 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6989 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6990 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6991 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6992 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6994 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",
6995 SIGNATURE_SHA512OSX
,
6997 esalt
[ 0], esalt
[ 1],
6998 esalt
[ 2], esalt
[ 3],
6999 esalt
[ 4], esalt
[ 5],
7000 esalt
[ 6], esalt
[ 7],
7008 ptr
[15], ptr
[14]);
7010 else if (hash_mode
== 7200)
7012 uint
*ptr
= digest_buf
;
7014 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7016 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7020 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7022 len_used
= strlen (out_buf
);
7024 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7026 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7028 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7031 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",
7039 ptr
[15], ptr
[14]);
7041 else if (hash_mode
== 7300)
7043 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7045 rakp_t
*rakp
= &rakps
[salt_pos
];
7047 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7049 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7052 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7059 else if (hash_mode
== 7400)
7061 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7063 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7064 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7065 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7066 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7067 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7068 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7069 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7070 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7072 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7074 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7076 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7080 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7083 else if (hash_mode
== 7500)
7085 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7087 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7089 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7090 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7092 char data
[128] = { 0 };
7094 char *ptr_data
= data
;
7096 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7098 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7101 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7103 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7108 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7110 (char *) krb5pa
->user
,
7111 (char *) krb5pa
->realm
,
7112 (char *) krb5pa
->salt
,
7115 else if (hash_mode
== 7700)
7117 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7118 (char *) salt
.salt_buf
,
7122 else if (hash_mode
== 7800)
7124 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7125 (char *) salt
.salt_buf
,
7132 else if (hash_mode
== 7900)
7134 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7138 char *tmp
= (char *) salt
.salt_buf_pc
;
7140 ptr_plain
[42] = tmp
[0];
7146 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7148 else if (hash_mode
== 8000)
7150 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7151 (unsigned char *) salt
.salt_buf
,
7161 else if (hash_mode
== 8100)
7163 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7164 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7166 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7167 (unsigned char *) salt
.salt_buf
,
7174 else if (hash_mode
== 8200)
7176 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7178 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7180 char data_buf
[4096] = { 0 };
7182 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7184 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7187 data_buf
[cloudkey
->data_len
* 2] = 0;
7189 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7190 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7191 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7192 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7193 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7194 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7195 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7196 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7198 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7199 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7200 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7201 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7203 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7219 else if (hash_mode
== 8300)
7221 char digest_buf_c
[34] = { 0 };
7223 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7225 digest_buf_c
[32] = 0;
7229 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7231 char domain_buf_c
[33] = { 0 };
7233 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7235 for (uint i
= 0; i
< salt_pc_len
; i
++)
7237 const char next
= domain_buf_c
[i
];
7239 domain_buf_c
[i
] = '.';
7244 domain_buf_c
[salt_pc_len
] = 0;
7248 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7250 else if (hash_mode
== 8500)
7252 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7254 else if (hash_mode
== 2612)
7256 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7258 (char *) salt
.salt_buf
,
7264 else if (hash_mode
== 3711)
7266 char *salt_ptr
= (char *) salt
.salt_buf
;
7268 salt_ptr
[salt
.salt_len
- 1] = 0;
7270 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7271 SIGNATURE_MEDIAWIKI_B
,
7278 else if (hash_mode
== 8800)
7280 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7282 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7284 char tmp
[3073] = { 0 };
7286 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7288 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7293 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7294 SIGNATURE_ANDROIDFDE
,
7295 byte_swap_32 (salt
.salt_buf
[0]),
7296 byte_swap_32 (salt
.salt_buf
[1]),
7297 byte_swap_32 (salt
.salt_buf
[2]),
7298 byte_swap_32 (salt
.salt_buf
[3]),
7299 byte_swap_32 (digest_buf
[0]),
7300 byte_swap_32 (digest_buf
[1]),
7301 byte_swap_32 (digest_buf
[2]),
7302 byte_swap_32 (digest_buf
[3]),
7305 else if (hash_mode
== 8900)
7307 uint N
= salt
.scrypt_N
;
7308 uint r
= salt
.scrypt_r
;
7309 uint p
= salt
.scrypt_p
;
7311 char base64_salt
[32] = { 0 };
7313 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7315 memset (tmp_buf
, 0, 46);
7317 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7318 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7319 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7320 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7321 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7322 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7323 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7324 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7325 digest_buf
[8] = 0; // needed for base64_encode ()
7327 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7329 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7337 else if (hash_mode
== 9000)
7339 snprintf (out_buf
, len
-1, "%s", hashfile
);
7341 else if (hash_mode
== 9200)
7345 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7347 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7349 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7353 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7354 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7355 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7356 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7357 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7358 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7359 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7360 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7361 digest_buf
[8] = 0; // needed for base64_encode ()
7363 char tmp_buf
[64] = { 0 };
7365 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7366 tmp_buf
[43] = 0; // cut it here
7370 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7372 else if (hash_mode
== 9300)
7374 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7375 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7376 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7377 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7378 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7379 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7380 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7381 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7382 digest_buf
[8] = 0; // needed for base64_encode ()
7384 char tmp_buf
[64] = { 0 };
7386 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7387 tmp_buf
[43] = 0; // cut it here
7389 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7391 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7393 else if (hash_mode
== 9400)
7395 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7397 office2007_t
*office2007
= &office2007s
[salt_pos
];
7399 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7400 SIGNATURE_OFFICE2007
,
7403 office2007
->keySize
,
7409 office2007
->encryptedVerifier
[0],
7410 office2007
->encryptedVerifier
[1],
7411 office2007
->encryptedVerifier
[2],
7412 office2007
->encryptedVerifier
[3],
7413 office2007
->encryptedVerifierHash
[0],
7414 office2007
->encryptedVerifierHash
[1],
7415 office2007
->encryptedVerifierHash
[2],
7416 office2007
->encryptedVerifierHash
[3],
7417 office2007
->encryptedVerifierHash
[4]);
7419 else if (hash_mode
== 9500)
7421 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7423 office2010_t
*office2010
= &office2010s
[salt_pos
];
7425 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,
7431 office2010
->encryptedVerifier
[0],
7432 office2010
->encryptedVerifier
[1],
7433 office2010
->encryptedVerifier
[2],
7434 office2010
->encryptedVerifier
[3],
7435 office2010
->encryptedVerifierHash
[0],
7436 office2010
->encryptedVerifierHash
[1],
7437 office2010
->encryptedVerifierHash
[2],
7438 office2010
->encryptedVerifierHash
[3],
7439 office2010
->encryptedVerifierHash
[4],
7440 office2010
->encryptedVerifierHash
[5],
7441 office2010
->encryptedVerifierHash
[6],
7442 office2010
->encryptedVerifierHash
[7]);
7444 else if (hash_mode
== 9600)
7446 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7448 office2013_t
*office2013
= &office2013s
[salt_pos
];
7450 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,
7456 office2013
->encryptedVerifier
[0],
7457 office2013
->encryptedVerifier
[1],
7458 office2013
->encryptedVerifier
[2],
7459 office2013
->encryptedVerifier
[3],
7460 office2013
->encryptedVerifierHash
[0],
7461 office2013
->encryptedVerifierHash
[1],
7462 office2013
->encryptedVerifierHash
[2],
7463 office2013
->encryptedVerifierHash
[3],
7464 office2013
->encryptedVerifierHash
[4],
7465 office2013
->encryptedVerifierHash
[5],
7466 office2013
->encryptedVerifierHash
[6],
7467 office2013
->encryptedVerifierHash
[7]);
7469 else if (hash_mode
== 9700)
7471 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7473 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7475 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7476 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7477 byte_swap_32 (salt
.salt_buf
[0]),
7478 byte_swap_32 (salt
.salt_buf
[1]),
7479 byte_swap_32 (salt
.salt_buf
[2]),
7480 byte_swap_32 (salt
.salt_buf
[3]),
7481 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7482 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7483 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7484 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7485 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7486 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7487 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7488 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7490 else if (hash_mode
== 9710)
7492 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7494 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7496 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7497 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7498 byte_swap_32 (salt
.salt_buf
[0]),
7499 byte_swap_32 (salt
.salt_buf
[1]),
7500 byte_swap_32 (salt
.salt_buf
[2]),
7501 byte_swap_32 (salt
.salt_buf
[3]),
7502 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7503 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7504 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7505 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7506 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7507 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7508 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7509 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7511 else if (hash_mode
== 9720)
7513 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7515 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7517 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7519 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7520 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7521 byte_swap_32 (salt
.salt_buf
[0]),
7522 byte_swap_32 (salt
.salt_buf
[1]),
7523 byte_swap_32 (salt
.salt_buf
[2]),
7524 byte_swap_32 (salt
.salt_buf
[3]),
7525 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7526 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7527 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7528 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7529 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7530 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7531 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7532 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7539 else if (hash_mode
== 9800)
7541 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7543 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7545 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7546 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7551 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7552 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7553 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7554 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7555 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7556 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7557 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7558 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7559 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7561 else if (hash_mode
== 9810)
7563 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7565 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7567 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7568 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7573 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7574 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7575 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7576 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7577 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7578 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7579 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7580 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7581 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7583 else if (hash_mode
== 9820)
7585 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7587 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7589 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7591 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7592 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7597 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7598 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7599 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7600 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7601 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7602 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7603 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7604 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7605 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7612 else if (hash_mode
== 10000)
7616 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7618 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7620 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7624 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7625 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7626 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7627 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7628 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7629 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7630 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7631 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7632 digest_buf
[8] = 0; // needed for base64_encode ()
7634 char tmp_buf
[64] = { 0 };
7636 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7640 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7642 else if (hash_mode
== 10100)
7644 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7649 byte_swap_32 (salt
.salt_buf
[0]),
7650 byte_swap_32 (salt
.salt_buf
[1]),
7651 byte_swap_32 (salt
.salt_buf
[2]),
7652 byte_swap_32 (salt
.salt_buf
[3]));
7654 else if (hash_mode
== 10200)
7656 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7658 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7662 char challenge
[100] = { 0 };
7664 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7668 char tmp_buf
[100] = { 0 };
7670 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7671 (char *) cram_md5
->user
,
7677 char response
[100] = { 0 };
7679 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7681 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7683 else if (hash_mode
== 10300)
7685 char tmp_buf
[100] = { 0 };
7687 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7688 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7690 uint tmp_len
= 20 + salt
.salt_len
;
7694 char base64_encoded
[100] = { 0 };
7696 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7698 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7700 else if (hash_mode
== 10400)
7702 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7704 pdf_t
*pdf
= &pdfs
[salt_pos
];
7706 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",
7714 byte_swap_32 (pdf
->id_buf
[0]),
7715 byte_swap_32 (pdf
->id_buf
[1]),
7716 byte_swap_32 (pdf
->id_buf
[2]),
7717 byte_swap_32 (pdf
->id_buf
[3]),
7719 byte_swap_32 (pdf
->u_buf
[0]),
7720 byte_swap_32 (pdf
->u_buf
[1]),
7721 byte_swap_32 (pdf
->u_buf
[2]),
7722 byte_swap_32 (pdf
->u_buf
[3]),
7723 byte_swap_32 (pdf
->u_buf
[4]),
7724 byte_swap_32 (pdf
->u_buf
[5]),
7725 byte_swap_32 (pdf
->u_buf
[6]),
7726 byte_swap_32 (pdf
->u_buf
[7]),
7728 byte_swap_32 (pdf
->o_buf
[0]),
7729 byte_swap_32 (pdf
->o_buf
[1]),
7730 byte_swap_32 (pdf
->o_buf
[2]),
7731 byte_swap_32 (pdf
->o_buf
[3]),
7732 byte_swap_32 (pdf
->o_buf
[4]),
7733 byte_swap_32 (pdf
->o_buf
[5]),
7734 byte_swap_32 (pdf
->o_buf
[6]),
7735 byte_swap_32 (pdf
->o_buf
[7])
7738 else if (hash_mode
== 10410)
7740 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7742 pdf_t
*pdf
= &pdfs
[salt_pos
];
7744 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",
7752 byte_swap_32 (pdf
->id_buf
[0]),
7753 byte_swap_32 (pdf
->id_buf
[1]),
7754 byte_swap_32 (pdf
->id_buf
[2]),
7755 byte_swap_32 (pdf
->id_buf
[3]),
7757 byte_swap_32 (pdf
->u_buf
[0]),
7758 byte_swap_32 (pdf
->u_buf
[1]),
7759 byte_swap_32 (pdf
->u_buf
[2]),
7760 byte_swap_32 (pdf
->u_buf
[3]),
7761 byte_swap_32 (pdf
->u_buf
[4]),
7762 byte_swap_32 (pdf
->u_buf
[5]),
7763 byte_swap_32 (pdf
->u_buf
[6]),
7764 byte_swap_32 (pdf
->u_buf
[7]),
7766 byte_swap_32 (pdf
->o_buf
[0]),
7767 byte_swap_32 (pdf
->o_buf
[1]),
7768 byte_swap_32 (pdf
->o_buf
[2]),
7769 byte_swap_32 (pdf
->o_buf
[3]),
7770 byte_swap_32 (pdf
->o_buf
[4]),
7771 byte_swap_32 (pdf
->o_buf
[5]),
7772 byte_swap_32 (pdf
->o_buf
[6]),
7773 byte_swap_32 (pdf
->o_buf
[7])
7776 else if (hash_mode
== 10420)
7778 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7780 pdf_t
*pdf
= &pdfs
[salt_pos
];
7782 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7784 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7792 byte_swap_32 (pdf
->id_buf
[0]),
7793 byte_swap_32 (pdf
->id_buf
[1]),
7794 byte_swap_32 (pdf
->id_buf
[2]),
7795 byte_swap_32 (pdf
->id_buf
[3]),
7797 byte_swap_32 (pdf
->u_buf
[0]),
7798 byte_swap_32 (pdf
->u_buf
[1]),
7799 byte_swap_32 (pdf
->u_buf
[2]),
7800 byte_swap_32 (pdf
->u_buf
[3]),
7801 byte_swap_32 (pdf
->u_buf
[4]),
7802 byte_swap_32 (pdf
->u_buf
[5]),
7803 byte_swap_32 (pdf
->u_buf
[6]),
7804 byte_swap_32 (pdf
->u_buf
[7]),
7806 byte_swap_32 (pdf
->o_buf
[0]),
7807 byte_swap_32 (pdf
->o_buf
[1]),
7808 byte_swap_32 (pdf
->o_buf
[2]),
7809 byte_swap_32 (pdf
->o_buf
[3]),
7810 byte_swap_32 (pdf
->o_buf
[4]),
7811 byte_swap_32 (pdf
->o_buf
[5]),
7812 byte_swap_32 (pdf
->o_buf
[6]),
7813 byte_swap_32 (pdf
->o_buf
[7]),
7821 else if (hash_mode
== 10500)
7823 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7825 pdf_t
*pdf
= &pdfs
[salt_pos
];
7827 if (pdf
->id_len
== 32)
7829 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",
7837 byte_swap_32 (pdf
->id_buf
[0]),
7838 byte_swap_32 (pdf
->id_buf
[1]),
7839 byte_swap_32 (pdf
->id_buf
[2]),
7840 byte_swap_32 (pdf
->id_buf
[3]),
7841 byte_swap_32 (pdf
->id_buf
[4]),
7842 byte_swap_32 (pdf
->id_buf
[5]),
7843 byte_swap_32 (pdf
->id_buf
[6]),
7844 byte_swap_32 (pdf
->id_buf
[7]),
7846 byte_swap_32 (pdf
->u_buf
[0]),
7847 byte_swap_32 (pdf
->u_buf
[1]),
7848 byte_swap_32 (pdf
->u_buf
[2]),
7849 byte_swap_32 (pdf
->u_buf
[3]),
7850 byte_swap_32 (pdf
->u_buf
[4]),
7851 byte_swap_32 (pdf
->u_buf
[5]),
7852 byte_swap_32 (pdf
->u_buf
[6]),
7853 byte_swap_32 (pdf
->u_buf
[7]),
7855 byte_swap_32 (pdf
->o_buf
[0]),
7856 byte_swap_32 (pdf
->o_buf
[1]),
7857 byte_swap_32 (pdf
->o_buf
[2]),
7858 byte_swap_32 (pdf
->o_buf
[3]),
7859 byte_swap_32 (pdf
->o_buf
[4]),
7860 byte_swap_32 (pdf
->o_buf
[5]),
7861 byte_swap_32 (pdf
->o_buf
[6]),
7862 byte_swap_32 (pdf
->o_buf
[7])
7867 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",
7875 byte_swap_32 (pdf
->id_buf
[0]),
7876 byte_swap_32 (pdf
->id_buf
[1]),
7877 byte_swap_32 (pdf
->id_buf
[2]),
7878 byte_swap_32 (pdf
->id_buf
[3]),
7880 byte_swap_32 (pdf
->u_buf
[0]),
7881 byte_swap_32 (pdf
->u_buf
[1]),
7882 byte_swap_32 (pdf
->u_buf
[2]),
7883 byte_swap_32 (pdf
->u_buf
[3]),
7884 byte_swap_32 (pdf
->u_buf
[4]),
7885 byte_swap_32 (pdf
->u_buf
[5]),
7886 byte_swap_32 (pdf
->u_buf
[6]),
7887 byte_swap_32 (pdf
->u_buf
[7]),
7889 byte_swap_32 (pdf
->o_buf
[0]),
7890 byte_swap_32 (pdf
->o_buf
[1]),
7891 byte_swap_32 (pdf
->o_buf
[2]),
7892 byte_swap_32 (pdf
->o_buf
[3]),
7893 byte_swap_32 (pdf
->o_buf
[4]),
7894 byte_swap_32 (pdf
->o_buf
[5]),
7895 byte_swap_32 (pdf
->o_buf
[6]),
7896 byte_swap_32 (pdf
->o_buf
[7])
7900 else if (hash_mode
== 10600)
7902 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7904 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7905 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7907 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7909 else if (hash_mode
== 10700)
7911 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7913 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7914 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7916 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7918 else if (hash_mode
== 10900)
7920 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7922 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7923 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7925 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7927 else if (hash_mode
== 11100)
7929 u32 salt_challenge
= salt
.salt_buf
[0];
7931 salt_challenge
= byte_swap_32 (salt_challenge
);
7933 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7935 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7936 SIGNATURE_POSTGRESQL_AUTH
,
7944 else if (hash_mode
== 11200)
7946 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7947 SIGNATURE_MYSQL_AUTH
,
7948 (unsigned char *) salt
.salt_buf
,
7955 else if (hash_mode
== 11300)
7957 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7959 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7961 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7962 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7963 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7965 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7966 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7967 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7969 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7971 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7973 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7976 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7978 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7980 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7983 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7985 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
7987 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7990 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
7991 SIGNATURE_BITCOIN_WALLET
,
7995 (unsigned char *) salt
.salt_buf
,
8003 free (cry_master_buf
);
8005 free (public_key_buf
);
8007 else if (hash_mode
== 11400)
8009 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8011 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8012 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8014 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8016 else if (hash_mode
== 11600)
8018 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8020 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8022 const uint data_len
= seven_zip
->data_len
;
8024 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8026 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8028 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8030 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8033 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8034 SIGNATURE_SEVEN_ZIP
,
8038 (char *) seven_zip
->salt_buf
,
8040 seven_zip
->iv_buf
[0],
8041 seven_zip
->iv_buf
[1],
8042 seven_zip
->iv_buf
[2],
8043 seven_zip
->iv_buf
[3],
8045 seven_zip
->data_len
,
8046 seven_zip
->unpack_size
,
8051 else if (hash_mode
== 11700)
8053 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8063 else if (hash_mode
== 11800)
8065 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8083 else if (hash_mode
== 11900)
8085 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8087 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8088 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8090 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8092 else if (hash_mode
== 12000)
8094 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8096 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8097 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8099 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8101 else if (hash_mode
== 12100)
8103 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8105 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8106 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8108 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8110 else if (hash_mode
== 12200)
8112 uint
*ptr_digest
= digest_buf
;
8113 uint
*ptr_salt
= salt
.salt_buf
;
8115 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8122 else if (hash_mode
== 12300)
8124 uint
*ptr_digest
= digest_buf
;
8125 uint
*ptr_salt
= salt
.salt_buf
;
8127 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",
8128 ptr_digest
[ 0], ptr_digest
[ 1],
8129 ptr_digest
[ 2], ptr_digest
[ 3],
8130 ptr_digest
[ 4], ptr_digest
[ 5],
8131 ptr_digest
[ 6], ptr_digest
[ 7],
8132 ptr_digest
[ 8], ptr_digest
[ 9],
8133 ptr_digest
[10], ptr_digest
[11],
8134 ptr_digest
[12], ptr_digest
[13],
8135 ptr_digest
[14], ptr_digest
[15],
8141 else if (hash_mode
== 12400)
8143 // encode iteration count
8145 char salt_iter
[5] = { 0 };
8147 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8148 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8149 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8150 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8155 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8156 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8157 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8158 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8163 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8165 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8166 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8168 memcpy (tmp_buf
, digest_buf
, 8);
8170 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8174 // fill the resulting buffer
8176 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8178 else if (hash_mode
== 12500)
8180 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8182 byte_swap_32 (salt
.salt_buf
[0]),
8183 byte_swap_32 (salt
.salt_buf
[1]),
8189 else if (hash_mode
== 12600)
8191 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8192 digest_buf
[0] + salt
.salt_buf_pc
[0],
8193 digest_buf
[1] + salt
.salt_buf_pc
[1],
8194 digest_buf
[2] + salt
.salt_buf_pc
[2],
8195 digest_buf
[3] + salt
.salt_buf_pc
[3],
8196 digest_buf
[4] + salt
.salt_buf_pc
[4],
8197 digest_buf
[5] + salt
.salt_buf_pc
[5],
8198 digest_buf
[6] + salt
.salt_buf_pc
[6],
8199 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8201 else if (hash_mode
== 12700)
8203 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8205 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8206 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8208 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8210 else if (hash_mode
== 12800)
8212 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8214 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",
8227 byte_swap_32 (digest_buf
[0]),
8228 byte_swap_32 (digest_buf
[1]),
8229 byte_swap_32 (digest_buf
[2]),
8230 byte_swap_32 (digest_buf
[3]),
8231 byte_swap_32 (digest_buf
[4]),
8232 byte_swap_32 (digest_buf
[5]),
8233 byte_swap_32 (digest_buf
[6]),
8234 byte_swap_32 (digest_buf
[7])
8237 else if (hash_mode
== 12900)
8239 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",
8248 byte_swap_32 (digest_buf
[0]),
8249 byte_swap_32 (digest_buf
[1]),
8250 byte_swap_32 (digest_buf
[2]),
8251 byte_swap_32 (digest_buf
[3]),
8252 byte_swap_32 (digest_buf
[4]),
8253 byte_swap_32 (digest_buf
[5]),
8254 byte_swap_32 (digest_buf
[6]),
8255 byte_swap_32 (digest_buf
[7]),
8262 else if (hash_mode
== 13000)
8264 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8266 rar5_t
*rar5
= &rar5s
[salt_pos
];
8268 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8278 byte_swap_32 (digest_buf
[0]),
8279 byte_swap_32 (digest_buf
[1])
8282 else if (hash_mode
== 13100)
8284 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8286 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8288 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8289 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8291 char data
[256] = { 0 };
8293 char *ptr_data
= data
;
8295 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8296 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8301 for (uint i
= 0; i
< 32; i
++, ptr_data
+= 2)
8302 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8306 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8308 (char *) krb5tgs
->account_info
,
8314 if (hash_type
== HASH_TYPE_MD4
)
8316 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8322 else if (hash_type
== HASH_TYPE_MD5
)
8324 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8330 else if (hash_type
== HASH_TYPE_SHA1
)
8332 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8339 else if (hash_type
== HASH_TYPE_SHA256
)
8341 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8351 else if (hash_type
== HASH_TYPE_SHA384
)
8353 uint
*ptr
= digest_buf
;
8355 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8363 else if (hash_type
== HASH_TYPE_SHA512
)
8365 uint
*ptr
= digest_buf
;
8367 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8377 else if (hash_type
== HASH_TYPE_LM
)
8379 snprintf (out_buf
, len
-1, "%08x%08x",
8383 else if (hash_type
== HASH_TYPE_ORACLEH
)
8385 snprintf (out_buf
, len
-1, "%08X%08X",
8389 else if (hash_type
== HASH_TYPE_BCRYPT
)
8391 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8392 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8394 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8396 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8398 else if (hash_type
== HASH_TYPE_KECCAK
)
8400 uint
*ptr
= digest_buf
;
8402 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",
8430 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8432 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8434 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8441 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8443 digest_buf
[ 0] = digest_buf
[ 0];
8444 digest_buf
[ 1] = digest_buf
[ 1];
8445 digest_buf
[ 2] = digest_buf
[ 2];
8446 digest_buf
[ 3] = digest_buf
[ 3];
8447 digest_buf
[ 4] = digest_buf
[ 4];
8448 digest_buf
[ 5] = digest_buf
[ 5];
8449 digest_buf
[ 6] = digest_buf
[ 6];
8450 digest_buf
[ 7] = digest_buf
[ 7];
8451 digest_buf
[ 8] = digest_buf
[ 8];
8452 digest_buf
[ 9] = digest_buf
[ 9];
8453 digest_buf
[10] = digest_buf
[10];
8454 digest_buf
[11] = digest_buf
[11];
8455 digest_buf
[12] = digest_buf
[12];
8456 digest_buf
[13] = digest_buf
[13];
8457 digest_buf
[14] = digest_buf
[14];
8458 digest_buf
[15] = digest_buf
[15];
8460 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8478 else if (hash_type
== HASH_TYPE_GOST
)
8480 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8490 else if (hash_type
== HASH_TYPE_MYSQL
)
8492 snprintf (out_buf
, len
-1, "%08x%08x",
8496 else if (hash_type
== HASH_TYPE_LOTUS5
)
8498 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8504 else if (hash_type
== HASH_TYPE_LOTUS6
)
8506 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8507 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8508 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8509 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8511 char buf
[16] = { 0 };
8513 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8514 memcpy (buf
+ 5, digest_buf
, 9);
8518 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8520 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8523 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8525 else if (hash_type
== HASH_TYPE_LOTUS8
)
8527 char buf
[52] = { 0 };
8531 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8537 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8541 buf
[26] = salt
.salt_buf_pc
[0];
8542 buf
[27] = salt
.salt_buf_pc
[1];
8546 memcpy (buf
+ 28, digest_buf
, 8);
8548 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8552 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8554 else if (hash_type
== HASH_TYPE_CRC32
)
8556 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8560 if (salt_type
== SALT_TYPE_INTERN
)
8562 size_t pos
= strlen (out_buf
);
8564 out_buf
[pos
] = data
.separator
;
8566 char *ptr
= (char *) salt
.salt_buf
;
8568 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8570 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8574 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8576 memset (hccap
, 0, sizeof (hccap_t
));
8578 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8580 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8582 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8583 wpa_t
*wpa
= &wpas
[salt_pos
];
8585 hccap
->keyver
= wpa
->keyver
;
8587 hccap
->eapol_size
= wpa
->eapol_size
;
8589 if (wpa
->keyver
!= 1)
8591 uint eapol_tmp
[64] = { 0 };
8593 for (uint i
= 0; i
< 64; i
++)
8595 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8598 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8602 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8605 uint pke_tmp
[25] = { 0 };
8607 for (int i
= 5; i
< 25; i
++)
8609 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8612 char *pke_ptr
= (char *) pke_tmp
;
8614 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8615 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8616 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8617 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8619 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8621 uint dgst_size
= data
.dgst_size
;
8623 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8625 if (wpa
->keyver
!= 1)
8627 uint digest_tmp
[4] = { 0 };
8629 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8630 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8631 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8632 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8634 memcpy (hccap
->keymic
, digest_tmp
, 16);
8638 memcpy (hccap
->keymic
, digest_ptr
, 16);
8642 void SuspendThreads ()
8644 if (data
.devices_status
== STATUS_RUNNING
)
8646 hc_timer_set (&data
.timer_paused
);
8648 data
.devices_status
= STATUS_PAUSED
;
8650 log_info ("Paused");
8654 void ResumeThreads ()
8656 if (data
.devices_status
== STATUS_PAUSED
)
8660 hc_timer_get (data
.timer_paused
, ms_paused
);
8662 data
.ms_paused
+= ms_paused
;
8664 data
.devices_status
= STATUS_RUNNING
;
8666 log_info ("Resumed");
8672 if (data
.devices_status
!= STATUS_RUNNING
) return;
8674 data
.devices_status
= STATUS_BYPASS
;
8676 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8679 void stop_at_checkpoint ()
8681 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8683 if (data
.devices_status
!= STATUS_RUNNING
) return;
8686 // this feature only makes sense if --restore-disable was not specified
8688 if (data
.restore_disable
== 1)
8690 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8695 // check if monitoring of Restore Point updates should be enabled or disabled
8697 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8699 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8701 // save the current restore point value
8703 data
.checkpoint_cur_words
= get_lowest_words_done ();
8705 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8709 data
.devices_status
= STATUS_RUNNING
;
8711 // reset the global value for checkpoint checks
8713 data
.checkpoint_cur_words
= 0;
8715 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8721 if (data
.devices_status
== STATUS_INIT
) return;
8722 if (data
.devices_status
== STATUS_STARTING
) return;
8724 data
.devices_status
= STATUS_ABORTED
;
8729 if (data
.devices_status
== STATUS_INIT
) return;
8730 if (data
.devices_status
== STATUS_STARTING
) return;
8732 data
.devices_status
= STATUS_QUIT
;
8735 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8737 FILE *fp
= fopen (kernel_file
, "rb");
8743 memset (&st
, 0, sizeof (st
));
8745 stat (kernel_file
, &st
);
8747 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8749 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8751 if (num_read
!= (size_t) st
.st_size
)
8753 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8760 buf
[st
.st_size
] = 0;
8762 for (int i
= 0; i
< num_devices
; i
++)
8764 kernel_lengths
[i
] = (size_t) st
.st_size
;
8766 kernel_sources
[i
] = buf
;
8771 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8779 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8781 if (binary_size
> 0)
8783 FILE *fp
= fopen (dst
, "wb");
8786 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8797 restore_data_t
*init_restore (int argc
, char **argv
)
8799 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8801 if (data
.restore_disable
== 0)
8803 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8807 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8811 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8820 char pidbin
[BUFSIZ
] = { 0 };
8822 int pidbin_len
= -1;
8825 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8827 FILE *fd
= fopen (pidbin
, "rb");
8831 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8833 pidbin
[pidbin_len
] = 0;
8837 char *argv0_r
= strrchr (argv
[0], '/');
8839 char *pidbin_r
= strrchr (pidbin
, '/');
8841 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8843 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8845 if (strcmp (argv0_r
, pidbin_r
) == 0)
8847 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8854 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8856 char pidbin2
[BUFSIZ
] = { 0 };
8858 int pidbin2_len
= -1;
8860 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8861 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8863 pidbin
[pidbin_len
] = 0;
8864 pidbin2
[pidbin2_len
] = 0;
8868 if (strcmp (pidbin
, pidbin2
) == 0)
8870 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8878 if (rd
->version_bin
< RESTORE_MIN
)
8880 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8887 memset (rd
, 0, sizeof (restore_data_t
));
8889 rd
->version_bin
= VERSION_BIN
;
8892 rd
->pid
= getpid ();
8894 rd
->pid
= GetCurrentProcessId ();
8897 if (getcwd (rd
->cwd
, 255) == NULL
)
8910 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8912 FILE *fp
= fopen (eff_restore_file
, "rb");
8916 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8921 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8923 log_error ("ERROR: cannot read %s", eff_restore_file
);
8928 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8930 for (uint i
= 0; i
< rd
->argc
; i
++)
8932 char buf
[BUFSIZ
] = { 0 };
8934 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8936 log_error ("ERROR: cannot read %s", eff_restore_file
);
8941 size_t len
= strlen (buf
);
8943 if (len
) buf
[len
- 1] = 0;
8945 rd
->argv
[i
] = mystrdup (buf
);
8950 char new_cwd
[1024] = { 0 };
8952 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8956 log_error ("Restore file is corrupted");
8959 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8961 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8963 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8968 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8971 if (chdir (rd
->cwd
))
8973 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8979 u64
get_lowest_words_done ()
8983 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8985 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8987 if (device_param
->skipped
) continue;
8989 const u64 words_done
= device_param
->words_done
;
8991 if (words_done
< words_cur
) words_cur
= words_done
;
8994 // It's possible that a device's workload isn't finished right after a restore-case.
8995 // In that case, this function would return 0 and overwrite the real restore point
8996 // There's also data.words_cur which is set to rd->words_cur but it changes while
8997 // the attack is running therefore we should stick to rd->words_cur.
8998 // Note that -s influences rd->words_cur we should keep a close look on that.
9000 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9005 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9007 u64 words_cur
= get_lowest_words_done ();
9009 rd
->words_cur
= words_cur
;
9011 FILE *fp
= fopen (new_restore_file
, "wb");
9015 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9020 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9022 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9027 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9029 for (uint i
= 0; i
< rd
->argc
; i
++)
9031 fprintf (fp
, "%s", rd
->argv
[i
]);
9037 fsync (fileno (fp
));
9042 void cycle_restore ()
9044 const char *eff_restore_file
= data
.eff_restore_file
;
9045 const char *new_restore_file
= data
.new_restore_file
;
9047 restore_data_t
*rd
= data
.rd
;
9049 write_restore (new_restore_file
, rd
);
9053 memset (&st
, 0, sizeof(st
));
9055 if (stat (eff_restore_file
, &st
) == 0)
9057 if (unlink (eff_restore_file
))
9059 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9063 if (rename (new_restore_file
, eff_restore_file
))
9065 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9069 void check_checkpoint ()
9071 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9073 u64 words_cur
= get_lowest_words_done ();
9075 if (words_cur
!= data
.checkpoint_cur_words
)
9085 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9089 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9091 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9093 myfree (alias
->device_name
);
9094 myfree (alias
->alias_name
);
9097 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9099 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9101 myfree (entry
->device_name
);
9104 myfree (tuning_db
->alias_buf
);
9105 myfree (tuning_db
->entry_buf
);
9110 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9112 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9114 int num_lines
= count_lines (fp
);
9116 // a bit over-allocated
9118 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9119 tuning_db
->alias_cnt
= 0;
9121 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9122 tuning_db
->entry_cnt
= 0;
9127 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9129 FILE *fp
= fopen (tuning_db_file
, "rb");
9133 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9138 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9148 char *line_buf
= fgets (buf
, sizeof (buf
) - 1, fp
);
9150 if (line_buf
== NULL
) break;
9154 const int line_len
= in_superchop (line_buf
);
9156 if (line_len
== 0) continue;
9158 if (line_buf
[0] == '#') continue;
9162 char *token_ptr
[7] = { NULL
};
9166 char *next
= strtok (line_buf
, "\t ");
9168 token_ptr
[token_cnt
] = next
;
9172 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9174 token_ptr
[token_cnt
] = next
;
9181 char *device_name
= token_ptr
[0];
9182 char *alias_name
= token_ptr
[1];
9184 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9186 alias
->device_name
= mystrdup (device_name
);
9187 alias
->alias_name
= mystrdup (alias_name
);
9189 tuning_db
->alias_cnt
++;
9191 else if (token_cnt
== 6)
9193 if ((token_ptr
[1][0] != '0') &&
9194 (token_ptr
[1][0] != '1') &&
9195 (token_ptr
[1][0] != '3') &&
9196 (token_ptr
[1][0] != '*'))
9198 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9203 if ((token_ptr
[3][0] != '1') &&
9204 (token_ptr
[3][0] != '2') &&
9205 (token_ptr
[3][0] != '4') &&
9206 (token_ptr
[3][0] != '8') &&
9207 (token_ptr
[3][0] != 'N'))
9209 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9214 char *device_name
= token_ptr
[0];
9216 int attack_mode
= -1;
9218 int vector_width
= -1;
9219 int kernel_accel
= -1;
9220 int kernel_loops
= -1;
9222 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9223 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9224 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9226 if (token_ptr
[4][0] != 'A')
9228 kernel_accel
= atoi (token_ptr
[4]);
9230 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9232 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9242 if (token_ptr
[5][0] != 'A')
9244 kernel_loops
= atoi (token_ptr
[5]);
9246 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9248 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9258 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9260 entry
->device_name
= mystrdup (device_name
);
9261 entry
->attack_mode
= attack_mode
;
9262 entry
->hash_type
= hash_type
;
9263 entry
->vector_width
= vector_width
;
9264 entry
->kernel_accel
= kernel_accel
;
9265 entry
->kernel_loops
= kernel_loops
;
9267 tuning_db
->entry_cnt
++;
9271 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9279 // todo: print loaded 'cnt' message
9281 // sort the database
9283 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9284 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9289 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, char *device_name
, int attack_mode
, int hash_type
)
9291 static tuning_db_entry_t s
;
9293 // first we need to convert all spaces in the device_name to underscore
9295 char *device_name_nospace
= strdup (device_name
);
9297 int device_name_length
= strlen (device_name_nospace
);
9301 for (i
= 0; i
< device_name_length
; i
++)
9303 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9306 // find out if there's an alias configured
9308 tuning_db_alias_t a
;
9310 a
.device_name
= device_name_nospace
;
9312 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
);
9314 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9316 // attack-mode 6 and 7 are attack-mode 1 basically
9318 if (attack_mode
== 6) attack_mode
= 1;
9319 if (attack_mode
== 7) attack_mode
= 1;
9321 // bsearch is not ideal but fast enough
9323 s
.device_name
= device_name_nospace
;
9324 s
.attack_mode
= attack_mode
;
9325 s
.hash_type
= hash_type
;
9327 tuning_db_entry_t
*entry
= NULL
;
9329 // this will produce all 2^3 combinations required
9331 for (i
= 0; i
< 8; i
++)
9333 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9334 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9335 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9337 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9339 if (entry
!= NULL
) break;
9341 // in non-wildcard mode also check the alias_name
9343 if (((i
& 1) == 0) && (alias_name
!= NULL
))
9345 s
.device_name
= alias_name
;
9347 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9349 if (entry
!= NULL
) break;
9353 // free converted device_name
9355 myfree (device_name_nospace
);
9364 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9366 u8 tmp
[256] = { 0 };
9368 if (salt_len
> sizeof (tmp
))
9373 memcpy (tmp
, in
, salt_len
);
9375 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9377 if ((salt_len
% 2) == 0)
9379 u32 new_salt_len
= salt_len
/ 2;
9381 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9386 tmp
[i
] = hex_convert (p1
) << 0;
9387 tmp
[i
] |= hex_convert (p0
) << 4;
9390 salt_len
= new_salt_len
;
9397 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9399 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9402 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9404 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9408 u32
*tmp_uint
= (u32
*) tmp
;
9410 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9411 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9412 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9413 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9414 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9415 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9416 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9417 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9418 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9419 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9421 salt_len
= salt_len
* 2;
9429 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9431 lowercase (tmp
, salt_len
);
9434 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9436 uppercase (tmp
, salt_len
);
9441 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9446 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9451 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9453 u32
*tmp_uint
= (uint
*) tmp
;
9459 for (u32 i
= 0; i
< max
; i
++)
9461 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9464 // Important: we may need to increase the length of memcpy since
9465 // we don't want to "loose" some swapped bytes (could happen if
9466 // they do not perfectly fit in the 4-byte blocks)
9467 // Memcpy does always copy the bytes in the BE order, but since
9468 // we swapped them, some important bytes could be in positions
9469 // we normally skip with the original len
9471 if (len
% 4) len
+= 4 - (len
% 4);
9474 memcpy (out
, tmp
, len
);
9479 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9481 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9483 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9485 u32
*digest
= (u32
*) hash_buf
->digest
;
9487 salt_t
*salt
= hash_buf
->salt
;
9489 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9491 char *iter_pos
= input_buf
+ 4;
9493 salt
->salt_iter
= 1 << atoi (iter_pos
);
9495 char *salt_pos
= strchr (iter_pos
, '$');
9497 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9503 salt
->salt_len
= salt_len
;
9505 u8 tmp_buf
[100] = { 0 };
9507 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9509 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9511 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9513 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9514 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9515 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9516 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9518 char *hash_pos
= salt_pos
+ 22;
9520 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9522 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9524 memcpy (digest
, tmp_buf
, 24);
9526 digest
[0] = byte_swap_32 (digest
[0]);
9527 digest
[1] = byte_swap_32 (digest
[1]);
9528 digest
[2] = byte_swap_32 (digest
[2]);
9529 digest
[3] = byte_swap_32 (digest
[3]);
9530 digest
[4] = byte_swap_32 (digest
[4]);
9531 digest
[5] = byte_swap_32 (digest
[5]);
9533 digest
[5] &= ~0xff; // its just 23 not 24 !
9538 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9540 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9542 u32
*digest
= (u32
*) hash_buf
->digest
;
9544 u8 tmp_buf
[100] = { 0 };
9546 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9548 memcpy (digest
, tmp_buf
, 32);
9550 digest
[0] = byte_swap_32 (digest
[0]);
9551 digest
[1] = byte_swap_32 (digest
[1]);
9552 digest
[2] = byte_swap_32 (digest
[2]);
9553 digest
[3] = byte_swap_32 (digest
[3]);
9554 digest
[4] = byte_swap_32 (digest
[4]);
9555 digest
[5] = byte_swap_32 (digest
[5]);
9556 digest
[6] = byte_swap_32 (digest
[6]);
9557 digest
[7] = byte_swap_32 (digest
[7]);
9559 digest
[0] -= SHA256M_A
;
9560 digest
[1] -= SHA256M_B
;
9561 digest
[2] -= SHA256M_C
;
9562 digest
[3] -= SHA256M_D
;
9563 digest
[4] -= SHA256M_E
;
9564 digest
[5] -= SHA256M_F
;
9565 digest
[6] -= SHA256M_G
;
9566 digest
[7] -= SHA256M_H
;
9571 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9573 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9575 u32
*digest
= (u32
*) hash_buf
->digest
;
9577 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9578 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9580 digest
[0] = byte_swap_32 (digest
[0]);
9581 digest
[1] = byte_swap_32 (digest
[1]);
9585 IP (digest
[0], digest
[1], tt
);
9587 digest
[0] = digest
[0];
9588 digest
[1] = digest
[1];
9595 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9597 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9599 u32
*digest
= (u32
*) hash_buf
->digest
;
9601 salt_t
*salt
= hash_buf
->salt
;
9603 char *hash_pos
= input_buf
+ 8;
9605 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9606 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9607 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9608 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9609 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9611 digest
[0] -= SHA1M_A
;
9612 digest
[1] -= SHA1M_B
;
9613 digest
[2] -= SHA1M_C
;
9614 digest
[3] -= SHA1M_D
;
9615 digest
[4] -= SHA1M_E
;
9619 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9621 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9623 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9625 salt
->salt_len
= salt_len
;
9630 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9632 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9634 u64
*digest
= (u64
*) hash_buf
->digest
;
9636 salt_t
*salt
= hash_buf
->salt
;
9638 char *hash_pos
= input_buf
+ 8;
9640 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9641 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9642 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9643 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9644 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9645 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9646 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9647 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9649 digest
[0] -= SHA512M_A
;
9650 digest
[1] -= SHA512M_B
;
9651 digest
[2] -= SHA512M_C
;
9652 digest
[3] -= SHA512M_D
;
9653 digest
[4] -= SHA512M_E
;
9654 digest
[5] -= SHA512M_F
;
9655 digest
[6] -= SHA512M_G
;
9656 digest
[7] -= SHA512M_H
;
9660 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9662 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9664 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9666 salt
->salt_len
= salt_len
;
9671 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9673 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9675 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9679 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9682 u32
*digest
= (u32
*) hash_buf
->digest
;
9684 salt_t
*salt
= hash_buf
->salt
;
9686 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9687 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9688 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9689 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9691 digest
[0] = byte_swap_32 (digest
[0]);
9692 digest
[1] = byte_swap_32 (digest
[1]);
9693 digest
[2] = byte_swap_32 (digest
[2]);
9694 digest
[3] = byte_swap_32 (digest
[3]);
9696 digest
[0] -= MD5M_A
;
9697 digest
[1] -= MD5M_B
;
9698 digest
[2] -= MD5M_C
;
9699 digest
[3] -= MD5M_D
;
9701 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9703 uint salt_len
= input_len
- 32 - 1;
9705 char *salt_buf
= input_buf
+ 32 + 1;
9707 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9709 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9711 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9713 salt
->salt_len
= salt_len
;
9718 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9720 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9722 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9726 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9731 char clean_input_buf
[32] = { 0 };
9733 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9734 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9736 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9740 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9746 clean_input_buf
[k
] = input_buf
[i
];
9754 u32
*digest
= (u32
*) hash_buf
->digest
;
9756 salt_t
*salt
= hash_buf
->salt
;
9758 u32 a
, b
, c
, d
, e
, f
;
9760 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9761 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9762 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9763 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9764 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9765 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9767 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9768 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9770 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9771 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9772 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9773 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9774 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9775 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9777 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9778 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9780 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9781 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9782 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9783 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9784 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9785 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9787 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9788 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9790 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9791 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9792 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9793 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9794 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9795 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9797 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9798 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9800 digest
[0] = byte_swap_32 (digest
[0]);
9801 digest
[1] = byte_swap_32 (digest
[1]);
9802 digest
[2] = byte_swap_32 (digest
[2]);
9803 digest
[3] = byte_swap_32 (digest
[3]);
9805 digest
[0] -= MD5M_A
;
9806 digest
[1] -= MD5M_B
;
9807 digest
[2] -= MD5M_C
;
9808 digest
[3] -= MD5M_D
;
9810 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9812 uint salt_len
= input_len
- 30 - 1;
9814 char *salt_buf
= input_buf
+ 30 + 1;
9816 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9818 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9820 // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
9821 if (salt_len
> 10) return (PARSER_SALT_LENGTH
);
9823 salt
->salt_len
= salt_len
;
9825 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9827 salt
->salt_len
+= 22;
9832 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9834 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9836 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9840 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9843 u32
*digest
= (u32
*) hash_buf
->digest
;
9845 salt_t
*salt
= hash_buf
->salt
;
9847 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9848 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9849 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9850 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9851 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
9853 digest
[0] -= SHA1M_A
;
9854 digest
[1] -= SHA1M_B
;
9855 digest
[2] -= SHA1M_C
;
9856 digest
[3] -= SHA1M_D
;
9857 digest
[4] -= SHA1M_E
;
9859 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9861 uint salt_len
= input_len
- 40 - 1;
9863 char *salt_buf
= input_buf
+ 40 + 1;
9865 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9867 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9869 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9871 salt
->salt_len
= salt_len
;
9876 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9878 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9880 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9884 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9887 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9889 char *iter_pos
= input_buf
+ 6;
9891 salt_t
*salt
= hash_buf
->salt
;
9893 uint iter
= atoi (iter_pos
);
9900 salt
->salt_iter
= iter
- 1;
9902 char *salt_pos
= strchr (iter_pos
, '#');
9904 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9908 char *digest_pos
= strchr (salt_pos
, '#');
9910 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9914 uint salt_len
= digest_pos
- salt_pos
- 1;
9916 u32
*digest
= (u32
*) hash_buf
->digest
;
9918 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
9919 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
9920 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
9921 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
9923 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9925 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9927 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9929 salt
->salt_len
= salt_len
;
9934 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9936 u32
*digest
= (u32
*) hash_buf
->digest
;
9938 salt_t
*salt
= hash_buf
->salt
;
9940 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
9944 memcpy (&in
, input_buf
, input_len
);
9946 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
9948 memcpy (digest
, in
.keymic
, 16);
9951 http://www.one-net.eu/jsw/j_sec/m_ptype.html
9952 The phrase "Pairwise key expansion"
9953 Access Point Address (referred to as Authenticator Address AA)
9954 Supplicant Address (referred to as Supplicant Address SA)
9955 Access Point Nonce (referred to as Authenticator Anonce)
9956 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
9959 uint salt_len
= strlen (in
.essid
);
9961 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
9963 salt
->salt_len
= salt_len
;
9965 salt
->salt_iter
= ROUNDS_WPA2
- 1;
9967 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
9969 memcpy (pke_ptr
, "Pairwise key expansion", 23);
9971 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
9973 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
9974 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
9978 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
9979 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
9982 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
9984 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
9985 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
9989 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
9990 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
9993 for (int i
= 0; i
< 25; i
++)
9995 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
9998 wpa
->keyver
= in
.keyver
;
10000 if (wpa
->keyver
> 255)
10002 log_info ("ATTENTION!");
10003 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10004 log_info (" This could be due to a recent aircrack-ng bug.");
10005 log_info (" The key version was automatically reset to a reasonable value.");
10008 wpa
->keyver
&= 0xff;
10011 wpa
->eapol_size
= in
.eapol_size
;
10013 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10015 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10017 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10019 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10021 if (wpa
->keyver
== 1)
10027 digest
[0] = byte_swap_32 (digest
[0]);
10028 digest
[1] = byte_swap_32 (digest
[1]);
10029 digest
[2] = byte_swap_32 (digest
[2]);
10030 digest
[3] = byte_swap_32 (digest
[3]);
10032 for (int i
= 0; i
< 64; i
++)
10034 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10038 salt
->salt_buf
[10] = digest
[1];
10039 salt
->salt_buf
[11] = digest
[2];
10041 return (PARSER_OK
);
10044 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10046 u32
*digest
= (u32
*) hash_buf
->digest
;
10048 salt_t
*salt
= hash_buf
->salt
;
10050 if (input_len
== 0)
10052 log_error ("Password Safe v2 container not specified");
10057 FILE *fp
= fopen (input_buf
, "rb");
10061 log_error ("%s: %s", input_buf
, strerror (errno
));
10068 memset (&buf
, 0, sizeof (psafe2_hdr
));
10070 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10074 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10076 salt
->salt_buf
[0] = buf
.random
[0];
10077 salt
->salt_buf
[1] = buf
.random
[1];
10079 salt
->salt_len
= 8;
10080 salt
->salt_iter
= 1000;
10082 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10083 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10084 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10085 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10086 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10088 return (PARSER_OK
);
10091 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10093 u32
*digest
= (u32
*) hash_buf
->digest
;
10095 salt_t
*salt
= hash_buf
->salt
;
10097 if (input_len
== 0)
10099 log_error (".psafe3 not specified");
10104 FILE *fp
= fopen (input_buf
, "rb");
10108 log_error ("%s: %s", input_buf
, strerror (errno
));
10115 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10119 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10121 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10123 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10125 salt
->salt_iter
= in
.iterations
+ 1;
10127 salt
->salt_buf
[0] = in
.salt_buf
[0];
10128 salt
->salt_buf
[1] = in
.salt_buf
[1];
10129 salt
->salt_buf
[2] = in
.salt_buf
[2];
10130 salt
->salt_buf
[3] = in
.salt_buf
[3];
10131 salt
->salt_buf
[4] = in
.salt_buf
[4];
10132 salt
->salt_buf
[5] = in
.salt_buf
[5];
10133 salt
->salt_buf
[6] = in
.salt_buf
[6];
10134 salt
->salt_buf
[7] = in
.salt_buf
[7];
10136 salt
->salt_len
= 32;
10138 digest
[0] = in
.hash_buf
[0];
10139 digest
[1] = in
.hash_buf
[1];
10140 digest
[2] = in
.hash_buf
[2];
10141 digest
[3] = in
.hash_buf
[3];
10142 digest
[4] = in
.hash_buf
[4];
10143 digest
[5] = in
.hash_buf
[5];
10144 digest
[6] = in
.hash_buf
[6];
10145 digest
[7] = in
.hash_buf
[7];
10147 digest
[0] = byte_swap_32 (digest
[0]);
10148 digest
[1] = byte_swap_32 (digest
[1]);
10149 digest
[2] = byte_swap_32 (digest
[2]);
10150 digest
[3] = byte_swap_32 (digest
[3]);
10151 digest
[4] = byte_swap_32 (digest
[4]);
10152 digest
[5] = byte_swap_32 (digest
[5]);
10153 digest
[6] = byte_swap_32 (digest
[6]);
10154 digest
[7] = byte_swap_32 (digest
[7]);
10156 return (PARSER_OK
);
10159 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10161 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10163 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10165 u32
*digest
= (u32
*) hash_buf
->digest
;
10167 salt_t
*salt
= hash_buf
->salt
;
10169 char *iter_pos
= input_buf
+ 3;
10171 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10173 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10175 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10177 salt
->salt_iter
= salt_iter
;
10179 char *salt_pos
= iter_pos
+ 1;
10183 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10185 salt
->salt_len
= salt_len
;
10187 char *hash_pos
= salt_pos
+ salt_len
;
10189 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10191 return (PARSER_OK
);
10194 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10196 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10198 u32
*digest
= (u32
*) hash_buf
->digest
;
10200 salt_t
*salt
= hash_buf
->salt
;
10202 char *salt_pos
= input_buf
+ 3;
10204 uint iterations_len
= 0;
10206 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10210 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10212 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10213 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10217 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10221 iterations_len
+= 8;
10225 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10228 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10230 char *hash_pos
= strchr (salt_pos
, '$');
10232 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10234 uint salt_len
= hash_pos
- salt_pos
;
10236 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10238 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10240 salt
->salt_len
= salt_len
;
10244 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10246 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10248 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10250 return (PARSER_OK
);
10253 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10255 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10257 u32
*digest
= (u32
*) hash_buf
->digest
;
10259 salt_t
*salt
= hash_buf
->salt
;
10261 char *salt_pos
= input_buf
+ 6;
10263 uint iterations_len
= 0;
10265 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10269 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10271 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10272 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10276 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10280 iterations_len
+= 8;
10284 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10287 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10289 char *hash_pos
= strchr (salt_pos
, '$');
10291 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10293 uint salt_len
= hash_pos
- salt_pos
;
10295 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10297 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10299 salt
->salt_len
= salt_len
;
10303 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10305 return (PARSER_OK
);
10308 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10310 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10312 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10314 u32
*digest
= (u32
*) hash_buf
->digest
;
10316 salt_t
*salt
= hash_buf
->salt
;
10318 char *salt_pos
= input_buf
+ 14;
10320 char *hash_pos
= strchr (salt_pos
, '*');
10322 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10326 uint salt_len
= hash_pos
- salt_pos
- 1;
10328 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10330 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10332 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10334 salt
->salt_len
= salt_len
;
10336 u8 tmp_buf
[100] = { 0 };
10338 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10340 memcpy (digest
, tmp_buf
, 20);
10342 digest
[0] = byte_swap_32 (digest
[0]);
10343 digest
[1] = byte_swap_32 (digest
[1]);
10344 digest
[2] = byte_swap_32 (digest
[2]);
10345 digest
[3] = byte_swap_32 (digest
[3]);
10346 digest
[4] = byte_swap_32 (digest
[4]);
10348 digest
[0] -= SHA1M_A
;
10349 digest
[1] -= SHA1M_B
;
10350 digest
[2] -= SHA1M_C
;
10351 digest
[3] -= SHA1M_D
;
10352 digest
[4] -= SHA1M_E
;
10354 return (PARSER_OK
);
10357 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10359 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10361 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10363 if (c12
& 3) return (PARSER_HASH_VALUE
);
10365 u32
*digest
= (u32
*) hash_buf
->digest
;
10367 salt_t
*salt
= hash_buf
->salt
;
10369 // for ascii_digest
10370 salt
->salt_sign
[0] = input_buf
[0];
10371 salt
->salt_sign
[1] = input_buf
[1];
10373 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10374 | itoa64_to_int (input_buf
[1]) << 6;
10376 salt
->salt_len
= 2;
10378 u8 tmp_buf
[100] = { 0 };
10380 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10382 memcpy (digest
, tmp_buf
, 8);
10386 IP (digest
[0], digest
[1], tt
);
10391 return (PARSER_OK
);
10394 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10396 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10398 u32
*digest
= (u32
*) hash_buf
->digest
;
10400 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10401 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10402 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10403 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10405 digest
[0] = byte_swap_32 (digest
[0]);
10406 digest
[1] = byte_swap_32 (digest
[1]);
10407 digest
[2] = byte_swap_32 (digest
[2]);
10408 digest
[3] = byte_swap_32 (digest
[3]);
10410 digest
[0] -= MD4M_A
;
10411 digest
[1] -= MD4M_B
;
10412 digest
[2] -= MD4M_C
;
10413 digest
[3] -= MD4M_D
;
10415 return (PARSER_OK
);
10418 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10420 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10422 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10426 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10429 u32
*digest
= (u32
*) hash_buf
->digest
;
10431 salt_t
*salt
= hash_buf
->salt
;
10433 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10434 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10435 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10436 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10438 digest
[0] = byte_swap_32 (digest
[0]);
10439 digest
[1] = byte_swap_32 (digest
[1]);
10440 digest
[2] = byte_swap_32 (digest
[2]);
10441 digest
[3] = byte_swap_32 (digest
[3]);
10443 digest
[0] -= MD4M_A
;
10444 digest
[1] -= MD4M_B
;
10445 digest
[2] -= MD4M_C
;
10446 digest
[3] -= MD4M_D
;
10448 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10450 uint salt_len
= input_len
- 32 - 1;
10452 char *salt_buf
= input_buf
+ 32 + 1;
10454 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10456 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10458 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10460 salt
->salt_len
= salt_len
;
10462 return (PARSER_OK
);
10465 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10467 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10469 u32
*digest
= (u32
*) hash_buf
->digest
;
10471 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10472 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10473 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10474 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10476 digest
[0] = byte_swap_32 (digest
[0]);
10477 digest
[1] = byte_swap_32 (digest
[1]);
10478 digest
[2] = byte_swap_32 (digest
[2]);
10479 digest
[3] = byte_swap_32 (digest
[3]);
10481 digest
[0] -= MD5M_A
;
10482 digest
[1] -= MD5M_B
;
10483 digest
[2] -= MD5M_C
;
10484 digest
[3] -= MD5M_D
;
10486 return (PARSER_OK
);
10489 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10491 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10493 u32
*digest
= (u32
*) hash_buf
->digest
;
10495 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10496 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10500 digest
[0] = byte_swap_32 (digest
[0]);
10501 digest
[1] = byte_swap_32 (digest
[1]);
10503 return (PARSER_OK
);
10506 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10508 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10510 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10514 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10517 u32
*digest
= (u32
*) hash_buf
->digest
;
10519 salt_t
*salt
= hash_buf
->salt
;
10521 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10522 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10523 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10524 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10526 digest
[0] = byte_swap_32 (digest
[0]);
10527 digest
[1] = byte_swap_32 (digest
[1]);
10528 digest
[2] = byte_swap_32 (digest
[2]);
10529 digest
[3] = byte_swap_32 (digest
[3]);
10531 digest
[0] -= MD5M_A
;
10532 digest
[1] -= MD5M_B
;
10533 digest
[2] -= MD5M_C
;
10534 digest
[3] -= MD5M_D
;
10536 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10538 uint salt_len
= input_len
- 32 - 1;
10540 char *salt_buf
= input_buf
+ 32 + 1;
10542 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10544 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10546 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10548 salt
->salt_len
= salt_len
;
10550 return (PARSER_OK
);
10553 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10555 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10557 u32
*digest
= (u32
*) hash_buf
->digest
;
10559 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10560 | itoa64_to_int (input_buf
[ 1]) << 6
10561 | itoa64_to_int (input_buf
[ 2]) << 12
10562 | itoa64_to_int (input_buf
[ 3]) << 18;
10563 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10564 | itoa64_to_int (input_buf
[ 5]) << 6
10565 | itoa64_to_int (input_buf
[ 6]) << 12
10566 | itoa64_to_int (input_buf
[ 7]) << 18;
10567 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10568 | itoa64_to_int (input_buf
[ 9]) << 6
10569 | itoa64_to_int (input_buf
[10]) << 12
10570 | itoa64_to_int (input_buf
[11]) << 18;
10571 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10572 | itoa64_to_int (input_buf
[13]) << 6
10573 | itoa64_to_int (input_buf
[14]) << 12
10574 | itoa64_to_int (input_buf
[15]) << 18;
10576 digest
[0] -= MD5M_A
;
10577 digest
[1] -= MD5M_B
;
10578 digest
[2] -= MD5M_C
;
10579 digest
[3] -= MD5M_D
;
10581 digest
[0] &= 0x00ffffff;
10582 digest
[1] &= 0x00ffffff;
10583 digest
[2] &= 0x00ffffff;
10584 digest
[3] &= 0x00ffffff;
10586 return (PARSER_OK
);
10589 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10591 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10593 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10597 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10600 u32
*digest
= (u32
*) hash_buf
->digest
;
10602 salt_t
*salt
= hash_buf
->salt
;
10604 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10605 | itoa64_to_int (input_buf
[ 1]) << 6
10606 | itoa64_to_int (input_buf
[ 2]) << 12
10607 | itoa64_to_int (input_buf
[ 3]) << 18;
10608 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10609 | itoa64_to_int (input_buf
[ 5]) << 6
10610 | itoa64_to_int (input_buf
[ 6]) << 12
10611 | itoa64_to_int (input_buf
[ 7]) << 18;
10612 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10613 | itoa64_to_int (input_buf
[ 9]) << 6
10614 | itoa64_to_int (input_buf
[10]) << 12
10615 | itoa64_to_int (input_buf
[11]) << 18;
10616 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10617 | itoa64_to_int (input_buf
[13]) << 6
10618 | itoa64_to_int (input_buf
[14]) << 12
10619 | itoa64_to_int (input_buf
[15]) << 18;
10621 digest
[0] -= MD5M_A
;
10622 digest
[1] -= MD5M_B
;
10623 digest
[2] -= MD5M_C
;
10624 digest
[3] -= MD5M_D
;
10626 digest
[0] &= 0x00ffffff;
10627 digest
[1] &= 0x00ffffff;
10628 digest
[2] &= 0x00ffffff;
10629 digest
[3] &= 0x00ffffff;
10631 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10633 uint salt_len
= input_len
- 16 - 1;
10635 char *salt_buf
= input_buf
+ 16 + 1;
10637 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10639 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10641 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10643 salt
->salt_len
= salt_len
;
10645 return (PARSER_OK
);
10648 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10650 key
[0] = (nthash
[0] >> 0);
10651 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10652 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10653 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10654 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10655 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10656 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10657 key
[7] = (nthash
[6] << 1);
10669 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10671 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10673 u32
*digest
= (u32
*) hash_buf
->digest
;
10675 salt_t
*salt
= hash_buf
->salt
;
10677 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10683 char *user_pos
= input_buf
;
10685 char *unused_pos
= strchr (user_pos
, ':');
10687 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10689 uint user_len
= unused_pos
- user_pos
;
10691 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10695 char *domain_pos
= strchr (unused_pos
, ':');
10697 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10699 uint unused_len
= domain_pos
- unused_pos
;
10701 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10705 char *srvchall_pos
= strchr (domain_pos
, ':');
10707 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10709 uint domain_len
= srvchall_pos
- domain_pos
;
10711 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10715 char *hash_pos
= strchr (srvchall_pos
, ':');
10717 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10719 uint srvchall_len
= hash_pos
- srvchall_pos
;
10721 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10725 char *clichall_pos
= strchr (hash_pos
, ':');
10727 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10729 uint hash_len
= clichall_pos
- hash_pos
;
10731 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10735 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10737 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10740 * store some data for later use
10743 netntlm
->user_len
= user_len
* 2;
10744 netntlm
->domain_len
= domain_len
* 2;
10745 netntlm
->srvchall_len
= srvchall_len
/ 2;
10746 netntlm
->clichall_len
= clichall_len
/ 2;
10748 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10749 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10752 * handle username and domainname
10755 for (uint i
= 0; i
< user_len
; i
++)
10757 *userdomain_ptr
++ = user_pos
[i
];
10758 *userdomain_ptr
++ = 0;
10761 for (uint i
= 0; i
< domain_len
; i
++)
10763 *userdomain_ptr
++ = domain_pos
[i
];
10764 *userdomain_ptr
++ = 0;
10768 * handle server challenge encoding
10771 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10773 const char p0
= srvchall_pos
[i
+ 0];
10774 const char p1
= srvchall_pos
[i
+ 1];
10776 *chall_ptr
++ = hex_convert (p1
) << 0
10777 | hex_convert (p0
) << 4;
10781 * handle client challenge encoding
10784 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10786 const char p0
= clichall_pos
[i
+ 0];
10787 const char p1
= clichall_pos
[i
+ 1];
10789 *chall_ptr
++ = hex_convert (p1
) << 0
10790 | hex_convert (p0
) << 4;
10797 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10799 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10801 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10803 salt
->salt_len
= salt_len
;
10805 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10806 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10807 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10808 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10810 digest
[0] = byte_swap_32 (digest
[0]);
10811 digest
[1] = byte_swap_32 (digest
[1]);
10812 digest
[2] = byte_swap_32 (digest
[2]);
10813 digest
[3] = byte_swap_32 (digest
[3]);
10815 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10817 uint digest_tmp
[2] = { 0 };
10819 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10820 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
10822 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10823 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10825 /* special case 2: ESS */
10827 if (srvchall_len
== 48)
10829 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10831 uint w
[16] = { 0 };
10833 w
[ 0] = netntlm
->chall_buf
[6];
10834 w
[ 1] = netntlm
->chall_buf
[7];
10835 w
[ 2] = netntlm
->chall_buf
[0];
10836 w
[ 3] = netntlm
->chall_buf
[1];
10840 uint dgst
[4] = { 0 };
10849 salt
->salt_buf
[0] = dgst
[0];
10850 salt
->salt_buf
[1] = dgst
[1];
10854 /* precompute netntlmv1 exploit start */
10856 for (uint i
= 0; i
< 0x10000; i
++)
10858 uint key_md4
[2] = { i
, 0 };
10859 uint key_des
[2] = { 0, 0 };
10861 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
10863 uint Kc
[16] = { 0 };
10864 uint Kd
[16] = { 0 };
10866 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10868 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10870 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10872 if (data3
[0] != digest_tmp
[0]) continue;
10873 if (data3
[1] != digest_tmp
[1]) continue;
10875 salt
->salt_buf
[2] = i
;
10877 salt
->salt_len
= 24;
10882 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10883 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10885 /* precompute netntlmv1 exploit stop */
10889 IP (digest
[0], digest
[1], tt
);
10890 IP (digest
[2], digest
[3], tt
);
10892 digest
[0] = rotr32 (digest
[0], 29);
10893 digest
[1] = rotr32 (digest
[1], 29);
10894 digest
[2] = rotr32 (digest
[2], 29);
10895 digest
[3] = rotr32 (digest
[3], 29);
10897 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10899 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
10900 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
10902 return (PARSER_OK
);
10905 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10907 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10909 u32
*digest
= (u32
*) hash_buf
->digest
;
10911 salt_t
*salt
= hash_buf
->salt
;
10913 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10919 char *user_pos
= input_buf
;
10921 char *unused_pos
= strchr (user_pos
, ':');
10923 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10925 uint user_len
= unused_pos
- user_pos
;
10927 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10931 char *domain_pos
= strchr (unused_pos
, ':');
10933 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10935 uint unused_len
= domain_pos
- unused_pos
;
10937 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10941 char *srvchall_pos
= strchr (domain_pos
, ':');
10943 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10945 uint domain_len
= srvchall_pos
- domain_pos
;
10947 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10951 char *hash_pos
= strchr (srvchall_pos
, ':');
10953 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10955 uint srvchall_len
= hash_pos
- srvchall_pos
;
10957 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
10961 char *clichall_pos
= strchr (hash_pos
, ':');
10963 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10965 uint hash_len
= clichall_pos
- hash_pos
;
10967 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
10971 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10973 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
10975 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
10978 * store some data for later use
10981 netntlm
->user_len
= user_len
* 2;
10982 netntlm
->domain_len
= domain_len
* 2;
10983 netntlm
->srvchall_len
= srvchall_len
/ 2;
10984 netntlm
->clichall_len
= clichall_len
/ 2;
10986 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10987 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10990 * handle username and domainname
10993 for (uint i
= 0; i
< user_len
; i
++)
10995 *userdomain_ptr
++ = toupper (user_pos
[i
]);
10996 *userdomain_ptr
++ = 0;
10999 for (uint i
= 0; i
< domain_len
; i
++)
11001 *userdomain_ptr
++ = domain_pos
[i
];
11002 *userdomain_ptr
++ = 0;
11005 *userdomain_ptr
++ = 0x80;
11008 * handle server challenge encoding
11011 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11013 const char p0
= srvchall_pos
[i
+ 0];
11014 const char p1
= srvchall_pos
[i
+ 1];
11016 *chall_ptr
++ = hex_convert (p1
) << 0
11017 | hex_convert (p0
) << 4;
11021 * handle client challenge encoding
11024 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11026 const char p0
= clichall_pos
[i
+ 0];
11027 const char p1
= clichall_pos
[i
+ 1];
11029 *chall_ptr
++ = hex_convert (p1
) << 0
11030 | hex_convert (p0
) << 4;
11033 *chall_ptr
++ = 0x80;
11036 * handle hash itself
11039 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11040 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11041 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11042 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11044 digest
[0] = byte_swap_32 (digest
[0]);
11045 digest
[1] = byte_swap_32 (digest
[1]);
11046 digest
[2] = byte_swap_32 (digest
[2]);
11047 digest
[3] = byte_swap_32 (digest
[3]);
11050 * reuse challange data as salt_buf, its the buffer that is most likely unique
11053 salt
->salt_buf
[0] = 0;
11054 salt
->salt_buf
[1] = 0;
11055 salt
->salt_buf
[2] = 0;
11056 salt
->salt_buf
[3] = 0;
11057 salt
->salt_buf
[4] = 0;
11058 salt
->salt_buf
[5] = 0;
11059 salt
->salt_buf
[6] = 0;
11060 salt
->salt_buf
[7] = 0;
11064 uptr
= (uint
*) netntlm
->userdomain_buf
;
11066 for (uint i
= 0; i
< 16; i
+= 16)
11068 md5_64 (uptr
, salt
->salt_buf
);
11071 uptr
= (uint
*) netntlm
->chall_buf
;
11073 for (uint i
= 0; i
< 256; i
+= 16)
11075 md5_64 (uptr
, salt
->salt_buf
);
11078 salt
->salt_len
= 16;
11080 return (PARSER_OK
);
11083 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11085 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11087 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11091 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11094 u32
*digest
= (u32
*) hash_buf
->digest
;
11096 salt_t
*salt
= hash_buf
->salt
;
11098 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11099 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11100 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11101 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11103 digest
[0] = byte_swap_32 (digest
[0]);
11104 digest
[1] = byte_swap_32 (digest
[1]);
11105 digest
[2] = byte_swap_32 (digest
[2]);
11106 digest
[3] = byte_swap_32 (digest
[3]);
11108 digest
[0] -= MD5M_A
;
11109 digest
[1] -= MD5M_B
;
11110 digest
[2] -= MD5M_C
;
11111 digest
[3] -= MD5M_D
;
11113 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11115 uint salt_len
= input_len
- 32 - 1;
11117 char *salt_buf
= input_buf
+ 32 + 1;
11119 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11121 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11123 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11125 salt
->salt_len
= salt_len
;
11127 return (PARSER_OK
);
11130 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11132 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11134 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11138 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11141 u32
*digest
= (u32
*) hash_buf
->digest
;
11143 salt_t
*salt
= hash_buf
->salt
;
11145 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11146 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11147 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11148 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11150 digest
[0] = byte_swap_32 (digest
[0]);
11151 digest
[1] = byte_swap_32 (digest
[1]);
11152 digest
[2] = byte_swap_32 (digest
[2]);
11153 digest
[3] = byte_swap_32 (digest
[3]);
11155 digest
[0] -= MD5M_A
;
11156 digest
[1] -= MD5M_B
;
11157 digest
[2] -= MD5M_C
;
11158 digest
[3] -= MD5M_D
;
11160 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11162 uint salt_len
= input_len
- 32 - 1;
11164 char *salt_buf
= input_buf
+ 32 + 1;
11166 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11168 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11170 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11172 salt
->salt_len
= salt_len
;
11174 return (PARSER_OK
);
11177 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11179 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11181 u32
*digest
= (u32
*) hash_buf
->digest
;
11183 salt_t
*salt
= hash_buf
->salt
;
11185 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11186 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11187 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11188 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11190 digest
[0] = byte_swap_32 (digest
[0]);
11191 digest
[1] = byte_swap_32 (digest
[1]);
11192 digest
[2] = byte_swap_32 (digest
[2]);
11193 digest
[3] = byte_swap_32 (digest
[3]);
11195 digest
[0] -= MD5M_A
;
11196 digest
[1] -= MD5M_B
;
11197 digest
[2] -= MD5M_C
;
11198 digest
[3] -= MD5M_D
;
11201 * This is a virtual salt. While the algorithm is basically not salted
11202 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11203 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11206 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11208 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11210 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11212 salt
->salt_len
= salt_len
;
11214 return (PARSER_OK
);
11217 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11219 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11221 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11225 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11228 u32
*digest
= (u32
*) hash_buf
->digest
;
11230 salt_t
*salt
= hash_buf
->salt
;
11232 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11233 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11234 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11235 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11237 digest
[0] = byte_swap_32 (digest
[0]);
11238 digest
[1] = byte_swap_32 (digest
[1]);
11239 digest
[2] = byte_swap_32 (digest
[2]);
11240 digest
[3] = byte_swap_32 (digest
[3]);
11242 digest
[0] -= MD5M_A
;
11243 digest
[1] -= MD5M_B
;
11244 digest
[2] -= MD5M_C
;
11245 digest
[3] -= MD5M_D
;
11247 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11249 uint salt_len
= input_len
- 32 - 1;
11251 char *salt_buf
= input_buf
+ 32 + 1;
11253 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11255 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11257 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11259 salt
->salt_len
= salt_len
;
11261 return (PARSER_OK
);
11264 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11266 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11268 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11272 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11275 u32
*digest
= (u32
*) hash_buf
->digest
;
11277 salt_t
*salt
= hash_buf
->salt
;
11279 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11280 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11281 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11282 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11284 digest
[0] = byte_swap_32 (digest
[0]);
11285 digest
[1] = byte_swap_32 (digest
[1]);
11286 digest
[2] = byte_swap_32 (digest
[2]);
11287 digest
[3] = byte_swap_32 (digest
[3]);
11289 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11291 uint salt_len
= input_len
- 32 - 1;
11293 char *salt_buf
= input_buf
+ 32 + 1;
11295 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11297 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11299 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11301 salt
->salt_len
= salt_len
;
11303 return (PARSER_OK
);
11306 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11308 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11310 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11314 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11317 u32
*digest
= (u32
*) hash_buf
->digest
;
11319 salt_t
*salt
= hash_buf
->salt
;
11321 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11322 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11323 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11324 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11326 digest
[0] = byte_swap_32 (digest
[0]);
11327 digest
[1] = byte_swap_32 (digest
[1]);
11328 digest
[2] = byte_swap_32 (digest
[2]);
11329 digest
[3] = byte_swap_32 (digest
[3]);
11331 digest
[0] -= MD4M_A
;
11332 digest
[1] -= MD4M_B
;
11333 digest
[2] -= MD4M_C
;
11334 digest
[3] -= MD4M_D
;
11336 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11338 uint salt_len
= input_len
- 32 - 1;
11340 char *salt_buf
= input_buf
+ 32 + 1;
11342 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11344 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11346 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11348 salt
->salt_len
= salt_len
;
11350 return (PARSER_OK
);
11353 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11355 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11357 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11361 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11364 u32
*digest
= (u32
*) hash_buf
->digest
;
11366 salt_t
*salt
= hash_buf
->salt
;
11368 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11369 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11370 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11371 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11373 digest
[0] = byte_swap_32 (digest
[0]);
11374 digest
[1] = byte_swap_32 (digest
[1]);
11375 digest
[2] = byte_swap_32 (digest
[2]);
11376 digest
[3] = byte_swap_32 (digest
[3]);
11378 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11380 uint salt_len
= input_len
- 32 - 1;
11382 char *salt_buf
= input_buf
+ 32 + 1;
11384 uint salt_pc_block
[16] = { 0 };
11386 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11388 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11390 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11392 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11394 salt_pc_block
[14] = salt_len
* 8;
11396 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11398 md5_64 (salt_pc_block
, salt_pc_digest
);
11400 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11401 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11402 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11403 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11405 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11407 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11409 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11411 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11412 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11413 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11414 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11416 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11418 return (PARSER_OK
);
11421 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11423 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11425 u32
*digest
= (u32
*) hash_buf
->digest
;
11427 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11428 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11429 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11430 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11431 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11433 digest
[0] -= SHA1M_A
;
11434 digest
[1] -= SHA1M_B
;
11435 digest
[2] -= SHA1M_C
;
11436 digest
[3] -= SHA1M_D
;
11437 digest
[4] -= SHA1M_E
;
11439 return (PARSER_OK
);
11442 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11444 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11446 u32
*digest
= (u32
*) hash_buf
->digest
;
11448 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11449 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11450 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11451 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11452 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11454 return (PARSER_OK
);
11457 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11459 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11461 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11465 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11468 u32
*digest
= (u32
*) hash_buf
->digest
;
11470 salt_t
*salt
= hash_buf
->salt
;
11472 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11473 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11474 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11475 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11476 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11478 digest
[0] -= SHA1M_A
;
11479 digest
[1] -= SHA1M_B
;
11480 digest
[2] -= SHA1M_C
;
11481 digest
[3] -= SHA1M_D
;
11482 digest
[4] -= SHA1M_E
;
11484 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11486 uint salt_len
= input_len
- 40 - 1;
11488 char *salt_buf
= input_buf
+ 40 + 1;
11490 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11492 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11494 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11496 salt
->salt_len
= salt_len
;
11498 return (PARSER_OK
);
11501 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11503 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11505 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11507 u32
*digest
= (u32
*) hash_buf
->digest
;
11509 u8 tmp_buf
[100] = { 0 };
11511 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11513 memcpy (digest
, tmp_buf
, 20);
11515 digest
[0] = byte_swap_32 (digest
[0]);
11516 digest
[1] = byte_swap_32 (digest
[1]);
11517 digest
[2] = byte_swap_32 (digest
[2]);
11518 digest
[3] = byte_swap_32 (digest
[3]);
11519 digest
[4] = byte_swap_32 (digest
[4]);
11521 digest
[0] -= SHA1M_A
;
11522 digest
[1] -= SHA1M_B
;
11523 digest
[2] -= SHA1M_C
;
11524 digest
[3] -= SHA1M_D
;
11525 digest
[4] -= SHA1M_E
;
11527 return (PARSER_OK
);
11530 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11532 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11534 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11536 u32
*digest
= (u32
*) hash_buf
->digest
;
11538 salt_t
*salt
= hash_buf
->salt
;
11540 u8 tmp_buf
[100] = { 0 };
11542 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11544 memcpy (digest
, tmp_buf
, 20);
11546 salt
->salt_len
= tmp_len
- 20;
11548 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11550 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11552 char *ptr
= (char *) salt
->salt_buf
;
11554 ptr
[salt
->salt_len
] = 0x80;
11557 digest
[0] = byte_swap_32 (digest
[0]);
11558 digest
[1] = byte_swap_32 (digest
[1]);
11559 digest
[2] = byte_swap_32 (digest
[2]);
11560 digest
[3] = byte_swap_32 (digest
[3]);
11561 digest
[4] = byte_swap_32 (digest
[4]);
11563 digest
[0] -= SHA1M_A
;
11564 digest
[1] -= SHA1M_B
;
11565 digest
[2] -= SHA1M_C
;
11566 digest
[3] -= SHA1M_D
;
11567 digest
[4] -= SHA1M_E
;
11569 return (PARSER_OK
);
11572 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11574 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11576 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11578 u32
*digest
= (u32
*) hash_buf
->digest
;
11580 salt_t
*salt
= hash_buf
->salt
;
11582 char *salt_buf
= input_buf
+ 6;
11586 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11588 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11590 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11592 salt
->salt_len
= salt_len
;
11594 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11596 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11597 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11598 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11599 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11600 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11602 digest
[0] -= SHA1M_A
;
11603 digest
[1] -= SHA1M_B
;
11604 digest
[2] -= SHA1M_C
;
11605 digest
[3] -= SHA1M_D
;
11606 digest
[4] -= SHA1M_E
;
11608 return (PARSER_OK
);
11611 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11613 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11615 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11617 u32
*digest
= (u32
*) hash_buf
->digest
;
11619 salt_t
*salt
= hash_buf
->salt
;
11621 char *salt_buf
= input_buf
+ 6;
11625 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11627 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11629 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11631 salt
->salt_len
= salt_len
;
11633 char *hash_pos
= input_buf
+ 6 + 8;
11635 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11636 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11637 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11638 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11639 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11641 digest
[0] -= SHA1M_A
;
11642 digest
[1] -= SHA1M_B
;
11643 digest
[2] -= SHA1M_C
;
11644 digest
[3] -= SHA1M_D
;
11645 digest
[4] -= SHA1M_E
;
11647 return (PARSER_OK
);
11650 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11652 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11654 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11656 u64
*digest
= (u64
*) hash_buf
->digest
;
11658 salt_t
*salt
= hash_buf
->salt
;
11660 char *salt_buf
= input_buf
+ 6;
11664 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11666 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11668 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11670 salt
->salt_len
= salt_len
;
11672 char *hash_pos
= input_buf
+ 6 + 8;
11674 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11675 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11676 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11677 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11678 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11679 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11680 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11681 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11683 digest
[0] -= SHA512M_A
;
11684 digest
[1] -= SHA512M_B
;
11685 digest
[2] -= SHA512M_C
;
11686 digest
[3] -= SHA512M_D
;
11687 digest
[4] -= SHA512M_E
;
11688 digest
[5] -= SHA512M_F
;
11689 digest
[6] -= SHA512M_G
;
11690 digest
[7] -= SHA512M_H
;
11692 return (PARSER_OK
);
11695 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11697 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11699 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11703 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11706 u32
*digest
= (u32
*) hash_buf
->digest
;
11708 salt_t
*salt
= hash_buf
->salt
;
11710 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11711 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11715 digest
[0] = byte_swap_32 (digest
[0]);
11716 digest
[1] = byte_swap_32 (digest
[1]);
11718 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11720 uint salt_len
= input_len
- 16 - 1;
11722 char *salt_buf
= input_buf
+ 16 + 1;
11724 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11726 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11728 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11730 salt
->salt_len
= salt_len
;
11732 return (PARSER_OK
);
11735 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11737 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11739 u32
*digest
= (u32
*) hash_buf
->digest
;
11741 salt_t
*salt
= hash_buf
->salt
;
11743 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11744 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11745 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11746 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11747 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11749 digest
[0] -= SHA1M_A
;
11750 digest
[1] -= SHA1M_B
;
11751 digest
[2] -= SHA1M_C
;
11752 digest
[3] -= SHA1M_D
;
11753 digest
[4] -= SHA1M_E
;
11755 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11757 uint salt_len
= input_len
- 40 - 1;
11759 char *salt_buf
= input_buf
+ 40 + 1;
11761 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11763 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11765 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11767 salt
->salt_len
= salt_len
;
11769 return (PARSER_OK
);
11772 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11774 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11776 u32
*digest
= (u32
*) hash_buf
->digest
;
11778 salt_t
*salt
= hash_buf
->salt
;
11780 char *hash_pos
= input_buf
;
11782 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11783 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11784 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
11785 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
11786 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
11787 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
11788 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
11789 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
11790 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
11791 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
11792 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
11793 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
11794 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
11795 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
11796 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
11797 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
11799 char *salt_pos
= input_buf
+ 128;
11801 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
11802 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
11803 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
11804 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
11806 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11807 salt
->salt_len
= 16;
11809 return (PARSER_OK
);
11812 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11814 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11816 u32
*digest
= (u32
*) hash_buf
->digest
;
11818 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11819 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11820 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11821 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11822 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11823 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11824 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11825 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11827 digest
[0] -= SHA256M_A
;
11828 digest
[1] -= SHA256M_B
;
11829 digest
[2] -= SHA256M_C
;
11830 digest
[3] -= SHA256M_D
;
11831 digest
[4] -= SHA256M_E
;
11832 digest
[5] -= SHA256M_F
;
11833 digest
[6] -= SHA256M_G
;
11834 digest
[7] -= SHA256M_H
;
11836 return (PARSER_OK
);
11839 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11841 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11843 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11847 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11850 u32
*digest
= (u32
*) hash_buf
->digest
;
11852 salt_t
*salt
= hash_buf
->salt
;
11854 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11855 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11856 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11857 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11858 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11859 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11860 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11861 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11863 digest
[0] -= SHA256M_A
;
11864 digest
[1] -= SHA256M_B
;
11865 digest
[2] -= SHA256M_C
;
11866 digest
[3] -= SHA256M_D
;
11867 digest
[4] -= SHA256M_E
;
11868 digest
[5] -= SHA256M_F
;
11869 digest
[6] -= SHA256M_G
;
11870 digest
[7] -= SHA256M_H
;
11872 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11874 uint salt_len
= input_len
- 64 - 1;
11876 char *salt_buf
= input_buf
+ 64 + 1;
11878 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11880 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11882 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11884 salt
->salt_len
= salt_len
;
11886 return (PARSER_OK
);
11889 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11891 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11893 u64
*digest
= (u64
*) hash_buf
->digest
;
11895 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11896 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11897 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11898 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11899 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11900 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11904 digest
[0] -= SHA384M_A
;
11905 digest
[1] -= SHA384M_B
;
11906 digest
[2] -= SHA384M_C
;
11907 digest
[3] -= SHA384M_D
;
11908 digest
[4] -= SHA384M_E
;
11909 digest
[5] -= SHA384M_F
;
11913 return (PARSER_OK
);
11916 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11918 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
11920 u64
*digest
= (u64
*) hash_buf
->digest
;
11922 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11923 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11924 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11925 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11926 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11927 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11928 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11929 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11931 digest
[0] -= SHA512M_A
;
11932 digest
[1] -= SHA512M_B
;
11933 digest
[2] -= SHA512M_C
;
11934 digest
[3] -= SHA512M_D
;
11935 digest
[4] -= SHA512M_E
;
11936 digest
[5] -= SHA512M_F
;
11937 digest
[6] -= SHA512M_G
;
11938 digest
[7] -= SHA512M_H
;
11940 return (PARSER_OK
);
11943 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11945 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11947 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
11951 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
11954 u64
*digest
= (u64
*) hash_buf
->digest
;
11956 salt_t
*salt
= hash_buf
->salt
;
11958 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11959 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11960 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11961 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11962 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11963 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11964 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11965 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11967 digest
[0] -= SHA512M_A
;
11968 digest
[1] -= SHA512M_B
;
11969 digest
[2] -= SHA512M_C
;
11970 digest
[3] -= SHA512M_D
;
11971 digest
[4] -= SHA512M_E
;
11972 digest
[5] -= SHA512M_F
;
11973 digest
[6] -= SHA512M_G
;
11974 digest
[7] -= SHA512M_H
;
11976 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11978 uint salt_len
= input_len
- 128 - 1;
11980 char *salt_buf
= input_buf
+ 128 + 1;
11982 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11984 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11986 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11988 salt
->salt_len
= salt_len
;
11990 return (PARSER_OK
);
11993 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11995 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
11997 u64
*digest
= (u64
*) hash_buf
->digest
;
11999 salt_t
*salt
= hash_buf
->salt
;
12001 char *salt_pos
= input_buf
+ 3;
12003 uint iterations_len
= 0;
12005 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12009 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12011 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12012 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12016 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12020 iterations_len
+= 8;
12024 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12027 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12029 char *hash_pos
= strchr (salt_pos
, '$');
12031 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12033 uint salt_len
= hash_pos
- salt_pos
;
12035 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12037 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12039 salt
->salt_len
= salt_len
;
12043 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12045 return (PARSER_OK
);
12048 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12050 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12052 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12054 u64
*digest
= (u64
*) hash_buf
->digest
;
12056 salt_t
*salt
= hash_buf
->salt
;
12058 uint keccak_mdlen
= input_len
/ 2;
12060 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12062 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12064 digest
[i
] = byte_swap_64 (digest
[i
]);
12067 salt
->keccak_mdlen
= keccak_mdlen
;
12069 return (PARSER_OK
);
12072 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12074 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12076 u32
*digest
= (u32
*) hash_buf
->digest
;
12078 salt_t
*salt
= hash_buf
->salt
;
12080 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12083 * Parse that strange long line
12088 size_t in_len
[9] = { 0 };
12090 in_off
[0] = strtok (input_buf
, ":");
12092 in_len
[0] = strlen (in_off
[0]);
12096 for (i
= 1; i
< 9; i
++)
12098 in_off
[i
] = strtok (NULL
, ":");
12100 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12102 in_len
[i
] = strlen (in_off
[i
]);
12105 char *ptr
= (char *) ikepsk
->msg_buf
;
12107 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12108 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12109 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12110 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12111 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12112 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12116 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12118 ptr
= (char *) ikepsk
->nr_buf
;
12120 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12121 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12125 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12128 * Store to database
12133 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12134 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12135 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12136 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12138 digest
[0] = byte_swap_32 (digest
[0]);
12139 digest
[1] = byte_swap_32 (digest
[1]);
12140 digest
[2] = byte_swap_32 (digest
[2]);
12141 digest
[3] = byte_swap_32 (digest
[3]);
12143 salt
->salt_len
= 32;
12145 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12146 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12147 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12148 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12149 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12150 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12151 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12152 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12154 return (PARSER_OK
);
12157 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12159 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12161 u32
*digest
= (u32
*) hash_buf
->digest
;
12163 salt_t
*salt
= hash_buf
->salt
;
12165 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12168 * Parse that strange long line
12173 size_t in_len
[9] = { 0 };
12175 in_off
[0] = strtok (input_buf
, ":");
12177 in_len
[0] = strlen (in_off
[0]);
12181 for (i
= 1; i
< 9; i
++)
12183 in_off
[i
] = strtok (NULL
, ":");
12185 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12187 in_len
[i
] = strlen (in_off
[i
]);
12190 char *ptr
= (char *) ikepsk
->msg_buf
;
12192 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12193 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12194 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12195 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12196 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12197 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12201 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12203 ptr
= (char *) ikepsk
->nr_buf
;
12205 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12206 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12210 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12213 * Store to database
12218 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12219 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12220 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12221 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12222 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12224 salt
->salt_len
= 32;
12226 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12227 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12228 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12229 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12230 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12231 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12232 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12233 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12235 return (PARSER_OK
);
12238 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12240 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12242 u32
*digest
= (u32
*) hash_buf
->digest
;
12244 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12245 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12246 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12247 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12248 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12250 digest
[0] = byte_swap_32 (digest
[0]);
12251 digest
[1] = byte_swap_32 (digest
[1]);
12252 digest
[2] = byte_swap_32 (digest
[2]);
12253 digest
[3] = byte_swap_32 (digest
[3]);
12254 digest
[4] = byte_swap_32 (digest
[4]);
12256 return (PARSER_OK
);
12259 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12261 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12263 u32
*digest
= (u32
*) hash_buf
->digest
;
12265 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12266 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12267 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12268 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12269 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12270 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12271 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12272 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12273 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12274 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12275 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12276 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12277 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12278 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12279 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12280 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12282 return (PARSER_OK
);
12285 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12287 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12289 u32
*digest
= (u32
*) hash_buf
->digest
;
12291 salt_t
*salt
= hash_buf
->salt
;
12293 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12294 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12295 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12296 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12297 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12299 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12301 uint salt_len
= input_len
- 40 - 1;
12303 char *salt_buf
= input_buf
+ 40 + 1;
12305 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12307 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12309 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12311 salt
->salt_len
= salt_len
;
12313 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12315 return (PARSER_OK
);
12318 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12320 u32
*digest
= (u32
*) hash_buf
->digest
;
12322 salt_t
*salt
= hash_buf
->salt
;
12324 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12326 if (input_len
== 0)
12328 log_error ("TrueCrypt container not specified");
12333 FILE *fp
= fopen (input_buf
, "rb");
12337 log_error ("%s: %s", input_buf
, strerror (errno
));
12342 char buf
[512] = { 0 };
12344 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12348 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12350 memcpy (tc
->salt_buf
, buf
, 64);
12352 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12354 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12356 salt
->salt_len
= 4;
12358 salt
->salt_iter
= 1000 - 1;
12360 digest
[0] = tc
->data_buf
[0];
12362 return (PARSER_OK
);
12365 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12367 u32
*digest
= (u32
*) hash_buf
->digest
;
12369 salt_t
*salt
= hash_buf
->salt
;
12371 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12373 if (input_len
== 0)
12375 log_error ("TrueCrypt container not specified");
12380 FILE *fp
= fopen (input_buf
, "rb");
12384 log_error ("%s: %s", input_buf
, strerror (errno
));
12389 char buf
[512] = { 0 };
12391 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12395 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12397 memcpy (tc
->salt_buf
, buf
, 64);
12399 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12401 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12403 salt
->salt_len
= 4;
12405 salt
->salt_iter
= 2000 - 1;
12407 digest
[0] = tc
->data_buf
[0];
12409 return (PARSER_OK
);
12412 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12414 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12416 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12418 u32
*digest
= (u32
*) hash_buf
->digest
;
12420 salt_t
*salt
= hash_buf
->salt
;
12422 char *salt_pos
= input_buf
+ 6;
12424 char *hash_pos
= strchr (salt_pos
, '$');
12426 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12428 uint salt_len
= hash_pos
- salt_pos
;
12430 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12432 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12434 salt
->salt_len
= salt_len
;
12436 salt
->salt_iter
= 1000;
12440 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12442 return (PARSER_OK
);
12445 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12447 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12449 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12451 u32
*digest
= (u32
*) hash_buf
->digest
;
12453 salt_t
*salt
= hash_buf
->salt
;
12455 char *iter_pos
= input_buf
+ 7;
12457 char *salt_pos
= strchr (iter_pos
, '$');
12459 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12463 char *hash_pos
= strchr (salt_pos
, '$');
12465 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12467 uint salt_len
= hash_pos
- salt_pos
;
12469 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12471 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12473 salt
->salt_len
= salt_len
;
12475 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12477 salt
->salt_sign
[0] = atoi (salt_iter
);
12479 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12483 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12485 digest
[0] = byte_swap_32 (digest
[0]);
12486 digest
[1] = byte_swap_32 (digest
[1]);
12487 digest
[2] = byte_swap_32 (digest
[2]);
12488 digest
[3] = byte_swap_32 (digest
[3]);
12489 digest
[4] = byte_swap_32 (digest
[4]);
12491 return (PARSER_OK
);
12494 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12496 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12498 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12500 u32
*digest
= (u32
*) hash_buf
->digest
;
12502 salt_t
*salt
= hash_buf
->salt
;
12504 char *iter_pos
= input_buf
+ 9;
12506 char *salt_pos
= strchr (iter_pos
, '$');
12508 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12512 char *hash_pos
= strchr (salt_pos
, '$');
12514 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12516 uint salt_len
= hash_pos
- salt_pos
;
12518 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12520 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12522 salt
->salt_len
= salt_len
;
12524 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12526 salt
->salt_sign
[0] = atoi (salt_iter
);
12528 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12532 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12534 digest
[0] = byte_swap_32 (digest
[0]);
12535 digest
[1] = byte_swap_32 (digest
[1]);
12536 digest
[2] = byte_swap_32 (digest
[2]);
12537 digest
[3] = byte_swap_32 (digest
[3]);
12538 digest
[4] = byte_swap_32 (digest
[4]);
12539 digest
[5] = byte_swap_32 (digest
[5]);
12540 digest
[6] = byte_swap_32 (digest
[6]);
12541 digest
[7] = byte_swap_32 (digest
[7]);
12543 return (PARSER_OK
);
12546 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12548 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12550 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12552 u64
*digest
= (u64
*) hash_buf
->digest
;
12554 salt_t
*salt
= hash_buf
->salt
;
12556 char *iter_pos
= input_buf
+ 9;
12558 char *salt_pos
= strchr (iter_pos
, '$');
12560 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12564 char *hash_pos
= strchr (salt_pos
, '$');
12566 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12568 uint salt_len
= hash_pos
- salt_pos
;
12570 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12572 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12574 salt
->salt_len
= salt_len
;
12576 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12578 salt
->salt_sign
[0] = atoi (salt_iter
);
12580 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12584 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12586 digest
[0] = byte_swap_64 (digest
[0]);
12587 digest
[1] = byte_swap_64 (digest
[1]);
12588 digest
[2] = byte_swap_64 (digest
[2]);
12589 digest
[3] = byte_swap_64 (digest
[3]);
12590 digest
[4] = byte_swap_64 (digest
[4]);
12591 digest
[5] = byte_swap_64 (digest
[5]);
12592 digest
[6] = byte_swap_64 (digest
[6]);
12593 digest
[7] = byte_swap_64 (digest
[7]);
12595 return (PARSER_OK
);
12598 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12600 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12602 u32
*digest
= (u32
*) hash_buf
->digest
;
12604 salt_t
*salt
= hash_buf
->salt
;
12606 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12612 char *iterations_pos
= input_buf
;
12614 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12616 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12618 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12620 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12624 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12626 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12628 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12630 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12632 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12634 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12639 * pbkdf2 iterations
12642 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12645 * handle salt encoding
12648 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12650 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12652 const char p0
= saltbuf_pos
[i
+ 0];
12653 const char p1
= saltbuf_pos
[i
+ 1];
12655 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12656 | hex_convert (p0
) << 4;
12659 salt
->salt_len
= saltbuf_len
/ 2;
12662 * handle cipher encoding
12665 uint
*tmp
= (uint
*) mymalloc (32);
12667 char *cipherbuf_ptr
= (char *) tmp
;
12669 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12671 const char p0
= cipherbuf_pos
[i
+ 0];
12672 const char p1
= cipherbuf_pos
[i
+ 1];
12674 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12675 | hex_convert (p0
) << 4;
12678 // iv is stored at salt_buf 4 (length 16)
12679 // data is stored at salt_buf 8 (length 16)
12681 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12682 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12683 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12684 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12686 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12687 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12688 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12689 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12693 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12695 const char p0
= cipherbuf_pos
[j
+ 0];
12696 const char p1
= cipherbuf_pos
[j
+ 1];
12698 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12699 | hex_convert (p0
) << 4;
12706 digest
[0] = 0x10101010;
12707 digest
[1] = 0x10101010;
12708 digest
[2] = 0x10101010;
12709 digest
[3] = 0x10101010;
12711 return (PARSER_OK
);
12714 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12716 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12718 u32
*digest
= (u32
*) hash_buf
->digest
;
12720 salt_t
*salt
= hash_buf
->salt
;
12722 char *hashbuf_pos
= input_buf
;
12724 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12726 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12728 uint hash_len
= iterations_pos
- hashbuf_pos
;
12730 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12734 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12736 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12738 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12742 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12744 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12746 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12748 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12750 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12752 salt
->salt_len
= salt_len
;
12754 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12756 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
12757 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
12758 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
12759 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
12761 return (PARSER_OK
);
12764 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12766 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12768 u32
*digest
= (u32
*) hash_buf
->digest
;
12770 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12771 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12772 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12773 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12774 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12775 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12776 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12777 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12779 digest
[0] = byte_swap_32 (digest
[0]);
12780 digest
[1] = byte_swap_32 (digest
[1]);
12781 digest
[2] = byte_swap_32 (digest
[2]);
12782 digest
[3] = byte_swap_32 (digest
[3]);
12783 digest
[4] = byte_swap_32 (digest
[4]);
12784 digest
[5] = byte_swap_32 (digest
[5]);
12785 digest
[6] = byte_swap_32 (digest
[6]);
12786 digest
[7] = byte_swap_32 (digest
[7]);
12788 return (PARSER_OK
);
12791 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12793 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12795 u32
*digest
= (u32
*) hash_buf
->digest
;
12797 salt_t
*salt
= hash_buf
->salt
;
12799 char *salt_pos
= input_buf
+ 3;
12801 uint iterations_len
= 0;
12803 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12807 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12809 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12810 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12814 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12818 iterations_len
+= 8;
12822 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12825 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12827 char *hash_pos
= strchr (salt_pos
, '$');
12829 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12831 uint salt_len
= hash_pos
- salt_pos
;
12833 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12835 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12837 salt
->salt_len
= salt_len
;
12841 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12843 return (PARSER_OK
);
12846 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12848 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12850 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12852 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12854 u64
*digest
= (u64
*) hash_buf
->digest
;
12856 salt_t
*salt
= hash_buf
->salt
;
12858 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12860 char *iter_pos
= input_buf
+ 4;
12862 char *salt_pos
= strchr (iter_pos
, '$');
12864 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12868 char *hash_pos
= strchr (salt_pos
, '$');
12870 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12872 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12876 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12877 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12878 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12879 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12880 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12881 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12882 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12883 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12885 uint salt_len
= hash_pos
- salt_pos
- 1;
12887 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12889 salt
->salt_len
= salt_len
/ 2;
12891 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12892 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12893 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12894 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12895 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
12896 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
12897 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
12898 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
12900 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12901 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12902 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12903 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12904 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12905 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12906 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12907 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12908 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12909 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12911 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12913 salt
->salt_iter
= atoi (iter_pos
) - 1;
12915 return (PARSER_OK
);
12918 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12920 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12922 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12924 u32
*digest
= (u32
*) hash_buf
->digest
;
12926 salt_t
*salt
= hash_buf
->salt
;
12928 char *salt_pos
= input_buf
+ 14;
12930 char *hash_pos
= strchr (salt_pos
, '*');
12932 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12936 uint salt_len
= hash_pos
- salt_pos
- 1;
12938 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12940 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
12942 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12944 salt
->salt_len
= salt_len
;
12946 u8 tmp_buf
[100] = { 0 };
12948 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
12950 memcpy (digest
, tmp_buf
, 32);
12952 digest
[0] = byte_swap_32 (digest
[0]);
12953 digest
[1] = byte_swap_32 (digest
[1]);
12954 digest
[2] = byte_swap_32 (digest
[2]);
12955 digest
[3] = byte_swap_32 (digest
[3]);
12956 digest
[4] = byte_swap_32 (digest
[4]);
12957 digest
[5] = byte_swap_32 (digest
[5]);
12958 digest
[6] = byte_swap_32 (digest
[6]);
12959 digest
[7] = byte_swap_32 (digest
[7]);
12961 digest
[0] -= SHA256M_A
;
12962 digest
[1] -= SHA256M_B
;
12963 digest
[2] -= SHA256M_C
;
12964 digest
[3] -= SHA256M_D
;
12965 digest
[4] -= SHA256M_E
;
12966 digest
[5] -= SHA256M_F
;
12967 digest
[6] -= SHA256M_G
;
12968 digest
[7] -= SHA256M_H
;
12970 return (PARSER_OK
);
12973 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12975 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
12977 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12979 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
12981 u64
*digest
= (u64
*) hash_buf
->digest
;
12983 salt_t
*salt
= hash_buf
->salt
;
12985 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12987 char *iter_pos
= input_buf
+ 19;
12989 char *salt_pos
= strchr (iter_pos
, '.');
12991 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12995 char *hash_pos
= strchr (salt_pos
, '.');
12997 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12999 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13003 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13004 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13005 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13006 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13007 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13008 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13009 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13010 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13012 uint salt_len
= hash_pos
- salt_pos
- 1;
13016 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13020 for (i
= 0; i
< salt_len
; i
++)
13022 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13025 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13026 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13028 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13030 salt
->salt_len
= salt_len
;
13032 salt
->salt_iter
= atoi (iter_pos
) - 1;
13034 return (PARSER_OK
);
13037 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13039 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13041 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13043 u64
*digest
= (u64
*) hash_buf
->digest
;
13045 salt_t
*salt
= hash_buf
->salt
;
13047 u8 tmp_buf
[120] = { 0 };
13049 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13051 memcpy (digest
, tmp_buf
, 64);
13053 digest
[0] = byte_swap_64 (digest
[0]);
13054 digest
[1] = byte_swap_64 (digest
[1]);
13055 digest
[2] = byte_swap_64 (digest
[2]);
13056 digest
[3] = byte_swap_64 (digest
[3]);
13057 digest
[4] = byte_swap_64 (digest
[4]);
13058 digest
[5] = byte_swap_64 (digest
[5]);
13059 digest
[6] = byte_swap_64 (digest
[6]);
13060 digest
[7] = byte_swap_64 (digest
[7]);
13062 digest
[0] -= SHA512M_A
;
13063 digest
[1] -= SHA512M_B
;
13064 digest
[2] -= SHA512M_C
;
13065 digest
[3] -= SHA512M_D
;
13066 digest
[4] -= SHA512M_E
;
13067 digest
[5] -= SHA512M_F
;
13068 digest
[6] -= SHA512M_G
;
13069 digest
[7] -= SHA512M_H
;
13071 salt
->salt_len
= tmp_len
- 64;
13073 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13075 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13077 char *ptr
= (char *) salt
->salt_buf
;
13079 ptr
[salt
->salt_len
] = 0x80;
13082 return (PARSER_OK
);
13085 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13087 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13089 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13093 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13096 u32
*digest
= (u32
*) hash_buf
->digest
;
13098 salt_t
*salt
= hash_buf
->salt
;
13100 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13101 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13102 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13103 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13105 digest
[0] = byte_swap_32 (digest
[0]);
13106 digest
[1] = byte_swap_32 (digest
[1]);
13107 digest
[2] = byte_swap_32 (digest
[2]);
13108 digest
[3] = byte_swap_32 (digest
[3]);
13110 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13112 uint salt_len
= input_len
- 32 - 1;
13114 char *salt_buf
= input_buf
+ 32 + 1;
13116 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13118 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13120 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13122 salt
->salt_len
= salt_len
;
13124 return (PARSER_OK
);
13127 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13129 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13131 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13135 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13138 u32
*digest
= (u32
*) hash_buf
->digest
;
13140 salt_t
*salt
= hash_buf
->salt
;
13142 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13143 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13144 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13145 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13146 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13148 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13150 uint salt_len
= input_len
- 40 - 1;
13152 char *salt_buf
= input_buf
+ 40 + 1;
13154 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13156 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13158 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13160 salt
->salt_len
= salt_len
;
13162 return (PARSER_OK
);
13165 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13167 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13169 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13173 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13176 u32
*digest
= (u32
*) hash_buf
->digest
;
13178 salt_t
*salt
= hash_buf
->salt
;
13180 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13181 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13182 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13183 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13184 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13185 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13186 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13187 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13189 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13191 uint salt_len
= input_len
- 64 - 1;
13193 char *salt_buf
= input_buf
+ 64 + 1;
13195 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13197 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13199 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13201 salt
->salt_len
= salt_len
;
13203 return (PARSER_OK
);
13206 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13208 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13210 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13214 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13217 u64
*digest
= (u64
*) hash_buf
->digest
;
13219 salt_t
*salt
= hash_buf
->salt
;
13221 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13222 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13223 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13224 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13225 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13226 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13227 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13228 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13230 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13232 uint salt_len
= input_len
- 128 - 1;
13234 char *salt_buf
= input_buf
+ 128 + 1;
13236 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13238 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13240 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13242 salt
->salt_len
= salt_len
;
13244 return (PARSER_OK
);
13247 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13249 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13251 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13253 u32
*digest
= (u32
*) hash_buf
->digest
;
13255 salt_t
*salt
= hash_buf
->salt
;
13257 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13263 char *user_pos
= input_buf
+ 10 + 1;
13265 char *realm_pos
= strchr (user_pos
, '$');
13267 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13269 uint user_len
= realm_pos
- user_pos
;
13271 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13275 char *salt_pos
= strchr (realm_pos
, '$');
13277 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13279 uint realm_len
= salt_pos
- realm_pos
;
13281 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13285 char *data_pos
= strchr (salt_pos
, '$');
13287 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13289 uint salt_len
= data_pos
- salt_pos
;
13291 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13295 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13297 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13303 memcpy (krb5pa
->user
, user_pos
, user_len
);
13304 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13305 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13307 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13309 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13311 const char p0
= data_pos
[i
+ 0];
13312 const char p1
= data_pos
[i
+ 1];
13314 *timestamp_ptr
++ = hex_convert (p1
) << 0
13315 | hex_convert (p0
) << 4;
13318 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13320 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13322 const char p0
= data_pos
[i
+ 0];
13323 const char p1
= data_pos
[i
+ 1];
13325 *checksum_ptr
++ = hex_convert (p1
) << 0
13326 | hex_convert (p0
) << 4;
13330 * copy some data to generic buffers to make sorting happy
13333 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13334 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13335 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13336 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13337 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13338 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13339 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13340 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13341 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13343 salt
->salt_len
= 36;
13345 digest
[0] = krb5pa
->checksum
[0];
13346 digest
[1] = krb5pa
->checksum
[1];
13347 digest
[2] = krb5pa
->checksum
[2];
13348 digest
[3] = krb5pa
->checksum
[3];
13350 return (PARSER_OK
);
13353 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13355 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13357 u32
*digest
= (u32
*) hash_buf
->digest
;
13359 salt_t
*salt
= hash_buf
->salt
;
13365 char *salt_pos
= input_buf
;
13367 char *hash_pos
= strchr (salt_pos
, '$');
13369 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13371 uint salt_len
= hash_pos
- salt_pos
;
13373 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13377 uint hash_len
= input_len
- 1 - salt_len
;
13379 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13387 for (uint i
= 0; i
< salt_len
; i
++)
13389 if (salt_pos
[i
] == ' ') continue;
13394 // SAP user names cannot be longer than 12 characters
13395 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13397 // SAP user name cannot start with ! or ?
13398 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13404 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13406 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13408 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13410 salt
->salt_len
= salt_len
;
13412 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13413 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13417 digest
[0] = byte_swap_32 (digest
[0]);
13418 digest
[1] = byte_swap_32 (digest
[1]);
13420 return (PARSER_OK
);
13423 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13425 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13427 u32
*digest
= (u32
*) hash_buf
->digest
;
13429 salt_t
*salt
= hash_buf
->salt
;
13435 char *salt_pos
= input_buf
;
13437 char *hash_pos
= strchr (salt_pos
, '$');
13439 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13441 uint salt_len
= hash_pos
- salt_pos
;
13443 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13447 uint hash_len
= input_len
- 1 - salt_len
;
13449 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13457 for (uint i
= 0; i
< salt_len
; i
++)
13459 if (salt_pos
[i
] == ' ') continue;
13464 // SAP user names cannot be longer than 12 characters
13465 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13466 // so far nobody complained so we stay with this because it helps in optimization
13467 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13469 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13471 // SAP user name cannot start with ! or ?
13472 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13478 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13480 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13482 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13484 salt
->salt_len
= salt_len
;
13486 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13487 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13488 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13489 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13490 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13492 return (PARSER_OK
);
13495 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13497 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13499 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13501 u64
*digest
= (u64
*) hash_buf
->digest
;
13503 salt_t
*salt
= hash_buf
->salt
;
13505 char *iter_pos
= input_buf
+ 3;
13507 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13509 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13511 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13513 salt
->salt_iter
= salt_iter
;
13515 char *salt_pos
= iter_pos
+ 1;
13519 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13521 salt
->salt_len
= salt_len
;
13523 char *hash_pos
= salt_pos
+ salt_len
;
13525 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13529 char *tmp
= (char *) salt
->salt_buf_pc
;
13531 tmp
[0] = hash_pos
[42];
13535 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13536 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13537 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13538 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13544 return (PARSER_OK
);
13547 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13549 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13551 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13553 u32
*digest
= (u32
*) hash_buf
->digest
;
13555 salt_t
*salt
= hash_buf
->salt
;
13557 char *salt_buf
= input_buf
+ 6;
13559 uint salt_len
= 16;
13561 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13563 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13565 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13567 salt
->salt_len
= salt_len
;
13569 char *hash_pos
= input_buf
+ 6 + 16;
13571 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13572 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13573 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13574 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13575 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13576 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13577 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13578 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13580 return (PARSER_OK
);
13583 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13585 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13587 u32
*digest
= (u32
*) hash_buf
->digest
;
13589 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13590 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13594 return (PARSER_OK
);
13597 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13599 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13601 u32
*digest
= (u32
*) hash_buf
->digest
;
13603 salt_t
*salt
= hash_buf
->salt
;
13605 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13607 char *saltbuf_pos
= input_buf
;
13609 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13611 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13613 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13615 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13616 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13618 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13622 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13624 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13626 char *salt_ptr
= (char *) saltbuf_pos
;
13627 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13632 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13634 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13637 rakp_ptr
[j
] = 0x80;
13639 rakp
->salt_len
= j
;
13641 for (i
= 0; i
< 64; i
++)
13643 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13646 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13647 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13648 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13649 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13650 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13651 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13652 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13653 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13655 salt
->salt_len
= 32; // muss min. 32 haben
13657 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13658 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13659 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13660 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13661 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13663 return (PARSER_OK
);
13666 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13668 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13670 u32
*digest
= (u32
*) hash_buf
->digest
;
13672 salt_t
*salt
= hash_buf
->salt
;
13674 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13676 char *salt_pos
= input_buf
+ 1;
13678 memcpy (salt
->salt_buf
, salt_pos
, 8);
13680 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13681 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13683 salt
->salt_len
= 8;
13685 char *hash_pos
= salt_pos
+ 8;
13687 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13688 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13689 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13690 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13691 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13693 digest
[0] -= SHA1M_A
;
13694 digest
[1] -= SHA1M_B
;
13695 digest
[2] -= SHA1M_C
;
13696 digest
[3] -= SHA1M_D
;
13697 digest
[4] -= SHA1M_E
;
13699 return (PARSER_OK
);
13702 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13704 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13706 u32
*digest
= (u32
*) hash_buf
->digest
;
13708 salt_t
*salt
= hash_buf
->salt
;
13710 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13711 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13712 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13713 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13715 digest
[0] = byte_swap_32 (digest
[0]);
13716 digest
[1] = byte_swap_32 (digest
[1]);
13717 digest
[2] = byte_swap_32 (digest
[2]);
13718 digest
[3] = byte_swap_32 (digest
[3]);
13720 digest
[0] -= MD5M_A
;
13721 digest
[1] -= MD5M_B
;
13722 digest
[2] -= MD5M_C
;
13723 digest
[3] -= MD5M_D
;
13725 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13727 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13729 u32
*salt_buf
= salt
->salt_buf
;
13731 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
13732 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
13733 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
13734 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
13736 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13737 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13738 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13739 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13741 salt
->salt_len
= 16 + 1;
13743 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13745 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13747 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
13749 return (PARSER_OK
);
13752 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13754 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13756 u32
*digest
= (u32
*) hash_buf
->digest
;
13758 salt_t
*salt
= hash_buf
->salt
;
13760 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13766 char *hashbuf_pos
= input_buf
;
13768 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13770 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13772 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13774 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13778 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13780 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13782 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13784 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13788 char *databuf_pos
= strchr (iteration_pos
, ':');
13790 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13792 const uint iteration_len
= databuf_pos
- iteration_pos
;
13794 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13795 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13797 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13799 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13800 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13806 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13807 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13808 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13809 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13810 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13811 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
13812 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
13813 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
13817 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13819 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13821 const char p0
= saltbuf_pos
[i
+ 0];
13822 const char p1
= saltbuf_pos
[i
+ 1];
13824 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13825 | hex_convert (p0
) << 4;
13828 salt
->salt_buf
[4] = 0x01000000;
13829 salt
->salt_buf
[5] = 0x80;
13831 salt
->salt_len
= saltbuf_len
/ 2;
13835 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13839 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13841 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13843 const char p0
= databuf_pos
[i
+ 0];
13844 const char p1
= databuf_pos
[i
+ 1];
13846 *databuf_ptr
++ = hex_convert (p1
) << 0
13847 | hex_convert (p0
) << 4;
13850 *databuf_ptr
++ = 0x80;
13852 for (uint i
= 0; i
< 512; i
++)
13854 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13857 cloudkey
->data_len
= databuf_len
/ 2;
13859 return (PARSER_OK
);
13862 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13864 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13866 u32
*digest
= (u32
*) hash_buf
->digest
;
13868 salt_t
*salt
= hash_buf
->salt
;
13874 char *hashbuf_pos
= input_buf
;
13876 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13878 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13880 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13882 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13886 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13888 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13890 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13892 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13894 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13898 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13900 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13902 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13904 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13906 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13910 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13912 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13913 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13915 // ok, the plan for this algorithm is the following:
13916 // we have 2 salts here, the domain-name and a random salt
13917 // while both are used in the initial transformation,
13918 // only the random salt is used in the following iterations
13919 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13920 // and one that includes only the real salt (stored into salt_buf[]).
13921 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13923 u8 tmp_buf
[100] = { 0 };
13925 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
13927 memcpy (digest
, tmp_buf
, 20);
13929 digest
[0] = byte_swap_32 (digest
[0]);
13930 digest
[1] = byte_swap_32 (digest
[1]);
13931 digest
[2] = byte_swap_32 (digest
[2]);
13932 digest
[3] = byte_swap_32 (digest
[3]);
13933 digest
[4] = byte_swap_32 (digest
[4]);
13937 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13939 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
13941 char *len_ptr
= NULL
;
13943 for (uint i
= 0; i
< domainbuf_len
; i
++)
13945 if (salt_buf_pc_ptr
[i
] == '.')
13947 len_ptr
= &salt_buf_pc_ptr
[i
];
13957 salt
->salt_buf_pc
[7] = domainbuf_len
;
13961 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13963 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
13965 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13967 salt
->salt_len
= salt_len
;
13971 salt
->salt_iter
= atoi (iteration_pos
);
13973 return (PARSER_OK
);
13976 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13978 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
13980 u32
*digest
= (u32
*) hash_buf
->digest
;
13982 salt_t
*salt
= hash_buf
->salt
;
13984 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13985 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13986 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13987 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13988 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13990 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13992 uint salt_len
= input_len
- 40 - 1;
13994 char *salt_buf
= input_buf
+ 40 + 1;
13996 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13998 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14000 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14002 salt
->salt_len
= salt_len
;
14004 return (PARSER_OK
);
14007 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14009 const u8 ascii_to_ebcdic
[] =
14011 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14012 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14013 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14014 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14015 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14016 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14017 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14018 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14019 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14020 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14021 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14022 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14023 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14024 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14025 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14026 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14029 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14031 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14033 u32
*digest
= (u32
*) hash_buf
->digest
;
14035 salt_t
*salt
= hash_buf
->salt
;
14037 char *salt_pos
= input_buf
+ 6 + 1;
14039 char *digest_pos
= strchr (salt_pos
, '*');
14041 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14043 uint salt_len
= digest_pos
- salt_pos
;
14045 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14047 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14049 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14053 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14054 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14056 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14058 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14060 salt
->salt_len
= salt_len
;
14062 for (uint i
= 0; i
< salt_len
; i
++)
14064 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14066 for (uint i
= salt_len
; i
< 8; i
++)
14068 salt_buf_pc_ptr
[i
] = 0x40;
14073 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14075 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14076 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14078 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14079 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14081 digest
[0] = byte_swap_32 (digest
[0]);
14082 digest
[1] = byte_swap_32 (digest
[1]);
14084 IP (digest
[0], digest
[1], tt
);
14086 digest
[0] = rotr32 (digest
[0], 29);
14087 digest
[1] = rotr32 (digest
[1], 29);
14091 return (PARSER_OK
);
14094 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14096 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14098 u32
*digest
= (u32
*) hash_buf
->digest
;
14100 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14101 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14102 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14103 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14105 digest
[0] = byte_swap_32 (digest
[0]);
14106 digest
[1] = byte_swap_32 (digest
[1]);
14107 digest
[2] = byte_swap_32 (digest
[2]);
14108 digest
[3] = byte_swap_32 (digest
[3]);
14110 return (PARSER_OK
);
14113 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14115 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14117 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14119 u32
*digest
= (u32
*) hash_buf
->digest
;
14121 salt_t
*salt
= hash_buf
->salt
;
14123 u8 tmp_buf
[120] = { 0 };
14125 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14127 tmp_buf
[3] += -4; // dont ask!
14129 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14131 salt
->salt_len
= 5;
14133 memcpy (digest
, tmp_buf
+ 5, 9);
14135 // yes, only 9 byte are needed to crack, but 10 to display
14137 salt
->salt_buf_pc
[7] = input_buf
[20];
14139 return (PARSER_OK
);
14142 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14144 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14146 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14148 u32
*digest
= (u32
*) hash_buf
->digest
;
14150 salt_t
*salt
= hash_buf
->salt
;
14152 u8 tmp_buf
[120] = { 0 };
14154 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14156 tmp_buf
[3] += -4; // dont ask!
14160 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14162 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)
14166 char tmp_iter_buf
[11] = { 0 };
14168 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14170 tmp_iter_buf
[10] = 0;
14172 salt
->salt_iter
= atoi (tmp_iter_buf
);
14174 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14176 return (PARSER_SALT_ITERATION
);
14179 salt
->salt_iter
--; // first round in init
14181 // 2 additional bytes for display only
14183 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14184 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14188 memcpy (digest
, tmp_buf
+ 28, 8);
14190 digest
[0] = byte_swap_32 (digest
[0]);
14191 digest
[1] = byte_swap_32 (digest
[1]);
14195 return (PARSER_OK
);
14198 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14200 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14202 u32
*digest
= (u32
*) hash_buf
->digest
;
14204 salt_t
*salt
= hash_buf
->salt
;
14206 char *salt_buf_pos
= input_buf
;
14208 char *hash_buf_pos
= salt_buf_pos
+ 6;
14210 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14211 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14212 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14213 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14214 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14215 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14216 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14217 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14219 digest
[0] -= SHA256M_A
;
14220 digest
[1] -= SHA256M_B
;
14221 digest
[2] -= SHA256M_C
;
14222 digest
[3] -= SHA256M_D
;
14223 digest
[4] -= SHA256M_E
;
14224 digest
[5] -= SHA256M_F
;
14225 digest
[6] -= SHA256M_G
;
14226 digest
[7] -= SHA256M_H
;
14228 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14230 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14232 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14234 salt
->salt_len
= salt_len
;
14236 return (PARSER_OK
);
14239 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14241 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14243 u32
*digest
= (u32
*) hash_buf
->digest
;
14245 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14247 salt_t
*salt
= hash_buf
->salt
;
14249 char *salt_buf
= input_buf
+ 6;
14251 char *digest_buf
= strchr (salt_buf
, '$');
14253 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14255 uint salt_len
= digest_buf
- salt_buf
;
14257 digest_buf
++; // skip the '$' symbol
14259 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14261 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14263 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14265 salt
->salt_len
= salt_len
;
14267 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14268 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14269 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14270 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14272 digest
[0] = byte_swap_32 (digest
[0]);
14273 digest
[1] = byte_swap_32 (digest
[1]);
14274 digest
[2] = byte_swap_32 (digest
[2]);
14275 digest
[3] = byte_swap_32 (digest
[3]);
14277 digest
[0] -= MD5M_A
;
14278 digest
[1] -= MD5M_B
;
14279 digest
[2] -= MD5M_C
;
14280 digest
[3] -= MD5M_D
;
14282 return (PARSER_OK
);
14285 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14287 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14289 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14291 u32
*digest
= (u32
*) hash_buf
->digest
;
14293 salt_t
*salt
= hash_buf
->salt
;
14295 char *salt_buf
= input_buf
+ 3;
14297 char *digest_buf
= strchr (salt_buf
, '$');
14299 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14301 uint salt_len
= digest_buf
- salt_buf
;
14303 digest_buf
++; // skip the '$' symbol
14305 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14307 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14309 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14311 salt_buf_ptr
[salt_len
] = 0x2d;
14313 salt
->salt_len
= salt_len
+ 1;
14315 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14316 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14317 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14318 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14320 digest
[0] = byte_swap_32 (digest
[0]);
14321 digest
[1] = byte_swap_32 (digest
[1]);
14322 digest
[2] = byte_swap_32 (digest
[2]);
14323 digest
[3] = byte_swap_32 (digest
[3]);
14325 digest
[0] -= MD5M_A
;
14326 digest
[1] -= MD5M_B
;
14327 digest
[2] -= MD5M_C
;
14328 digest
[3] -= MD5M_D
;
14330 return (PARSER_OK
);
14333 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14335 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14337 u32
*digest
= (u32
*) hash_buf
->digest
;
14339 u8 tmp_buf
[100] = { 0 };
14341 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14343 memcpy (digest
, tmp_buf
, 20);
14345 digest
[0] = byte_swap_32 (digest
[0]);
14346 digest
[1] = byte_swap_32 (digest
[1]);
14347 digest
[2] = byte_swap_32 (digest
[2]);
14348 digest
[3] = byte_swap_32 (digest
[3]);
14349 digest
[4] = byte_swap_32 (digest
[4]);
14351 digest
[0] -= SHA1M_A
;
14352 digest
[1] -= SHA1M_B
;
14353 digest
[2] -= SHA1M_C
;
14354 digest
[3] -= SHA1M_D
;
14355 digest
[4] -= SHA1M_E
;
14357 return (PARSER_OK
);
14360 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14362 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14364 u32
*digest
= (u32
*) hash_buf
->digest
;
14366 salt_t
*salt
= hash_buf
->salt
;
14368 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14369 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14370 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14371 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14373 digest
[0] = byte_swap_32 (digest
[0]);
14374 digest
[1] = byte_swap_32 (digest
[1]);
14375 digest
[2] = byte_swap_32 (digest
[2]);
14376 digest
[3] = byte_swap_32 (digest
[3]);
14378 digest
[0] -= MD5M_A
;
14379 digest
[1] -= MD5M_B
;
14380 digest
[2] -= MD5M_C
;
14381 digest
[3] -= MD5M_D
;
14383 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14385 uint salt_len
= input_len
- 32 - 1;
14387 char *salt_buf
= input_buf
+ 32 + 1;
14389 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14391 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14393 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14396 * add static "salt" part
14399 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14403 salt
->salt_len
= salt_len
;
14405 return (PARSER_OK
);
14408 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14410 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14412 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14414 u32
*digest
= (u32
*) hash_buf
->digest
;
14416 salt_t
*salt
= hash_buf
->salt
;
14418 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14424 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14426 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14428 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14430 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14432 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14436 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14438 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14440 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14442 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14446 char *keybuf_pos
= strchr (keylen_pos
, '$');
14448 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14450 uint keylen_len
= keybuf_pos
- keylen_pos
;
14452 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14456 char *databuf_pos
= strchr (keybuf_pos
, '$');
14458 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14460 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14462 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14466 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14468 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14474 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14475 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14476 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14477 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14479 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14480 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14481 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14482 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14484 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14485 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14486 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14487 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14489 salt
->salt_len
= 16;
14490 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14492 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14494 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14497 return (PARSER_OK
);
14500 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14502 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14504 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14506 u32
*digest
= (u32
*) hash_buf
->digest
;
14508 salt_t
*salt
= hash_buf
->salt
;
14514 // first is the N salt parameter
14516 char *N_pos
= input_buf
+ 6;
14518 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14522 salt
->scrypt_N
= atoi (N_pos
);
14526 char *r_pos
= strchr (N_pos
, ':');
14528 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14532 salt
->scrypt_r
= atoi (r_pos
);
14536 char *p_pos
= strchr (r_pos
, ':');
14538 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14542 salt
->scrypt_p
= atoi (p_pos
);
14546 char *saltbuf_pos
= strchr (p_pos
, ':');
14548 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14552 char *hash_pos
= strchr (saltbuf_pos
, ':');
14554 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14560 u8 tmp_buf
[33] = { 0 };
14562 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14564 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14566 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14568 salt
->salt_len
= tmp_len
;
14569 salt
->salt_iter
= 1;
14571 // digest - base64 decode
14573 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14575 tmp_len
= input_len
- (hash_pos
- input_buf
);
14577 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14579 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14581 memcpy (digest
, tmp_buf
, 32);
14583 return (PARSER_OK
);
14586 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14588 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14590 u32
*digest
= (u32
*) hash_buf
->digest
;
14592 salt_t
*salt
= hash_buf
->salt
;
14598 char decrypted
[76] = { 0 }; // iv + hash
14600 juniper_decrypt_hash (input_buf
, decrypted
);
14602 char *md5crypt_hash
= decrypted
+ 12;
14604 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14606 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14608 char *salt_pos
= md5crypt_hash
+ 3;
14610 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14612 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14614 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14618 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14620 return (PARSER_OK
);
14623 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14625 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14627 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14629 u32
*digest
= (u32
*) hash_buf
->digest
;
14631 salt_t
*salt
= hash_buf
->salt
;
14633 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14639 // first is *raw* salt
14641 char *salt_pos
= input_buf
+ 3;
14643 char *hash_pos
= strchr (salt_pos
, '$');
14645 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14647 uint salt_len
= hash_pos
- salt_pos
;
14649 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14653 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14655 memcpy (salt_buf_ptr
, salt_pos
, 14);
14657 salt_buf_ptr
[17] = 0x01;
14658 salt_buf_ptr
[18] = 0x80;
14660 // add some stuff to normal salt to make sorted happy
14662 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14663 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14664 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14665 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14667 salt
->salt_len
= salt_len
;
14668 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14670 // base64 decode hash
14672 u8 tmp_buf
[100] = { 0 };
14674 uint hash_len
= input_len
- 3 - salt_len
- 1;
14676 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14678 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14680 memcpy (digest
, tmp_buf
, 32);
14682 digest
[0] = byte_swap_32 (digest
[0]);
14683 digest
[1] = byte_swap_32 (digest
[1]);
14684 digest
[2] = byte_swap_32 (digest
[2]);
14685 digest
[3] = byte_swap_32 (digest
[3]);
14686 digest
[4] = byte_swap_32 (digest
[4]);
14687 digest
[5] = byte_swap_32 (digest
[5]);
14688 digest
[6] = byte_swap_32 (digest
[6]);
14689 digest
[7] = byte_swap_32 (digest
[7]);
14691 return (PARSER_OK
);
14694 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14696 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14698 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14700 u32
*digest
= (u32
*) hash_buf
->digest
;
14702 salt_t
*salt
= hash_buf
->salt
;
14708 // first is *raw* salt
14710 char *salt_pos
= input_buf
+ 3;
14712 char *hash_pos
= strchr (salt_pos
, '$');
14714 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14716 uint salt_len
= hash_pos
- salt_pos
;
14718 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14720 salt
->salt_len
= salt_len
;
14723 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14725 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14726 salt_buf_ptr
[salt_len
] = 0;
14728 // base64 decode hash
14730 u8 tmp_buf
[100] = { 0 };
14732 uint hash_len
= input_len
- 3 - salt_len
- 1;
14734 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14736 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14738 memcpy (digest
, tmp_buf
, 32);
14741 salt
->scrypt_N
= 16384;
14742 salt
->scrypt_r
= 1;
14743 salt
->scrypt_p
= 1;
14744 salt
->salt_iter
= 1;
14746 return (PARSER_OK
);
14749 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14751 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14753 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14755 u32
*digest
= (u32
*) hash_buf
->digest
;
14757 salt_t
*salt
= hash_buf
->salt
;
14759 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14765 char *version_pos
= input_buf
+ 8 + 1;
14767 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14769 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14771 u32 version_len
= verifierHashSize_pos
- version_pos
;
14773 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14775 verifierHashSize_pos
++;
14777 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14779 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14781 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14783 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14787 char *saltSize_pos
= strchr (keySize_pos
, '*');
14789 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14791 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14793 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14797 char *osalt_pos
= strchr (saltSize_pos
, '*');
14799 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14801 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14803 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14807 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14809 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14811 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14813 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14815 encryptedVerifier_pos
++;
14817 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14819 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14821 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14823 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14825 encryptedVerifierHash_pos
++;
14827 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;
14829 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14831 const uint version
= atoi (version_pos
);
14833 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14835 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14837 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14839 const uint keySize
= atoi (keySize_pos
);
14841 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14843 office2007
->keySize
= keySize
;
14845 const uint saltSize
= atoi (saltSize_pos
);
14847 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14853 salt
->salt_len
= 16;
14854 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14856 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
14857 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
14858 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
14859 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
14865 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
14866 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
14867 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
14868 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
14870 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
14871 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
14872 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
14873 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
14874 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
14880 digest
[0] = office2007
->encryptedVerifierHash
[0];
14881 digest
[1] = office2007
->encryptedVerifierHash
[1];
14882 digest
[2] = office2007
->encryptedVerifierHash
[2];
14883 digest
[3] = office2007
->encryptedVerifierHash
[3];
14885 return (PARSER_OK
);
14888 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14890 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14892 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14894 u32
*digest
= (u32
*) hash_buf
->digest
;
14896 salt_t
*salt
= hash_buf
->salt
;
14898 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14904 char *version_pos
= input_buf
+ 8 + 1;
14906 char *spinCount_pos
= strchr (version_pos
, '*');
14908 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14910 u32 version_len
= spinCount_pos
- version_pos
;
14912 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14916 char *keySize_pos
= strchr (spinCount_pos
, '*');
14918 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14920 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
14922 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14926 char *saltSize_pos
= strchr (keySize_pos
, '*');
14928 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14930 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14932 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14936 char *osalt_pos
= strchr (saltSize_pos
, '*');
14938 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14940 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14942 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14946 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14948 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14950 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14952 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14954 encryptedVerifier_pos
++;
14956 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14958 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14960 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14962 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14964 encryptedVerifierHash_pos
++;
14966 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;
14968 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14970 const uint version
= atoi (version_pos
);
14972 if (version
!= 2010) return (PARSER_SALT_VALUE
);
14974 const uint spinCount
= atoi (spinCount_pos
);
14976 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
14978 const uint keySize
= atoi (keySize_pos
);
14980 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
14982 const uint saltSize
= atoi (saltSize_pos
);
14984 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14990 salt
->salt_len
= 16;
14991 salt
->salt_iter
= spinCount
;
14993 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
14994 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
14995 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
14996 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15002 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15003 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15004 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15005 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15007 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15008 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15009 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15010 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15011 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15012 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15013 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15014 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15020 digest
[0] = office2010
->encryptedVerifierHash
[0];
15021 digest
[1] = office2010
->encryptedVerifierHash
[1];
15022 digest
[2] = office2010
->encryptedVerifierHash
[2];
15023 digest
[3] = office2010
->encryptedVerifierHash
[3];
15025 return (PARSER_OK
);
15028 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15030 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15032 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15034 u32
*digest
= (u32
*) hash_buf
->digest
;
15036 salt_t
*salt
= hash_buf
->salt
;
15038 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15044 char *version_pos
= input_buf
+ 8 + 1;
15046 char *spinCount_pos
= strchr (version_pos
, '*');
15048 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15050 u32 version_len
= spinCount_pos
- version_pos
;
15052 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15056 char *keySize_pos
= strchr (spinCount_pos
, '*');
15058 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15060 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15062 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15066 char *saltSize_pos
= strchr (keySize_pos
, '*');
15068 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15070 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15072 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15076 char *osalt_pos
= strchr (saltSize_pos
, '*');
15078 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15080 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15082 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15086 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15088 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15090 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15092 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15094 encryptedVerifier_pos
++;
15096 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15098 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15100 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15102 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15104 encryptedVerifierHash_pos
++;
15106 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;
15108 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15110 const uint version
= atoi (version_pos
);
15112 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15114 const uint spinCount
= atoi (spinCount_pos
);
15116 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15118 const uint keySize
= atoi (keySize_pos
);
15120 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15122 const uint saltSize
= atoi (saltSize_pos
);
15124 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15130 salt
->salt_len
= 16;
15131 salt
->salt_iter
= spinCount
;
15133 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15134 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15135 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15136 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15142 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15143 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15144 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15145 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15147 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15148 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15149 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15150 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15151 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15152 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15153 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15154 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15160 digest
[0] = office2013
->encryptedVerifierHash
[0];
15161 digest
[1] = office2013
->encryptedVerifierHash
[1];
15162 digest
[2] = office2013
->encryptedVerifierHash
[2];
15163 digest
[3] = office2013
->encryptedVerifierHash
[3];
15165 return (PARSER_OK
);
15168 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15170 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15172 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15174 u32
*digest
= (u32
*) hash_buf
->digest
;
15176 salt_t
*salt
= hash_buf
->salt
;
15178 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15184 char *version_pos
= input_buf
+ 11;
15186 char *osalt_pos
= strchr (version_pos
, '*');
15188 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15190 u32 version_len
= osalt_pos
- version_pos
;
15192 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15196 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15198 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15200 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15202 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15204 encryptedVerifier_pos
++;
15206 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15208 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15210 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15212 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15214 encryptedVerifierHash_pos
++;
15216 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15218 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15220 const uint version
= *version_pos
- 0x30;
15222 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15228 oldoffice01
->version
= version
;
15230 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15231 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15232 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15233 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15235 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15236 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15237 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15238 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15240 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15241 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15242 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15243 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15245 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15246 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15247 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15248 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15254 salt
->salt_len
= 16;
15256 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15257 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15258 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15259 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15261 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15262 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15263 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15264 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15266 // this is a workaround as office produces multiple documents with the same salt
15268 salt
->salt_len
+= 32;
15270 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15271 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15272 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15273 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15274 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15275 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15276 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15277 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15283 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15284 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15285 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15286 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15288 return (PARSER_OK
);
15291 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15293 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15296 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15298 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15300 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15302 u32
*digest
= (u32
*) hash_buf
->digest
;
15304 salt_t
*salt
= hash_buf
->salt
;
15306 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15312 char *version_pos
= input_buf
+ 11;
15314 char *osalt_pos
= strchr (version_pos
, '*');
15316 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15318 u32 version_len
= osalt_pos
- version_pos
;
15320 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15324 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15326 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15328 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15330 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15332 encryptedVerifier_pos
++;
15334 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15336 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15338 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15340 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15342 encryptedVerifierHash_pos
++;
15344 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15346 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15348 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15350 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15354 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15356 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15358 const uint version
= *version_pos
- 0x30;
15360 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15366 oldoffice01
->version
= version
;
15368 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15369 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15370 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15371 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15373 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15374 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15375 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15376 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15378 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15379 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15380 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15381 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15383 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15384 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15385 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15386 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15388 oldoffice01
->rc4key
[1] = 0;
15389 oldoffice01
->rc4key
[0] = 0;
15391 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15392 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15393 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15394 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15395 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15396 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15397 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15398 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15399 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15400 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15402 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15403 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15409 salt
->salt_len
= 16;
15411 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15412 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15413 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15414 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15416 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15417 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15418 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15419 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15421 // this is a workaround as office produces multiple documents with the same salt
15423 salt
->salt_len
+= 32;
15425 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15426 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15427 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15428 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15429 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15430 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15431 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15432 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15438 digest
[0] = oldoffice01
->rc4key
[0];
15439 digest
[1] = oldoffice01
->rc4key
[1];
15443 return (PARSER_OK
);
15446 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15448 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15450 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15452 u32
*digest
= (u32
*) hash_buf
->digest
;
15454 salt_t
*salt
= hash_buf
->salt
;
15456 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15462 char *version_pos
= input_buf
+ 11;
15464 char *osalt_pos
= strchr (version_pos
, '*');
15466 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15468 u32 version_len
= osalt_pos
- version_pos
;
15470 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15474 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15476 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15478 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15480 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15482 encryptedVerifier_pos
++;
15484 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15486 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15488 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15490 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15492 encryptedVerifierHash_pos
++;
15494 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15496 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15498 const uint version
= *version_pos
- 0x30;
15500 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15506 oldoffice34
->version
= version
;
15508 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15509 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15510 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15511 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15513 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15514 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15515 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15516 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15518 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15519 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15520 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15521 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15522 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15524 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15525 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15526 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15527 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15528 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15534 salt
->salt_len
= 16;
15536 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15537 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15538 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15539 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15541 // this is a workaround as office produces multiple documents with the same salt
15543 salt
->salt_len
+= 32;
15545 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15546 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15547 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15548 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15549 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15550 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15551 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15552 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15558 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15559 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15560 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15561 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15563 return (PARSER_OK
);
15566 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15568 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15570 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15573 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15575 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15577 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15579 u32
*digest
= (u32
*) hash_buf
->digest
;
15581 salt_t
*salt
= hash_buf
->salt
;
15583 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15589 char *version_pos
= input_buf
+ 11;
15591 char *osalt_pos
= strchr (version_pos
, '*');
15593 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15595 u32 version_len
= osalt_pos
- version_pos
;
15597 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15601 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15603 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15605 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15607 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15609 encryptedVerifier_pos
++;
15611 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15613 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15615 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15617 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15619 encryptedVerifierHash_pos
++;
15621 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15623 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15625 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15627 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15631 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15633 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15635 const uint version
= *version_pos
- 0x30;
15637 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15643 oldoffice34
->version
= version
;
15645 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15646 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15647 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15648 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15650 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15651 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15652 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15653 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15655 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15656 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15657 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15658 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15659 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15661 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15662 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15663 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15664 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15665 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15667 oldoffice34
->rc4key
[1] = 0;
15668 oldoffice34
->rc4key
[0] = 0;
15670 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15671 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15672 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15673 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15674 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15675 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15676 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15677 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15678 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15679 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15681 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15682 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15688 salt
->salt_len
= 16;
15690 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15691 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15692 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15693 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15695 // this is a workaround as office produces multiple documents with the same salt
15697 salt
->salt_len
+= 32;
15699 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15700 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15701 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15702 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15703 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15704 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15705 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15706 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15712 digest
[0] = oldoffice34
->rc4key
[0];
15713 digest
[1] = oldoffice34
->rc4key
[1];
15717 return (PARSER_OK
);
15720 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15722 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15724 u32
*digest
= (u32
*) hash_buf
->digest
;
15726 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15727 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15728 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15729 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15731 digest
[0] = byte_swap_32 (digest
[0]);
15732 digest
[1] = byte_swap_32 (digest
[1]);
15733 digest
[2] = byte_swap_32 (digest
[2]);
15734 digest
[3] = byte_swap_32 (digest
[3]);
15736 return (PARSER_OK
);
15739 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15741 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15743 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15745 u32
*digest
= (u32
*) hash_buf
->digest
;
15747 salt_t
*salt
= hash_buf
->salt
;
15749 char *signature_pos
= input_buf
;
15751 char *salt_pos
= strchr (signature_pos
, '$');
15753 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15755 u32 signature_len
= salt_pos
- signature_pos
;
15757 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15761 char *hash_pos
= strchr (salt_pos
, '$');
15763 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15765 u32 salt_len
= hash_pos
- salt_pos
;
15767 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15771 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15773 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15775 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
15776 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
15777 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
15778 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
15779 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
15781 digest
[0] -= SHA1M_A
;
15782 digest
[1] -= SHA1M_B
;
15783 digest
[2] -= SHA1M_C
;
15784 digest
[3] -= SHA1M_D
;
15785 digest
[4] -= SHA1M_E
;
15787 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15789 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15791 salt
->salt_len
= salt_len
;
15793 return (PARSER_OK
);
15796 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15798 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15800 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15802 u32
*digest
= (u32
*) hash_buf
->digest
;
15804 salt_t
*salt
= hash_buf
->salt
;
15806 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15812 char *iter_pos
= input_buf
+ 14;
15814 const int iter
= atoi (iter_pos
);
15816 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15818 salt
->salt_iter
= iter
- 1;
15820 char *salt_pos
= strchr (iter_pos
, '$');
15822 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15826 char *hash_pos
= strchr (salt_pos
, '$');
15828 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15830 const uint salt_len
= hash_pos
- salt_pos
;
15834 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15836 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15838 salt
->salt_len
= salt_len
;
15840 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15841 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15843 // add some stuff to normal salt to make sorted happy
15845 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15846 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15847 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15848 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15849 salt
->salt_buf
[4] = salt
->salt_iter
;
15851 // base64 decode hash
15853 u8 tmp_buf
[100] = { 0 };
15855 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15857 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15859 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15861 memcpy (digest
, tmp_buf
, 32);
15863 digest
[0] = byte_swap_32 (digest
[0]);
15864 digest
[1] = byte_swap_32 (digest
[1]);
15865 digest
[2] = byte_swap_32 (digest
[2]);
15866 digest
[3] = byte_swap_32 (digest
[3]);
15867 digest
[4] = byte_swap_32 (digest
[4]);
15868 digest
[5] = byte_swap_32 (digest
[5]);
15869 digest
[6] = byte_swap_32 (digest
[6]);
15870 digest
[7] = byte_swap_32 (digest
[7]);
15872 return (PARSER_OK
);
15875 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15877 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15879 u32
*digest
= (u32
*) hash_buf
->digest
;
15881 salt_t
*salt
= hash_buf
->salt
;
15883 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15884 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15888 digest
[0] = byte_swap_32 (digest
[0]);
15889 digest
[1] = byte_swap_32 (digest
[1]);
15891 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15892 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15893 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15895 char iter_c
= input_buf
[17];
15896 char iter_d
= input_buf
[19];
15898 // atm only defaults, let's see if there's more request
15899 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15900 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15902 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15904 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
15905 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
15906 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
15907 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
15909 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15910 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15911 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15912 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15914 salt
->salt_len
= 16;
15916 return (PARSER_OK
);
15919 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15921 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
15923 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15925 u32
*digest
= (u32
*) hash_buf
->digest
;
15927 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
15929 salt_t
*salt
= hash_buf
->salt
;
15931 char *salt_pos
= input_buf
+ 10;
15933 char *hash_pos
= strchr (salt_pos
, '$');
15935 uint salt_len
= hash_pos
- salt_pos
;
15937 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15941 uint hash_len
= input_len
- 10 - salt_len
- 1;
15943 // base64 decode salt
15945 u8 tmp_buf
[100] = { 0 };
15947 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
15949 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
15951 tmp_buf
[salt_len
] = 0x80;
15953 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
15955 salt
->salt_len
= salt_len
;
15957 // base64 decode salt
15959 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15961 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15963 uint user_len
= hash_len
- 32;
15965 const u8
*tmp_hash
= tmp_buf
+ user_len
;
15967 user_len
--; // skip the trailing space
15969 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
15970 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
15971 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
15972 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
15974 digest
[0] = byte_swap_32 (digest
[0]);
15975 digest
[1] = byte_swap_32 (digest
[1]);
15976 digest
[2] = byte_swap_32 (digest
[2]);
15977 digest
[3] = byte_swap_32 (digest
[3]);
15979 // store username for host only (output hash if cracked)
15981 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
15982 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
15984 return (PARSER_OK
);
15987 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15989 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
15991 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15993 u32
*digest
= (u32
*) hash_buf
->digest
;
15995 salt_t
*salt
= hash_buf
->salt
;
15997 char *iter_pos
= input_buf
+ 10;
15999 u32 iter
= atoi (iter_pos
);
16003 return (PARSER_SALT_ITERATION
);
16006 iter
--; // first iteration is special
16008 salt
->salt_iter
= iter
;
16010 char *base64_pos
= strchr (iter_pos
, '}');
16012 if (base64_pos
== NULL
)
16014 return (PARSER_SIGNATURE_UNMATCHED
);
16019 // base64 decode salt
16021 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16023 u8 tmp_buf
[100] = { 0 };
16025 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16027 if (decoded_len
< 24)
16029 return (PARSER_SALT_LENGTH
);
16034 uint salt_len
= decoded_len
- 20;
16036 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16037 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16039 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16041 salt
->salt_len
= salt_len
;
16045 u32
*digest_ptr
= (u32
*) tmp_buf
;
16047 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16048 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16049 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16050 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16051 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16053 return (PARSER_OK
);
16056 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16058 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16060 u32
*digest
= (u32
*) hash_buf
->digest
;
16062 salt_t
*salt
= hash_buf
->salt
;
16064 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16065 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16066 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16067 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16068 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16070 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16072 uint salt_len
= input_len
- 40 - 1;
16074 char *salt_buf
= input_buf
+ 40 + 1;
16076 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16078 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16080 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16082 salt
->salt_len
= salt_len
;
16084 return (PARSER_OK
);
16087 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16089 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16091 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16093 u32
*digest
= (u32
*) hash_buf
->digest
;
16095 salt_t
*salt
= hash_buf
->salt
;
16097 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16103 char *V_pos
= input_buf
+ 5;
16105 char *R_pos
= strchr (V_pos
, '*');
16107 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16109 u32 V_len
= R_pos
- V_pos
;
16113 char *bits_pos
= strchr (R_pos
, '*');
16115 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16117 u32 R_len
= bits_pos
- R_pos
;
16121 char *P_pos
= strchr (bits_pos
, '*');
16123 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16125 u32 bits_len
= P_pos
- bits_pos
;
16129 char *enc_md_pos
= strchr (P_pos
, '*');
16131 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16133 u32 P_len
= enc_md_pos
- P_pos
;
16137 char *id_len_pos
= strchr (enc_md_pos
, '*');
16139 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16141 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16145 char *id_buf_pos
= strchr (id_len_pos
, '*');
16147 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16149 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16153 char *u_len_pos
= strchr (id_buf_pos
, '*');
16155 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16157 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16159 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16163 char *u_buf_pos
= strchr (u_len_pos
, '*');
16165 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16167 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16171 char *o_len_pos
= strchr (u_buf_pos
, '*');
16173 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16175 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16177 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16181 char *o_buf_pos
= strchr (o_len_pos
, '*');
16183 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16185 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16189 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;
16191 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16195 const int V
= atoi (V_pos
);
16196 const int R
= atoi (R_pos
);
16197 const int P
= atoi (P_pos
);
16199 if (V
!= 1) return (PARSER_SALT_VALUE
);
16200 if (R
!= 2) return (PARSER_SALT_VALUE
);
16202 const int enc_md
= atoi (enc_md_pos
);
16204 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16206 const int id_len
= atoi (id_len_pos
);
16207 const int u_len
= atoi (u_len_pos
);
16208 const int o_len
= atoi (o_len_pos
);
16210 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16211 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16212 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16214 const int bits
= atoi (bits_pos
);
16216 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16218 // copy data to esalt
16224 pdf
->enc_md
= enc_md
;
16226 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16227 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16228 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16229 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16230 pdf
->id_len
= id_len
;
16232 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16233 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16234 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16235 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16236 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16237 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16238 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16239 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16240 pdf
->u_len
= u_len
;
16242 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16243 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16244 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16245 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16246 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16247 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16248 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16249 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16250 pdf
->o_len
= o_len
;
16252 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16253 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16254 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16255 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16257 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16258 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16259 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16260 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16261 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16262 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16263 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16264 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16266 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16267 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16268 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16269 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16270 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16271 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16272 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16273 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16275 // we use ID for salt, maybe needs to change, we will see...
16277 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16278 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16279 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16280 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16281 salt
->salt_len
= pdf
->id_len
;
16283 digest
[0] = pdf
->u_buf
[0];
16284 digest
[1] = pdf
->u_buf
[1];
16285 digest
[2] = pdf
->u_buf
[2];
16286 digest
[3] = pdf
->u_buf
[3];
16288 return (PARSER_OK
);
16291 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16293 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16296 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16298 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16300 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16302 u32
*digest
= (u32
*) hash_buf
->digest
;
16304 salt_t
*salt
= hash_buf
->salt
;
16306 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16312 char *V_pos
= input_buf
+ 5;
16314 char *R_pos
= strchr (V_pos
, '*');
16316 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16318 u32 V_len
= R_pos
- V_pos
;
16322 char *bits_pos
= strchr (R_pos
, '*');
16324 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16326 u32 R_len
= bits_pos
- R_pos
;
16330 char *P_pos
= strchr (bits_pos
, '*');
16332 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16334 u32 bits_len
= P_pos
- bits_pos
;
16338 char *enc_md_pos
= strchr (P_pos
, '*');
16340 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16342 u32 P_len
= enc_md_pos
- P_pos
;
16346 char *id_len_pos
= strchr (enc_md_pos
, '*');
16348 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16350 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16354 char *id_buf_pos
= strchr (id_len_pos
, '*');
16356 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16358 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16362 char *u_len_pos
= strchr (id_buf_pos
, '*');
16364 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16366 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16368 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16372 char *u_buf_pos
= strchr (u_len_pos
, '*');
16374 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16376 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16380 char *o_len_pos
= strchr (u_buf_pos
, '*');
16382 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16384 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16386 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16390 char *o_buf_pos
= strchr (o_len_pos
, '*');
16392 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16394 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16398 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16400 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16402 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16404 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16408 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;
16410 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16414 const int V
= atoi (V_pos
);
16415 const int R
= atoi (R_pos
);
16416 const int P
= atoi (P_pos
);
16418 if (V
!= 1) return (PARSER_SALT_VALUE
);
16419 if (R
!= 2) return (PARSER_SALT_VALUE
);
16421 const int enc_md
= atoi (enc_md_pos
);
16423 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16425 const int id_len
= atoi (id_len_pos
);
16426 const int u_len
= atoi (u_len_pos
);
16427 const int o_len
= atoi (o_len_pos
);
16429 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16430 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16431 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16433 const int bits
= atoi (bits_pos
);
16435 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16437 // copy data to esalt
16443 pdf
->enc_md
= enc_md
;
16445 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16446 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16447 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16448 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16449 pdf
->id_len
= id_len
;
16451 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16452 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16453 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16454 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16455 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16456 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16457 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16458 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16459 pdf
->u_len
= u_len
;
16461 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16462 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16463 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16464 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16465 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16466 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16467 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16468 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16469 pdf
->o_len
= o_len
;
16471 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16472 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16473 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16474 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16476 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16477 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16478 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16479 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16480 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16481 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16482 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16483 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16485 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16486 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16487 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16488 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16489 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16490 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16491 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16492 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16494 pdf
->rc4key
[1] = 0;
16495 pdf
->rc4key
[0] = 0;
16497 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16498 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16499 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16500 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16501 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16502 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16503 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16504 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16505 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16506 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16508 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16509 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16511 // we use ID for salt, maybe needs to change, we will see...
16513 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16514 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16515 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16516 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16517 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16518 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16519 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16520 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16521 salt
->salt_len
= pdf
->id_len
+ 16;
16523 digest
[0] = pdf
->rc4key
[0];
16524 digest
[1] = pdf
->rc4key
[1];
16528 return (PARSER_OK
);
16531 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16533 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16535 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16537 u32
*digest
= (u32
*) hash_buf
->digest
;
16539 salt_t
*salt
= hash_buf
->salt
;
16541 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16547 char *V_pos
= input_buf
+ 5;
16549 char *R_pos
= strchr (V_pos
, '*');
16551 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16553 u32 V_len
= R_pos
- V_pos
;
16557 char *bits_pos
= strchr (R_pos
, '*');
16559 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16561 u32 R_len
= bits_pos
- R_pos
;
16565 char *P_pos
= strchr (bits_pos
, '*');
16567 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16569 u32 bits_len
= P_pos
- bits_pos
;
16573 char *enc_md_pos
= strchr (P_pos
, '*');
16575 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16577 u32 P_len
= enc_md_pos
- P_pos
;
16581 char *id_len_pos
= strchr (enc_md_pos
, '*');
16583 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16585 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16589 char *id_buf_pos
= strchr (id_len_pos
, '*');
16591 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16593 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16597 char *u_len_pos
= strchr (id_buf_pos
, '*');
16599 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16601 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16603 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16607 char *u_buf_pos
= strchr (u_len_pos
, '*');
16609 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16611 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16615 char *o_len_pos
= strchr (u_buf_pos
, '*');
16617 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16619 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16621 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16625 char *o_buf_pos
= strchr (o_len_pos
, '*');
16627 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16629 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16633 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;
16635 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16639 const int V
= atoi (V_pos
);
16640 const int R
= atoi (R_pos
);
16641 const int P
= atoi (P_pos
);
16645 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16646 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16648 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16650 const int id_len
= atoi (id_len_pos
);
16651 const int u_len
= atoi (u_len_pos
);
16652 const int o_len
= atoi (o_len_pos
);
16654 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16656 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16657 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16659 const int bits
= atoi (bits_pos
);
16661 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16667 enc_md
= atoi (enc_md_pos
);
16670 // copy data to esalt
16676 pdf
->enc_md
= enc_md
;
16678 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16679 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16680 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16681 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16685 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
16686 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
16687 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
16688 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
16691 pdf
->id_len
= id_len
;
16693 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16694 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16695 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16696 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16697 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16698 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16699 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16700 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16701 pdf
->u_len
= u_len
;
16703 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16704 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16705 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16706 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16707 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16708 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16709 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16710 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16711 pdf
->o_len
= o_len
;
16713 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16714 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16715 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16716 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16720 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16721 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16722 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16723 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16726 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16727 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16728 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16729 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16730 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16731 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16732 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16733 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16735 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16736 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16737 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16738 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16739 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16740 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16741 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16742 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16744 // precompute rc4 data for later use
16760 uint salt_pc_block
[32] = { 0 };
16762 char *salt_pc_ptr
= (char *) salt_pc_block
;
16764 memcpy (salt_pc_ptr
, padding
, 32);
16765 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16767 uint salt_pc_digest
[4] = { 0 };
16769 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16771 pdf
->rc4data
[0] = salt_pc_digest
[0];
16772 pdf
->rc4data
[1] = salt_pc_digest
[1];
16774 // we use ID for salt, maybe needs to change, we will see...
16776 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16777 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16778 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16779 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16780 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16781 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16782 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16783 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16784 salt
->salt_len
= pdf
->id_len
+ 16;
16786 salt
->salt_iter
= ROUNDS_PDF14
;
16788 digest
[0] = pdf
->u_buf
[0];
16789 digest
[1] = pdf
->u_buf
[1];
16793 return (PARSER_OK
);
16796 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16798 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16800 if (ret
!= PARSER_OK
)
16805 u32
*digest
= (u32
*) hash_buf
->digest
;
16807 salt_t
*salt
= hash_buf
->salt
;
16809 digest
[0] -= SHA256M_A
;
16810 digest
[1] -= SHA256M_B
;
16811 digest
[2] -= SHA256M_C
;
16812 digest
[3] -= SHA256M_D
;
16813 digest
[4] -= SHA256M_E
;
16814 digest
[5] -= SHA256M_F
;
16815 digest
[6] -= SHA256M_G
;
16816 digest
[7] -= SHA256M_H
;
16818 salt
->salt_buf
[2] = 0x80;
16820 return (PARSER_OK
);
16823 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16825 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16827 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16829 u32
*digest
= (u32
*) hash_buf
->digest
;
16831 salt_t
*salt
= hash_buf
->salt
;
16833 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16839 char *V_pos
= input_buf
+ 5;
16841 char *R_pos
= strchr (V_pos
, '*');
16843 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16845 u32 V_len
= R_pos
- V_pos
;
16849 char *bits_pos
= strchr (R_pos
, '*');
16851 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16853 u32 R_len
= bits_pos
- R_pos
;
16857 char *P_pos
= strchr (bits_pos
, '*');
16859 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16861 u32 bits_len
= P_pos
- bits_pos
;
16865 char *enc_md_pos
= strchr (P_pos
, '*');
16867 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16869 u32 P_len
= enc_md_pos
- P_pos
;
16873 char *id_len_pos
= strchr (enc_md_pos
, '*');
16875 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16877 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16881 char *id_buf_pos
= strchr (id_len_pos
, '*');
16883 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16885 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16889 char *u_len_pos
= strchr (id_buf_pos
, '*');
16891 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16893 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16897 char *u_buf_pos
= strchr (u_len_pos
, '*');
16899 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16901 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16905 char *o_len_pos
= strchr (u_buf_pos
, '*');
16907 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16909 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16913 char *o_buf_pos
= strchr (o_len_pos
, '*');
16915 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16917 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16921 char *last
= strchr (o_buf_pos
, '*');
16923 if (last
== NULL
) last
= input_buf
+ input_len
;
16925 u32 o_buf_len
= last
- o_buf_pos
;
16929 const int V
= atoi (V_pos
);
16930 const int R
= atoi (R_pos
);
16934 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
16935 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
16937 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16939 const int bits
= atoi (bits_pos
);
16941 if (bits
!= 256) return (PARSER_SALT_VALUE
);
16943 int enc_md
= atoi (enc_md_pos
);
16945 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
16947 const uint id_len
= atoi (id_len_pos
);
16948 const uint u_len
= atoi (u_len_pos
);
16949 const uint o_len
= atoi (o_len_pos
);
16951 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
16952 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
16953 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
16954 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
16955 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
16956 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
16957 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
16958 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
16960 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
16961 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
16962 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
16964 // copy data to esalt
16966 if (u_len
< 40) return (PARSER_SALT_VALUE
);
16968 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
16970 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
16973 salt
->salt_buf
[0] = pdf
->u_buf
[8];
16974 salt
->salt_buf
[1] = pdf
->u_buf
[9];
16976 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16977 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16979 salt
->salt_len
= 8;
16980 salt
->salt_iter
= ROUNDS_PDF17L8
;
16982 digest
[0] = pdf
->u_buf
[0];
16983 digest
[1] = pdf
->u_buf
[1];
16984 digest
[2] = pdf
->u_buf
[2];
16985 digest
[3] = pdf
->u_buf
[3];
16986 digest
[4] = pdf
->u_buf
[4];
16987 digest
[5] = pdf
->u_buf
[5];
16988 digest
[6] = pdf
->u_buf
[6];
16989 digest
[7] = pdf
->u_buf
[7];
16991 return (PARSER_OK
);
16994 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16996 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
16998 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17000 u32
*digest
= (u32
*) hash_buf
->digest
;
17002 salt_t
*salt
= hash_buf
->salt
;
17004 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17012 char *iter_pos
= input_buf
+ 7;
17014 u32 iter
= atoi (iter_pos
);
17016 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17017 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17019 // first is *raw* salt
17021 char *salt_pos
= strchr (iter_pos
, ':');
17023 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17027 char *hash_pos
= strchr (salt_pos
, ':');
17029 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17031 u32 salt_len
= hash_pos
- salt_pos
;
17033 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17037 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17039 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17043 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17045 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17047 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17049 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17050 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17052 salt
->salt_len
= salt_len
;
17053 salt
->salt_iter
= iter
- 1;
17057 u8 tmp_buf
[100] = { 0 };
17059 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17061 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17063 memcpy (digest
, tmp_buf
, 16);
17065 digest
[0] = byte_swap_32 (digest
[0]);
17066 digest
[1] = byte_swap_32 (digest
[1]);
17067 digest
[2] = byte_swap_32 (digest
[2]);
17068 digest
[3] = byte_swap_32 (digest
[3]);
17070 // add some stuff to normal salt to make sorted happy
17072 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17073 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17074 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17075 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17076 salt
->salt_buf
[4] = salt
->salt_iter
;
17078 return (PARSER_OK
);
17081 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17083 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17085 u32
*digest
= (u32
*) hash_buf
->digest
;
17087 salt_t
*salt
= hash_buf
->salt
;
17089 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17090 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17091 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17092 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17094 digest
[0] = byte_swap_32 (digest
[0]);
17095 digest
[1] = byte_swap_32 (digest
[1]);
17096 digest
[2] = byte_swap_32 (digest
[2]);
17097 digest
[3] = byte_swap_32 (digest
[3]);
17099 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17101 uint salt_len
= input_len
- 32 - 1;
17103 char *salt_buf
= input_buf
+ 32 + 1;
17105 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17107 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17109 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17111 salt
->salt_len
= salt_len
;
17113 return (PARSER_OK
);
17116 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17118 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17120 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17122 u32
*digest
= (u32
*) hash_buf
->digest
;
17124 salt_t
*salt
= hash_buf
->salt
;
17126 char *user_pos
= input_buf
+ 10;
17128 char *salt_pos
= strchr (user_pos
, '*');
17130 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17134 char *hash_pos
= strchr (salt_pos
, '*');
17138 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17140 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17142 uint user_len
= salt_pos
- user_pos
- 1;
17144 uint salt_len
= hash_pos
- salt_pos
- 1;
17146 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17152 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17153 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17154 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17155 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17157 digest
[0] = byte_swap_32 (digest
[0]);
17158 digest
[1] = byte_swap_32 (digest
[1]);
17159 digest
[2] = byte_swap_32 (digest
[2]);
17160 digest
[3] = byte_swap_32 (digest
[3]);
17162 digest
[0] -= MD5M_A
;
17163 digest
[1] -= MD5M_B
;
17164 digest
[2] -= MD5M_C
;
17165 digest
[3] -= MD5M_D
;
17171 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17173 // first 4 bytes are the "challenge"
17175 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17176 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17177 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17178 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17180 // append the user name
17182 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17184 salt
->salt_len
= 4 + user_len
;
17186 return (PARSER_OK
);
17189 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17191 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17193 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17195 u32
*digest
= (u32
*) hash_buf
->digest
;
17197 salt_t
*salt
= hash_buf
->salt
;
17199 char *salt_pos
= input_buf
+ 9;
17201 char *hash_pos
= strchr (salt_pos
, '*');
17203 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17207 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17209 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17211 uint salt_len
= hash_pos
- salt_pos
- 1;
17213 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17219 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17220 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17221 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17222 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17223 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17229 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17231 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17233 salt
->salt_len
= salt_len
;
17235 return (PARSER_OK
);
17238 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17240 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17242 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17244 u32
*digest
= (u32
*) hash_buf
->digest
;
17246 salt_t
*salt
= hash_buf
->salt
;
17248 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17254 char *cry_master_len_pos
= input_buf
+ 9;
17256 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17258 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17260 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17262 cry_master_buf_pos
++;
17264 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17266 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17268 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17270 cry_salt_len_pos
++;
17272 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17274 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17276 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17278 cry_salt_buf_pos
++;
17280 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17282 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17284 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17288 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17290 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17292 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17296 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17298 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17300 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17304 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17306 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17308 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17310 public_key_len_pos
++;
17312 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17314 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17316 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17318 public_key_buf_pos
++;
17320 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;
17322 const uint cry_master_len
= atoi (cry_master_len_pos
);
17323 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17324 const uint ckey_len
= atoi (ckey_len_pos
);
17325 const uint public_key_len
= atoi (public_key_len_pos
);
17327 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17328 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17329 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17330 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17332 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17334 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17336 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17339 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17341 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17343 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17346 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17348 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17350 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17353 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17354 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17355 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17358 * store digest (should be unique enought, hopefully)
17361 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17362 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17363 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17364 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17370 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17372 const uint cry_rounds
= atoi (cry_rounds_pos
);
17374 salt
->salt_iter
= cry_rounds
- 1;
17376 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17378 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17380 salt
->salt_len
= salt_len
;
17382 return (PARSER_OK
);
17385 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17387 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17389 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17391 u32
*digest
= (u32
*) hash_buf
->digest
;
17393 salt_t
*salt
= hash_buf
->salt
;
17395 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17397 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17399 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17401 memcpy (temp_input_buf
, input_buf
, input_len
);
17405 char *URI_server_pos
= temp_input_buf
+ 6;
17407 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17409 if (URI_client_pos
== NULL
)
17411 myfree (temp_input_buf
);
17413 return (PARSER_SEPARATOR_UNMATCHED
);
17416 URI_client_pos
[0] = 0;
17419 uint URI_server_len
= strlen (URI_server_pos
);
17421 if (URI_server_len
> 512)
17423 myfree (temp_input_buf
);
17425 return (PARSER_SALT_LENGTH
);
17430 char *user_pos
= strchr (URI_client_pos
, '*');
17432 if (user_pos
== NULL
)
17434 myfree (temp_input_buf
);
17436 return (PARSER_SEPARATOR_UNMATCHED
);
17442 uint URI_client_len
= strlen (URI_client_pos
);
17444 if (URI_client_len
> 512)
17446 myfree (temp_input_buf
);
17448 return (PARSER_SALT_LENGTH
);
17453 char *realm_pos
= strchr (user_pos
, '*');
17455 if (realm_pos
== NULL
)
17457 myfree (temp_input_buf
);
17459 return (PARSER_SEPARATOR_UNMATCHED
);
17465 uint user_len
= strlen (user_pos
);
17467 if (user_len
> 116)
17469 myfree (temp_input_buf
);
17471 return (PARSER_SALT_LENGTH
);
17476 char *method_pos
= strchr (realm_pos
, '*');
17478 if (method_pos
== NULL
)
17480 myfree (temp_input_buf
);
17482 return (PARSER_SEPARATOR_UNMATCHED
);
17488 uint realm_len
= strlen (realm_pos
);
17490 if (realm_len
> 116)
17492 myfree (temp_input_buf
);
17494 return (PARSER_SALT_LENGTH
);
17499 char *URI_prefix_pos
= strchr (method_pos
, '*');
17501 if (URI_prefix_pos
== NULL
)
17503 myfree (temp_input_buf
);
17505 return (PARSER_SEPARATOR_UNMATCHED
);
17508 URI_prefix_pos
[0] = 0;
17511 uint method_len
= strlen (method_pos
);
17513 if (method_len
> 246)
17515 myfree (temp_input_buf
);
17517 return (PARSER_SALT_LENGTH
);
17522 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17524 if (URI_resource_pos
== NULL
)
17526 myfree (temp_input_buf
);
17528 return (PARSER_SEPARATOR_UNMATCHED
);
17531 URI_resource_pos
[0] = 0;
17532 URI_resource_pos
++;
17534 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17536 if (URI_prefix_len
> 245)
17538 myfree (temp_input_buf
);
17540 return (PARSER_SALT_LENGTH
);
17545 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17547 if (URI_suffix_pos
== NULL
)
17549 myfree (temp_input_buf
);
17551 return (PARSER_SEPARATOR_UNMATCHED
);
17554 URI_suffix_pos
[0] = 0;
17557 uint URI_resource_len
= strlen (URI_resource_pos
);
17559 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17561 myfree (temp_input_buf
);
17563 return (PARSER_SALT_LENGTH
);
17568 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17570 if (nonce_pos
== NULL
)
17572 myfree (temp_input_buf
);
17574 return (PARSER_SEPARATOR_UNMATCHED
);
17580 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17582 if (URI_suffix_len
> 245)
17584 myfree (temp_input_buf
);
17586 return (PARSER_SALT_LENGTH
);
17591 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17593 if (nonce_client_pos
== NULL
)
17595 myfree (temp_input_buf
);
17597 return (PARSER_SEPARATOR_UNMATCHED
);
17600 nonce_client_pos
[0] = 0;
17601 nonce_client_pos
++;
17603 uint nonce_len
= strlen (nonce_pos
);
17605 if (nonce_len
< 1 || nonce_len
> 50)
17607 myfree (temp_input_buf
);
17609 return (PARSER_SALT_LENGTH
);
17614 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17616 if (nonce_count_pos
== NULL
)
17618 myfree (temp_input_buf
);
17620 return (PARSER_SEPARATOR_UNMATCHED
);
17623 nonce_count_pos
[0] = 0;
17626 uint nonce_client_len
= strlen (nonce_client_pos
);
17628 if (nonce_client_len
> 50)
17630 myfree (temp_input_buf
);
17632 return (PARSER_SALT_LENGTH
);
17637 char *qop_pos
= strchr (nonce_count_pos
, '*');
17639 if (qop_pos
== NULL
)
17641 myfree (temp_input_buf
);
17643 return (PARSER_SEPARATOR_UNMATCHED
);
17649 uint nonce_count_len
= strlen (nonce_count_pos
);
17651 if (nonce_count_len
> 50)
17653 myfree (temp_input_buf
);
17655 return (PARSER_SALT_LENGTH
);
17660 char *directive_pos
= strchr (qop_pos
, '*');
17662 if (directive_pos
== NULL
)
17664 myfree (temp_input_buf
);
17666 return (PARSER_SEPARATOR_UNMATCHED
);
17669 directive_pos
[0] = 0;
17672 uint qop_len
= strlen (qop_pos
);
17676 myfree (temp_input_buf
);
17678 return (PARSER_SALT_LENGTH
);
17683 char *digest_pos
= strchr (directive_pos
, '*');
17685 if (digest_pos
== NULL
)
17687 myfree (temp_input_buf
);
17689 return (PARSER_SEPARATOR_UNMATCHED
);
17695 uint directive_len
= strlen (directive_pos
);
17697 if (directive_len
!= 3)
17699 myfree (temp_input_buf
);
17701 return (PARSER_SALT_LENGTH
);
17704 if (memcmp (directive_pos
, "MD5", 3))
17706 log_info ("ERROR: only the MD5 directive is currently supported\n");
17708 myfree (temp_input_buf
);
17710 return (PARSER_SIP_AUTH_DIRECTIVE
);
17714 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17719 uint md5_max_len
= 4 * 64;
17721 uint md5_remaining_len
= md5_max_len
;
17723 uint tmp_md5_buf
[64] = { 0 };
17725 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17727 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17729 md5_len
+= method_len
+ 1;
17730 tmp_md5_ptr
+= method_len
+ 1;
17732 if (URI_prefix_len
> 0)
17734 md5_remaining_len
= md5_max_len
- md5_len
;
17736 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17738 md5_len
+= URI_prefix_len
+ 1;
17739 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17742 md5_remaining_len
= md5_max_len
- md5_len
;
17744 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17746 md5_len
+= URI_resource_len
;
17747 tmp_md5_ptr
+= URI_resource_len
;
17749 if (URI_suffix_len
> 0)
17751 md5_remaining_len
= md5_max_len
- md5_len
;
17753 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17755 md5_len
+= 1 + URI_suffix_len
;
17758 uint tmp_digest
[4] = { 0 };
17760 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17762 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17763 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17764 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17765 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17771 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17773 uint esalt_len
= 0;
17775 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17777 // there are 2 possibilities for the esalt:
17779 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17781 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17783 if (esalt_len
> max_esalt_len
)
17785 myfree (temp_input_buf
);
17787 return (PARSER_SALT_LENGTH
);
17790 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17802 esalt_len
= 1 + nonce_len
+ 1 + 32;
17804 if (esalt_len
> max_esalt_len
)
17806 myfree (temp_input_buf
);
17808 return (PARSER_SALT_LENGTH
);
17811 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17819 // add 0x80 to esalt
17821 esalt_buf_ptr
[esalt_len
] = 0x80;
17823 sip
->esalt_len
= esalt_len
;
17829 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17831 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17833 uint max_salt_len
= 119;
17835 if (salt_len
> max_salt_len
)
17837 myfree (temp_input_buf
);
17839 return (PARSER_SALT_LENGTH
);
17842 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17844 sip
->salt_len
= salt_len
;
17847 * fake salt (for sorting)
17850 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17854 uint fake_salt_len
= salt_len
;
17856 if (fake_salt_len
> max_salt_len
)
17858 fake_salt_len
= max_salt_len
;
17861 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17863 salt
->salt_len
= fake_salt_len
;
17869 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
17870 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
17871 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
17872 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
17874 digest
[0] = byte_swap_32 (digest
[0]);
17875 digest
[1] = byte_swap_32 (digest
[1]);
17876 digest
[2] = byte_swap_32 (digest
[2]);
17877 digest
[3] = byte_swap_32 (digest
[3]);
17879 myfree (temp_input_buf
);
17881 return (PARSER_OK
);
17884 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17886 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17888 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17890 u32
*digest
= (u32
*) hash_buf
->digest
;
17892 salt_t
*salt
= hash_buf
->salt
;
17896 char *digest_pos
= input_buf
;
17898 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
17905 char *salt_buf
= input_buf
+ 8 + 1;
17909 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17911 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17913 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17915 salt
->salt_len
= salt_len
;
17917 return (PARSER_OK
);
17920 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17922 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
17924 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17926 u32
*digest
= (u32
*) hash_buf
->digest
;
17928 salt_t
*salt
= hash_buf
->salt
;
17930 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
17936 char *p_buf_pos
= input_buf
+ 4;
17938 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
17940 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17942 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
17944 NumCyclesPower_pos
++;
17946 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
17948 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17950 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
17954 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
17956 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17958 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
17962 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
17964 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17966 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
17970 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
17972 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17974 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
17978 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
17980 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17982 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
17986 char *data_len_pos
= strchr (crc_buf_pos
, '$');
17988 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17990 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
17994 char *unpack_size_pos
= strchr (data_len_pos
, '$');
17996 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17998 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18002 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18004 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18006 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18010 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;
18012 const uint iter
= atoi (NumCyclesPower_pos
);
18013 const uint crc
= atoi (crc_buf_pos
);
18014 const uint p_buf
= atoi (p_buf_pos
);
18015 const uint salt_len
= atoi (salt_len_pos
);
18016 const uint iv_len
= atoi (iv_len_pos
);
18017 const uint unpack_size
= atoi (unpack_size_pos
);
18018 const uint data_len
= atoi (data_len_pos
);
18024 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18025 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18027 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18029 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18031 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18037 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18038 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18039 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18040 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18042 seven_zip
->iv_len
= iv_len
;
18044 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18046 seven_zip
->salt_len
= 0;
18048 seven_zip
->crc
= crc
;
18050 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18052 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18054 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18057 seven_zip
->data_len
= data_len
;
18059 seven_zip
->unpack_size
= unpack_size
;
18063 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18064 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18065 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18066 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18068 salt
->salt_len
= 16;
18070 salt
->salt_sign
[0] = iter
;
18072 salt
->salt_iter
= 1 << iter
;
18083 return (PARSER_OK
);
18086 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18088 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18090 u32
*digest
= (u32
*) hash_buf
->digest
;
18092 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18093 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18094 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18095 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18096 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18097 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18098 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18099 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18101 digest
[0] = byte_swap_32 (digest
[0]);
18102 digest
[1] = byte_swap_32 (digest
[1]);
18103 digest
[2] = byte_swap_32 (digest
[2]);
18104 digest
[3] = byte_swap_32 (digest
[3]);
18105 digest
[4] = byte_swap_32 (digest
[4]);
18106 digest
[5] = byte_swap_32 (digest
[5]);
18107 digest
[6] = byte_swap_32 (digest
[6]);
18108 digest
[7] = byte_swap_32 (digest
[7]);
18110 return (PARSER_OK
);
18113 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18115 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18117 u32
*digest
= (u32
*) hash_buf
->digest
;
18119 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18120 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18121 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18122 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18123 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18124 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18125 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18126 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18127 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18128 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18129 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18130 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18131 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18132 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18133 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18134 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18136 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18137 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18138 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18139 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18140 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18141 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18142 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18143 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18144 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18145 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18146 digest
[10] = byte_swap_32 (digest
[10]);
18147 digest
[11] = byte_swap_32 (digest
[11]);
18148 digest
[12] = byte_swap_32 (digest
[12]);
18149 digest
[13] = byte_swap_32 (digest
[13]);
18150 digest
[14] = byte_swap_32 (digest
[14]);
18151 digest
[15] = byte_swap_32 (digest
[15]);
18153 return (PARSER_OK
);
18156 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18158 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18160 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18162 u32
*digest
= (u32
*) hash_buf
->digest
;
18164 salt_t
*salt
= hash_buf
->salt
;
18166 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18174 char *iter_pos
= input_buf
+ 4;
18176 u32 iter
= atoi (iter_pos
);
18178 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18179 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18181 // first is *raw* salt
18183 char *salt_pos
= strchr (iter_pos
, ':');
18185 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18189 char *hash_pos
= strchr (salt_pos
, ':');
18191 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18193 u32 salt_len
= hash_pos
- salt_pos
;
18195 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18199 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18201 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18205 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18207 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18209 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18211 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18212 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18214 salt
->salt_len
= salt_len
;
18215 salt
->salt_iter
= iter
- 1;
18219 u8 tmp_buf
[100] = { 0 };
18221 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18223 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18225 memcpy (digest
, tmp_buf
, 16);
18227 // add some stuff to normal salt to make sorted happy
18229 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18230 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18231 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18232 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18233 salt
->salt_buf
[4] = salt
->salt_iter
;
18235 return (PARSER_OK
);
18238 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18240 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18242 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18244 u32
*digest
= (u32
*) hash_buf
->digest
;
18246 salt_t
*salt
= hash_buf
->salt
;
18248 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18256 char *iter_pos
= input_buf
+ 5;
18258 u32 iter
= atoi (iter_pos
);
18260 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18261 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18263 // first is *raw* salt
18265 char *salt_pos
= strchr (iter_pos
, ':');
18267 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18271 char *hash_pos
= strchr (salt_pos
, ':');
18273 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18275 u32 salt_len
= hash_pos
- salt_pos
;
18277 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18281 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18283 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18287 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18289 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18291 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18293 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18294 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18296 salt
->salt_len
= salt_len
;
18297 salt
->salt_iter
= iter
- 1;
18301 u8 tmp_buf
[100] = { 0 };
18303 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18305 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18307 memcpy (digest
, tmp_buf
, 16);
18309 digest
[0] = byte_swap_32 (digest
[0]);
18310 digest
[1] = byte_swap_32 (digest
[1]);
18311 digest
[2] = byte_swap_32 (digest
[2]);
18312 digest
[3] = byte_swap_32 (digest
[3]);
18314 // add some stuff to normal salt to make sorted happy
18316 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18317 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18318 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18319 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18320 salt
->salt_buf
[4] = salt
->salt_iter
;
18322 return (PARSER_OK
);
18325 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18327 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18329 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18331 u64
*digest
= (u64
*) hash_buf
->digest
;
18333 salt_t
*salt
= hash_buf
->salt
;
18335 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18343 char *iter_pos
= input_buf
+ 7;
18345 u32 iter
= atoi (iter_pos
);
18347 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18348 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18350 // first is *raw* salt
18352 char *salt_pos
= strchr (iter_pos
, ':');
18354 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18358 char *hash_pos
= strchr (salt_pos
, ':');
18360 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18362 u32 salt_len
= hash_pos
- salt_pos
;
18364 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18368 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18370 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18374 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18376 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18378 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18380 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18381 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18383 salt
->salt_len
= salt_len
;
18384 salt
->salt_iter
= iter
- 1;
18388 u8 tmp_buf
[100] = { 0 };
18390 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18392 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18394 memcpy (digest
, tmp_buf
, 64);
18396 digest
[0] = byte_swap_64 (digest
[0]);
18397 digest
[1] = byte_swap_64 (digest
[1]);
18398 digest
[2] = byte_swap_64 (digest
[2]);
18399 digest
[3] = byte_swap_64 (digest
[3]);
18400 digest
[4] = byte_swap_64 (digest
[4]);
18401 digest
[5] = byte_swap_64 (digest
[5]);
18402 digest
[6] = byte_swap_64 (digest
[6]);
18403 digest
[7] = byte_swap_64 (digest
[7]);
18405 // add some stuff to normal salt to make sorted happy
18407 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18408 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18409 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18410 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18411 salt
->salt_buf
[4] = salt
->salt_iter
;
18413 return (PARSER_OK
);
18416 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18418 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18420 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18422 uint
*digest
= (uint
*) hash_buf
->digest
;
18424 salt_t
*salt
= hash_buf
->salt
;
18430 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18432 char *hash_pos
= strchr (salt_pos
, '$');
18434 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18436 u32 salt_len
= hash_pos
- salt_pos
;
18438 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18442 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18444 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18448 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18449 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18467 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18468 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18470 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18471 salt
->salt_len
= 8;
18473 return (PARSER_OK
);
18476 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18478 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18480 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18482 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18484 if (c19
& 3) return (PARSER_HASH_VALUE
);
18486 salt_t
*salt
= hash_buf
->salt
;
18488 u32
*digest
= (u32
*) hash_buf
->digest
;
18492 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18493 | itoa64_to_int (input_buf
[2]) << 6
18494 | itoa64_to_int (input_buf
[3]) << 12
18495 | itoa64_to_int (input_buf
[4]) << 18;
18499 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18500 | itoa64_to_int (input_buf
[6]) << 6
18501 | itoa64_to_int (input_buf
[7]) << 12
18502 | itoa64_to_int (input_buf
[8]) << 18;
18504 salt
->salt_len
= 4;
18506 u8 tmp_buf
[100] = { 0 };
18508 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18510 memcpy (digest
, tmp_buf
, 8);
18514 IP (digest
[0], digest
[1], tt
);
18516 digest
[0] = rotr32 (digest
[0], 31);
18517 digest
[1] = rotr32 (digest
[1], 31);
18521 return (PARSER_OK
);
18524 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18526 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18528 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18530 u32
*digest
= (u32
*) hash_buf
->digest
;
18532 salt_t
*salt
= hash_buf
->salt
;
18538 char *type_pos
= input_buf
+ 6 + 1;
18540 char *salt_pos
= strchr (type_pos
, '*');
18542 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18544 u32 type_len
= salt_pos
- type_pos
;
18546 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18550 char *crypted_pos
= strchr (salt_pos
, '*');
18552 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18554 u32 salt_len
= crypted_pos
- salt_pos
;
18556 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18560 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18562 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18568 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18569 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18571 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18572 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18574 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18575 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18576 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18577 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18579 salt
->salt_len
= 24;
18580 salt
->salt_iter
= ROUNDS_RAR3
;
18582 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18583 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18585 digest
[0] = 0xc43d7b00;
18586 digest
[1] = 0x40070000;
18590 return (PARSER_OK
);
18593 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18595 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18597 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18599 u32
*digest
= (u32
*) hash_buf
->digest
;
18601 salt_t
*salt
= hash_buf
->salt
;
18603 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18609 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18611 char *param1_pos
= strchr (param0_pos
, '$');
18613 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18615 u32 param0_len
= param1_pos
- param0_pos
;
18619 char *param2_pos
= strchr (param1_pos
, '$');
18621 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18623 u32 param1_len
= param2_pos
- param1_pos
;
18627 char *param3_pos
= strchr (param2_pos
, '$');
18629 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18631 u32 param2_len
= param3_pos
- param2_pos
;
18635 char *param4_pos
= strchr (param3_pos
, '$');
18637 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18639 u32 param3_len
= param4_pos
- param3_pos
;
18643 char *param5_pos
= strchr (param4_pos
, '$');
18645 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18647 u32 param4_len
= param5_pos
- param4_pos
;
18651 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18653 char *salt_buf
= param1_pos
;
18654 char *iv
= param3_pos
;
18655 char *pswcheck
= param5_pos
;
18657 const uint salt_len
= atoi (param0_pos
);
18658 const uint iterations
= atoi (param2_pos
);
18659 const uint pswcheck_len
= atoi (param4_pos
);
18665 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18666 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18667 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18669 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18670 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18671 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18677 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18678 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18679 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18680 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
18682 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
18683 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
18684 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
18685 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
18687 salt
->salt_len
= 16;
18689 salt
->salt_sign
[0] = iterations
;
18691 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18697 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
18698 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
18702 return (PARSER_OK
);
18705 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18707 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
18709 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18711 u32
*digest
= (u32
*) hash_buf
->digest
;
18713 salt_t
*salt
= hash_buf
->salt
;
18715 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
18722 char *account_pos
= input_buf
+ 11 + 1;
18728 if (account_pos
[0] == '*')
18732 data_pos
= strchr (account_pos
, '*');
18737 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18739 uint account_len
= data_pos
- account_pos
+ 1;
18741 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
18746 data_len
= input_len
- 11 - 1 - account_len
- 2;
18748 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
18752 /* assume $krb5tgs$23$checksum$edata2 */
18753 data_pos
= account_pos
;
18755 memcpy (krb5tgs
->account_info
, "**", 3);
18757 data_len
= input_len
- 11 - 1 - 1;
18760 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
18762 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
18764 for (uint i
= 0; i
< 16 * 2; i
+= 2)
18766 const char p0
= data_pos
[i
+ 0];
18767 const char p1
= data_pos
[i
+ 1];
18769 *checksum_ptr
++ = hex_convert (p1
) << 0
18770 | hex_convert (p0
) << 4;
18773 char *edata_ptr
= (char *) krb5tgs
->edata2
;
18776 for (uint i
= 16 * 2 + 1; i
< input_len
; i
+= 2)
18778 const char p0
= data_pos
[i
+ 0];
18779 const char p1
= data_pos
[i
+ 1];
18780 *edata_ptr
++ = hex_convert (p1
) << 0
18781 | hex_convert (p0
) << 4;
18784 krb5tgs
->edata2_len
= strlen(edata_ptr
- input_len
)/(2 * 4);
18786 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
18787 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
18788 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
18789 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
18791 salt
->salt_len
= 32;
18793 digest
[0] = krb5tgs
->checksum
[0];
18794 digest
[1] = krb5tgs
->checksum
[1];
18795 digest
[2] = krb5tgs
->checksum
[2];
18796 digest
[3] = krb5tgs
->checksum
[3];
18798 return (PARSER_OK
);
18801 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18803 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18805 u32
*digest
= (u32
*) hash_buf
->digest
;
18807 salt_t
*salt
= hash_buf
->salt
;
18809 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18810 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18811 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18812 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18813 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18814 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18815 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18816 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18818 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18820 uint salt_len
= input_len
- 64 - 1;
18822 char *salt_buf
= input_buf
+ 64 + 1;
18824 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18826 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18828 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18830 salt
->salt_len
= salt_len
;
18833 * we can precompute the first sha256 transform
18836 uint w
[16] = { 0 };
18838 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18839 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18840 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18841 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18842 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18843 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18844 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18845 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18846 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18847 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18848 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18849 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18850 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18851 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18852 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18853 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18855 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
18857 sha256_64 (w
, pc256
);
18859 salt
->salt_buf_pc
[0] = pc256
[0];
18860 salt
->salt_buf_pc
[1] = pc256
[1];
18861 salt
->salt_buf_pc
[2] = pc256
[2];
18862 salt
->salt_buf_pc
[3] = pc256
[3];
18863 salt
->salt_buf_pc
[4] = pc256
[4];
18864 salt
->salt_buf_pc
[5] = pc256
[5];
18865 salt
->salt_buf_pc
[6] = pc256
[6];
18866 salt
->salt_buf_pc
[7] = pc256
[7];
18868 digest
[0] -= pc256
[0];
18869 digest
[1] -= pc256
[1];
18870 digest
[2] -= pc256
[2];
18871 digest
[3] -= pc256
[3];
18872 digest
[4] -= pc256
[4];
18873 digest
[5] -= pc256
[5];
18874 digest
[6] -= pc256
[6];
18875 digest
[7] -= pc256
[7];
18877 return (PARSER_OK
);
18880 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18882 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18884 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18886 u32
*digest
= (u32
*) hash_buf
->digest
;
18888 salt_t
*salt
= hash_buf
->salt
;
18894 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18896 char *data_buf_pos
= strchr (data_len_pos
, '$');
18898 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18900 u32 data_len_len
= data_buf_pos
- data_len_pos
;
18902 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18903 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18907 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18909 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
18911 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
18913 u32 data_len
= atoi (data_len_pos
);
18915 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
18921 char *salt_pos
= data_buf_pos
;
18923 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18924 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18925 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
18926 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
18928 // this is actually the CT, which is also the hash later (if matched)
18930 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
18931 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
18932 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
18933 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
18935 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
18937 salt
->salt_iter
= 10 - 1;
18943 digest
[0] = salt
->salt_buf
[4];
18944 digest
[1] = salt
->salt_buf
[5];
18945 digest
[2] = salt
->salt_buf
[6];
18946 digest
[3] = salt
->salt_buf
[7];
18948 return (PARSER_OK
);
18951 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18953 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
18955 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18957 u32
*digest
= (u32
*) hash_buf
->digest
;
18959 salt_t
*salt
= hash_buf
->salt
;
18965 char *salt_pos
= input_buf
+ 11 + 1;
18967 char *iter_pos
= strchr (salt_pos
, ',');
18969 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18971 u32 salt_len
= iter_pos
- salt_pos
;
18973 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
18977 char *hash_pos
= strchr (iter_pos
, ',');
18979 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18981 u32 iter_len
= hash_pos
- iter_pos
;
18983 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
18987 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
18989 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
18995 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18996 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18997 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
18998 salt
->salt_buf
[3] = 0x00018000;
19000 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19001 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19002 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
19003 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
19005 salt
->salt_len
= salt_len
/ 2;
19007 salt
->salt_iter
= atoi (iter_pos
) - 1;
19013 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19014 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19015 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19016 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19017 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19018 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19019 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19020 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19022 return (PARSER_OK
);
19025 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19027 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
19029 u32
*digest
= (u32
*) hash_buf
->digest
;
19031 salt_t
*salt
= hash_buf
->salt
;
19037 char *hash_pos
= input_buf
+ 64;
19038 char *salt1_pos
= input_buf
+ 128;
19039 char *salt2_pos
= input_buf
;
19045 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
19046 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
19047 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
19048 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
19050 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
19051 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
19052 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
19053 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
19055 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
19056 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
19057 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
19058 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
19060 salt
->salt_len
= 48;
19062 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
19068 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19069 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19070 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19071 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19072 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19073 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19074 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19075 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19077 return (PARSER_OK
);
19081 * parallel running threads
19086 BOOL WINAPI
sigHandler_default (DWORD sig
)
19090 case CTRL_CLOSE_EVENT
:
19093 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
19094 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
19095 * function otherwise it is too late (e.g. after returning from this function)
19100 SetConsoleCtrlHandler (NULL
, TRUE
);
19107 case CTRL_LOGOFF_EVENT
:
19108 case CTRL_SHUTDOWN_EVENT
:
19112 SetConsoleCtrlHandler (NULL
, TRUE
);
19120 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19124 case CTRL_CLOSE_EVENT
:
19128 SetConsoleCtrlHandler (NULL
, TRUE
);
19135 case CTRL_LOGOFF_EVENT
:
19136 case CTRL_SHUTDOWN_EVENT
:
19140 SetConsoleCtrlHandler (NULL
, TRUE
);
19148 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19150 if (callback
== NULL
)
19152 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19156 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19162 void sigHandler_default (int sig
)
19166 signal (sig
, NULL
);
19169 void sigHandler_benchmark (int sig
)
19173 signal (sig
, NULL
);
19176 void hc_signal (void (callback
) (int))
19178 if (callback
== NULL
) callback
= SIG_DFL
;
19180 signal (SIGINT
, callback
);
19181 signal (SIGTERM
, callback
);
19182 signal (SIGABRT
, callback
);
19187 void status_display ();
19189 void *thread_keypress (void *p
)
19191 int benchmark
= *((int *) p
);
19193 uint quiet
= data
.quiet
;
19197 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19199 int ch
= tty_getchar();
19201 if (ch
== -1) break;
19203 if (ch
== 0) continue;
19209 hc_thread_mutex_lock (mux_display
);
19224 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19225 if (quiet
== 0) fflush (stdout
);
19237 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19238 if (quiet
== 0) fflush (stdout
);
19250 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19251 if (quiet
== 0) fflush (stdout
);
19263 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19264 if (quiet
== 0) fflush (stdout
);
19272 if (benchmark
== 1) break;
19274 stop_at_checkpoint ();
19278 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19279 if (quiet
== 0) fflush (stdout
);
19287 if (benchmark
== 1)
19299 hc_thread_mutex_unlock (mux_display
);
19311 bool class_num (const u8 c
)
19313 return ((c
>= '0') && (c
<= '9'));
19316 bool class_lower (const u8 c
)
19318 return ((c
>= 'a') && (c
<= 'z'));
19321 bool class_upper (const u8 c
)
19323 return ((c
>= 'A') && (c
<= 'Z'));
19326 bool class_alpha (const u8 c
)
19328 return (class_lower (c
) || class_upper (c
));
19331 int conv_ctoi (const u8 c
)
19337 else if (class_upper (c
))
19339 return c
- 'A' + 10;
19345 int conv_itoc (const u8 c
)
19353 return c
+ 'A' - 10;
19363 #define INCR_POS if (++rule_pos == rule_len) return (-1)
19364 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
19365 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
19366 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
19367 #define MAX_KERNEL_RULES 255
19368 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
19369 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19370 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19372 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
19373 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
19374 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19375 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19377 int cpu_rule_to_kernel_rule (char rule_buf
[BUFSIZ
], uint rule_len
, kernel_rule_t
*rule
)
19382 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19384 switch (rule_buf
[rule_pos
])
19390 case RULE_OP_MANGLE_NOOP
:
19391 SET_NAME (rule
, rule_buf
[rule_pos
]);
19394 case RULE_OP_MANGLE_LREST
:
19395 SET_NAME (rule
, rule_buf
[rule_pos
]);
19398 case RULE_OP_MANGLE_UREST
:
19399 SET_NAME (rule
, rule_buf
[rule_pos
]);
19402 case RULE_OP_MANGLE_LREST_UFIRST
:
19403 SET_NAME (rule
, rule_buf
[rule_pos
]);
19406 case RULE_OP_MANGLE_UREST_LFIRST
:
19407 SET_NAME (rule
, rule_buf
[rule_pos
]);
19410 case RULE_OP_MANGLE_TREST
:
19411 SET_NAME (rule
, rule_buf
[rule_pos
]);
19414 case RULE_OP_MANGLE_TOGGLE_AT
:
19415 SET_NAME (rule
, rule_buf
[rule_pos
]);
19416 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19419 case RULE_OP_MANGLE_REVERSE
:
19420 SET_NAME (rule
, rule_buf
[rule_pos
]);
19423 case RULE_OP_MANGLE_DUPEWORD
:
19424 SET_NAME (rule
, rule_buf
[rule_pos
]);
19427 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19428 SET_NAME (rule
, rule_buf
[rule_pos
]);
19429 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19432 case RULE_OP_MANGLE_REFLECT
:
19433 SET_NAME (rule
, rule_buf
[rule_pos
]);
19436 case RULE_OP_MANGLE_ROTATE_LEFT
:
19437 SET_NAME (rule
, rule_buf
[rule_pos
]);
19440 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19441 SET_NAME (rule
, rule_buf
[rule_pos
]);
19444 case RULE_OP_MANGLE_APPEND
:
19445 SET_NAME (rule
, rule_buf
[rule_pos
]);
19446 SET_P0 (rule
, rule_buf
[rule_pos
]);
19449 case RULE_OP_MANGLE_PREPEND
:
19450 SET_NAME (rule
, rule_buf
[rule_pos
]);
19451 SET_P0 (rule
, rule_buf
[rule_pos
]);
19454 case RULE_OP_MANGLE_DELETE_FIRST
:
19455 SET_NAME (rule
, rule_buf
[rule_pos
]);
19458 case RULE_OP_MANGLE_DELETE_LAST
:
19459 SET_NAME (rule
, rule_buf
[rule_pos
]);
19462 case RULE_OP_MANGLE_DELETE_AT
:
19463 SET_NAME (rule
, rule_buf
[rule_pos
]);
19464 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19467 case RULE_OP_MANGLE_EXTRACT
:
19468 SET_NAME (rule
, rule_buf
[rule_pos
]);
19469 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19470 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19473 case RULE_OP_MANGLE_OMIT
:
19474 SET_NAME (rule
, rule_buf
[rule_pos
]);
19475 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19476 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19479 case RULE_OP_MANGLE_INSERT
:
19480 SET_NAME (rule
, rule_buf
[rule_pos
]);
19481 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19482 SET_P1 (rule
, rule_buf
[rule_pos
]);
19485 case RULE_OP_MANGLE_OVERSTRIKE
:
19486 SET_NAME (rule
, rule_buf
[rule_pos
]);
19487 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19488 SET_P1 (rule
, rule_buf
[rule_pos
]);
19491 case RULE_OP_MANGLE_TRUNCATE_AT
:
19492 SET_NAME (rule
, rule_buf
[rule_pos
]);
19493 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19496 case RULE_OP_MANGLE_REPLACE
:
19497 SET_NAME (rule
, rule_buf
[rule_pos
]);
19498 SET_P0 (rule
, rule_buf
[rule_pos
]);
19499 SET_P1 (rule
, rule_buf
[rule_pos
]);
19502 case RULE_OP_MANGLE_PURGECHAR
:
19506 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19510 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19511 SET_NAME (rule
, rule_buf
[rule_pos
]);
19512 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19515 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19516 SET_NAME (rule
, rule_buf
[rule_pos
]);
19517 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19520 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19521 SET_NAME (rule
, rule_buf
[rule_pos
]);
19524 case RULE_OP_MANGLE_SWITCH_FIRST
:
19525 SET_NAME (rule
, rule_buf
[rule_pos
]);
19528 case RULE_OP_MANGLE_SWITCH_LAST
:
19529 SET_NAME (rule
, rule_buf
[rule_pos
]);
19532 case RULE_OP_MANGLE_SWITCH_AT
:
19533 SET_NAME (rule
, rule_buf
[rule_pos
]);
19534 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19535 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19538 case RULE_OP_MANGLE_CHR_SHIFTL
:
19539 SET_NAME (rule
, rule_buf
[rule_pos
]);
19540 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19543 case RULE_OP_MANGLE_CHR_SHIFTR
:
19544 SET_NAME (rule
, rule_buf
[rule_pos
]);
19545 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19548 case RULE_OP_MANGLE_CHR_INCR
:
19549 SET_NAME (rule
, rule_buf
[rule_pos
]);
19550 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19553 case RULE_OP_MANGLE_CHR_DECR
:
19554 SET_NAME (rule
, rule_buf
[rule_pos
]);
19555 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19558 case RULE_OP_MANGLE_REPLACE_NP1
:
19559 SET_NAME (rule
, rule_buf
[rule_pos
]);
19560 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19563 case RULE_OP_MANGLE_REPLACE_NM1
:
19564 SET_NAME (rule
, rule_buf
[rule_pos
]);
19565 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19568 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19569 SET_NAME (rule
, rule_buf
[rule_pos
]);
19570 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19573 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19574 SET_NAME (rule
, rule_buf
[rule_pos
]);
19575 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19578 case RULE_OP_MANGLE_TITLE
:
19579 SET_NAME (rule
, rule_buf
[rule_pos
]);
19588 if (rule_pos
< rule_len
) return (-1);
19593 int kernel_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], kernel_rule_t
*rule
)
19597 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19601 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19605 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19609 case RULE_OP_MANGLE_NOOP
:
19610 rule_buf
[rule_pos
] = rule_cmd
;
19613 case RULE_OP_MANGLE_LREST
:
19614 rule_buf
[rule_pos
] = rule_cmd
;
19617 case RULE_OP_MANGLE_UREST
:
19618 rule_buf
[rule_pos
] = rule_cmd
;
19621 case RULE_OP_MANGLE_LREST_UFIRST
:
19622 rule_buf
[rule_pos
] = rule_cmd
;
19625 case RULE_OP_MANGLE_UREST_LFIRST
:
19626 rule_buf
[rule_pos
] = rule_cmd
;
19629 case RULE_OP_MANGLE_TREST
:
19630 rule_buf
[rule_pos
] = rule_cmd
;
19633 case RULE_OP_MANGLE_TOGGLE_AT
:
19634 rule_buf
[rule_pos
] = rule_cmd
;
19635 GET_P0_CONV (rule
);
19638 case RULE_OP_MANGLE_REVERSE
:
19639 rule_buf
[rule_pos
] = rule_cmd
;
19642 case RULE_OP_MANGLE_DUPEWORD
:
19643 rule_buf
[rule_pos
] = rule_cmd
;
19646 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19647 rule_buf
[rule_pos
] = rule_cmd
;
19648 GET_P0_CONV (rule
);
19651 case RULE_OP_MANGLE_REFLECT
:
19652 rule_buf
[rule_pos
] = rule_cmd
;
19655 case RULE_OP_MANGLE_ROTATE_LEFT
:
19656 rule_buf
[rule_pos
] = rule_cmd
;
19659 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19660 rule_buf
[rule_pos
] = rule_cmd
;
19663 case RULE_OP_MANGLE_APPEND
:
19664 rule_buf
[rule_pos
] = rule_cmd
;
19668 case RULE_OP_MANGLE_PREPEND
:
19669 rule_buf
[rule_pos
] = rule_cmd
;
19673 case RULE_OP_MANGLE_DELETE_FIRST
:
19674 rule_buf
[rule_pos
] = rule_cmd
;
19677 case RULE_OP_MANGLE_DELETE_LAST
:
19678 rule_buf
[rule_pos
] = rule_cmd
;
19681 case RULE_OP_MANGLE_DELETE_AT
:
19682 rule_buf
[rule_pos
] = rule_cmd
;
19683 GET_P0_CONV (rule
);
19686 case RULE_OP_MANGLE_EXTRACT
:
19687 rule_buf
[rule_pos
] = rule_cmd
;
19688 GET_P0_CONV (rule
);
19689 GET_P1_CONV (rule
);
19692 case RULE_OP_MANGLE_OMIT
:
19693 rule_buf
[rule_pos
] = rule_cmd
;
19694 GET_P0_CONV (rule
);
19695 GET_P1_CONV (rule
);
19698 case RULE_OP_MANGLE_INSERT
:
19699 rule_buf
[rule_pos
] = rule_cmd
;
19700 GET_P0_CONV (rule
);
19704 case RULE_OP_MANGLE_OVERSTRIKE
:
19705 rule_buf
[rule_pos
] = rule_cmd
;
19706 GET_P0_CONV (rule
);
19710 case RULE_OP_MANGLE_TRUNCATE_AT
:
19711 rule_buf
[rule_pos
] = rule_cmd
;
19712 GET_P0_CONV (rule
);
19715 case RULE_OP_MANGLE_REPLACE
:
19716 rule_buf
[rule_pos
] = rule_cmd
;
19721 case RULE_OP_MANGLE_PURGECHAR
:
19725 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19729 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19730 rule_buf
[rule_pos
] = rule_cmd
;
19731 GET_P0_CONV (rule
);
19734 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19735 rule_buf
[rule_pos
] = rule_cmd
;
19736 GET_P0_CONV (rule
);
19739 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19740 rule_buf
[rule_pos
] = rule_cmd
;
19743 case RULE_OP_MANGLE_SWITCH_FIRST
:
19744 rule_buf
[rule_pos
] = rule_cmd
;
19747 case RULE_OP_MANGLE_SWITCH_LAST
:
19748 rule_buf
[rule_pos
] = rule_cmd
;
19751 case RULE_OP_MANGLE_SWITCH_AT
:
19752 rule_buf
[rule_pos
] = rule_cmd
;
19753 GET_P0_CONV (rule
);
19754 GET_P1_CONV (rule
);
19757 case RULE_OP_MANGLE_CHR_SHIFTL
:
19758 rule_buf
[rule_pos
] = rule_cmd
;
19759 GET_P0_CONV (rule
);
19762 case RULE_OP_MANGLE_CHR_SHIFTR
:
19763 rule_buf
[rule_pos
] = rule_cmd
;
19764 GET_P0_CONV (rule
);
19767 case RULE_OP_MANGLE_CHR_INCR
:
19768 rule_buf
[rule_pos
] = rule_cmd
;
19769 GET_P0_CONV (rule
);
19772 case RULE_OP_MANGLE_CHR_DECR
:
19773 rule_buf
[rule_pos
] = rule_cmd
;
19774 GET_P0_CONV (rule
);
19777 case RULE_OP_MANGLE_REPLACE_NP1
:
19778 rule_buf
[rule_pos
] = rule_cmd
;
19779 GET_P0_CONV (rule
);
19782 case RULE_OP_MANGLE_REPLACE_NM1
:
19783 rule_buf
[rule_pos
] = rule_cmd
;
19784 GET_P0_CONV (rule
);
19787 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19788 rule_buf
[rule_pos
] = rule_cmd
;
19789 GET_P0_CONV (rule
);
19792 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19793 rule_buf
[rule_pos
] = rule_cmd
;
19794 GET_P0_CONV (rule
);
19797 case RULE_OP_MANGLE_TITLE
:
19798 rule_buf
[rule_pos
] = rule_cmd
;
19802 return rule_pos
- 1;
19820 * CPU rules : this is from hashcat sources, cpu based rules
19823 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19824 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19826 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19827 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19828 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19830 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19831 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19832 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19834 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19838 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19843 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19847 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19852 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19856 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19861 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19866 for (l
= 0; l
< arr_len
; l
++)
19868 r
= arr_len
- 1 - l
;
19872 MANGLE_SWITCH (arr
, l
, r
);
19878 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19880 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19882 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19884 return (arr_len
* 2);
19887 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19889 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19891 int orig_len
= arr_len
;
19895 for (i
= 0; i
< times
; i
++)
19897 memcpy (&arr
[arr_len
], arr
, orig_len
);
19899 arr_len
+= orig_len
;
19905 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19907 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19909 mangle_double (arr
, arr_len
);
19911 mangle_reverse (arr
+ arr_len
, arr_len
);
19913 return (arr_len
* 2);
19916 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
19921 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
19923 MANGLE_SWITCH (arr
, l
, r
);
19929 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
19934 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
19936 MANGLE_SWITCH (arr
, l
, r
);
19942 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19944 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19948 return (arr_len
+ 1);
19951 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19953 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19957 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19959 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19964 return (arr_len
+ 1);
19967 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19969 if (upos
>= arr_len
) return (arr_len
);
19973 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
19975 arr
[arr_pos
] = arr
[arr_pos
+ 1];
19978 return (arr_len
- 1);
19981 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19983 if (upos
>= arr_len
) return (arr_len
);
19985 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
19989 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
19991 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
19997 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19999 if (upos
>= arr_len
) return (arr_len
);
20001 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
20005 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
20007 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
20010 return (arr_len
- ulen
);
20013 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20015 if (upos
>= arr_len
) return (arr_len
);
20017 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20021 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
20023 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20028 return (arr_len
+ 1);
20031 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
)
20033 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20035 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
20037 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
20039 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
20041 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
20043 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
20045 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
20047 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
20049 return (arr_len
+ arr2_cpy
);
20052 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20054 if (upos
>= arr_len
) return (arr_len
);
20061 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20063 if (upos
>= arr_len
) return (arr_len
);
20065 memset (arr
+ upos
, 0, arr_len
- upos
);
20070 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
20074 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20076 if (arr
[arr_pos
] != oldc
) continue;
20078 arr
[arr_pos
] = newc
;
20084 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20090 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20092 if (arr
[arr_pos
] == c
) continue;
20094 arr
[ret_len
] = arr
[arr_pos
];
20102 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20104 if (ulen
> arr_len
) return (arr_len
);
20106 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20108 char cs
[100] = { 0 };
20110 memcpy (cs
, arr
, ulen
);
20114 for (i
= 0; i
< ulen
; i
++)
20118 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20124 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20126 if (ulen
> arr_len
) return (arr_len
);
20128 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20130 int upos
= arr_len
- ulen
;
20134 for (i
= 0; i
< ulen
; i
++)
20136 char c
= arr
[upos
+ i
];
20138 arr_len
= mangle_append (arr
, arr_len
, c
);
20144 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20146 if ( arr_len
== 0) return (arr_len
);
20147 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20149 char c
= arr
[upos
];
20153 for (i
= 0; i
< ulen
; i
++)
20155 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20161 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20163 if ( arr_len
== 0) return (arr_len
);
20164 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20168 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20170 int new_pos
= arr_pos
* 2;
20172 arr
[new_pos
] = arr
[arr_pos
];
20174 arr
[new_pos
+ 1] = arr
[arr_pos
];
20177 return (arr_len
* 2);
20180 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20182 if (upos
>= arr_len
) return (arr_len
);
20183 if (upos2
>= arr_len
) return (arr_len
);
20185 MANGLE_SWITCH (arr
, upos
, upos2
);
20190 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20192 MANGLE_SWITCH (arr
, upos
, upos2
);
20197 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20199 if (upos
>= arr_len
) return (arr_len
);
20206 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20208 if (upos
>= arr_len
) return (arr_len
);
20215 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20217 if (upos
>= arr_len
) return (arr_len
);
20224 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20226 if (upos
>= arr_len
) return (arr_len
);
20233 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20235 int upper_next
= 1;
20239 for (pos
= 0; pos
< arr_len
; pos
++)
20241 if (arr
[pos
] == ' ')
20252 MANGLE_UPPER_AT (arr
, pos
);
20256 MANGLE_LOWER_AT (arr
, pos
);
20263 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20265 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20271 for (j
= 0; j
< rp_gen_num
; j
++)
20278 switch ((char) get_random_num (0, 9))
20281 r
= get_random_num (0, sizeof (grp_op_nop
));
20282 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20286 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20287 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20288 p1
= get_random_num (0, sizeof (grp_pos
));
20289 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20293 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20294 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20295 p1
= get_random_num (1, 6);
20296 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20300 r
= get_random_num (0, sizeof (grp_op_chr
));
20301 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20302 p1
= get_random_num (0x20, 0x7e);
20303 rule_buf
[rule_pos
++] = (char) p1
;
20307 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20308 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20309 p1
= get_random_num (0x20, 0x7e);
20310 rule_buf
[rule_pos
++] = (char) p1
;
20311 p2
= get_random_num (0x20, 0x7e);
20313 p2
= get_random_num (0x20, 0x7e);
20314 rule_buf
[rule_pos
++] = (char) p2
;
20318 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20319 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20320 p1
= get_random_num (0, sizeof (grp_pos
));
20321 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20322 p2
= get_random_num (0x20, 0x7e);
20323 rule_buf
[rule_pos
++] = (char) p2
;
20327 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20328 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20329 p1
= get_random_num (0, sizeof (grp_pos
));
20330 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20331 p2
= get_random_num (0, sizeof (grp_pos
));
20333 p2
= get_random_num (0, sizeof (grp_pos
));
20334 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20338 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20339 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
20340 p1
= get_random_num (0, sizeof (grp_pos
));
20341 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20342 p2
= get_random_num (1, sizeof (grp_pos
));
20344 p2
= get_random_num (1, sizeof (grp_pos
));
20345 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20349 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
20350 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
20351 p1
= get_random_num (0, sizeof (grp_pos
));
20352 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20353 p2
= get_random_num (1, sizeof (grp_pos
));
20354 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20355 p3
= get_random_num (0, sizeof (grp_pos
));
20356 rule_buf
[rule_pos
++] = grp_pos
[p3
];
20364 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
20366 char mem
[BLOCK_SIZE
] = { 0 };
20368 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
20370 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
20372 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20374 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
20376 int out_len
= in_len
;
20377 int mem_len
= in_len
;
20379 memcpy (out
, in
, out_len
);
20383 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
20388 switch (rule
[rule_pos
])
20393 case RULE_OP_MANGLE_NOOP
:
20396 case RULE_OP_MANGLE_LREST
:
20397 out_len
= mangle_lrest (out
, out_len
);
20400 case RULE_OP_MANGLE_UREST
:
20401 out_len
= mangle_urest (out
, out_len
);
20404 case RULE_OP_MANGLE_LREST_UFIRST
:
20405 out_len
= mangle_lrest (out
, out_len
);
20406 if (out_len
) MANGLE_UPPER_AT (out
, 0);
20409 case RULE_OP_MANGLE_UREST_LFIRST
:
20410 out_len
= mangle_urest (out
, out_len
);
20411 if (out_len
) MANGLE_LOWER_AT (out
, 0);
20414 case RULE_OP_MANGLE_TREST
:
20415 out_len
= mangle_trest (out
, out_len
);
20418 case RULE_OP_MANGLE_TOGGLE_AT
:
20419 NEXT_RULEPOS (rule_pos
);
20420 NEXT_RPTOI (rule
, rule_pos
, upos
);
20421 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
20424 case RULE_OP_MANGLE_REVERSE
:
20425 out_len
= mangle_reverse (out
, out_len
);
20428 case RULE_OP_MANGLE_DUPEWORD
:
20429 out_len
= mangle_double (out
, out_len
);
20432 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20433 NEXT_RULEPOS (rule_pos
);
20434 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20435 out_len
= mangle_double_times (out
, out_len
, ulen
);
20438 case RULE_OP_MANGLE_REFLECT
:
20439 out_len
= mangle_reflect (out
, out_len
);
20442 case RULE_OP_MANGLE_ROTATE_LEFT
:
20443 mangle_rotate_left (out
, out_len
);
20446 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20447 mangle_rotate_right (out
, out_len
);
20450 case RULE_OP_MANGLE_APPEND
:
20451 NEXT_RULEPOS (rule_pos
);
20452 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
20455 case RULE_OP_MANGLE_PREPEND
:
20456 NEXT_RULEPOS (rule_pos
);
20457 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
20460 case RULE_OP_MANGLE_DELETE_FIRST
:
20461 out_len
= mangle_delete_at (out
, out_len
, 0);
20464 case RULE_OP_MANGLE_DELETE_LAST
:
20465 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
20468 case RULE_OP_MANGLE_DELETE_AT
:
20469 NEXT_RULEPOS (rule_pos
);
20470 NEXT_RPTOI (rule
, rule_pos
, upos
);
20471 out_len
= mangle_delete_at (out
, out_len
, upos
);
20474 case RULE_OP_MANGLE_EXTRACT
:
20475 NEXT_RULEPOS (rule_pos
);
20476 NEXT_RPTOI (rule
, rule_pos
, upos
);
20477 NEXT_RULEPOS (rule_pos
);
20478 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20479 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
20482 case RULE_OP_MANGLE_OMIT
:
20483 NEXT_RULEPOS (rule_pos
);
20484 NEXT_RPTOI (rule
, rule_pos
, upos
);
20485 NEXT_RULEPOS (rule_pos
);
20486 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20487 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
20490 case RULE_OP_MANGLE_INSERT
:
20491 NEXT_RULEPOS (rule_pos
);
20492 NEXT_RPTOI (rule
, rule_pos
, upos
);
20493 NEXT_RULEPOS (rule_pos
);
20494 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
20497 case RULE_OP_MANGLE_OVERSTRIKE
:
20498 NEXT_RULEPOS (rule_pos
);
20499 NEXT_RPTOI (rule
, rule_pos
, upos
);
20500 NEXT_RULEPOS (rule_pos
);
20501 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20504 case RULE_OP_MANGLE_TRUNCATE_AT
:
20505 NEXT_RULEPOS (rule_pos
);
20506 NEXT_RPTOI (rule
, rule_pos
, upos
);
20507 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20510 case RULE_OP_MANGLE_REPLACE
:
20511 NEXT_RULEPOS (rule_pos
);
20512 NEXT_RULEPOS (rule_pos
);
20513 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20516 case RULE_OP_MANGLE_PURGECHAR
:
20517 NEXT_RULEPOS (rule_pos
);
20518 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20521 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20525 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20526 NEXT_RULEPOS (rule_pos
);
20527 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20528 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20531 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20532 NEXT_RULEPOS (rule_pos
);
20533 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20534 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20537 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20538 out_len
= mangle_dupechar (out
, out_len
);
20541 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20542 NEXT_RULEPOS (rule_pos
);
20543 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20544 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20547 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20548 NEXT_RULEPOS (rule_pos
);
20549 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20550 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20553 case RULE_OP_MANGLE_SWITCH_FIRST
:
20554 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20557 case RULE_OP_MANGLE_SWITCH_LAST
:
20558 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20561 case RULE_OP_MANGLE_SWITCH_AT
:
20562 NEXT_RULEPOS (rule_pos
);
20563 NEXT_RPTOI (rule
, rule_pos
, upos
);
20564 NEXT_RULEPOS (rule_pos
);
20565 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20566 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20569 case RULE_OP_MANGLE_CHR_SHIFTL
:
20570 NEXT_RULEPOS (rule_pos
);
20571 NEXT_RPTOI (rule
, rule_pos
, upos
);
20572 mangle_chr_shiftl (out
, out_len
, upos
);
20575 case RULE_OP_MANGLE_CHR_SHIFTR
:
20576 NEXT_RULEPOS (rule_pos
);
20577 NEXT_RPTOI (rule
, rule_pos
, upos
);
20578 mangle_chr_shiftr (out
, out_len
, upos
);
20581 case RULE_OP_MANGLE_CHR_INCR
:
20582 NEXT_RULEPOS (rule_pos
);
20583 NEXT_RPTOI (rule
, rule_pos
, upos
);
20584 mangle_chr_incr (out
, out_len
, upos
);
20587 case RULE_OP_MANGLE_CHR_DECR
:
20588 NEXT_RULEPOS (rule_pos
);
20589 NEXT_RPTOI (rule
, rule_pos
, upos
);
20590 mangle_chr_decr (out
, out_len
, upos
);
20593 case RULE_OP_MANGLE_REPLACE_NP1
:
20594 NEXT_RULEPOS (rule_pos
);
20595 NEXT_RPTOI (rule
, rule_pos
, upos
);
20596 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20599 case RULE_OP_MANGLE_REPLACE_NM1
:
20600 NEXT_RULEPOS (rule_pos
);
20601 NEXT_RPTOI (rule
, rule_pos
, upos
);
20602 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20605 case RULE_OP_MANGLE_TITLE
:
20606 out_len
= mangle_title (out
, out_len
);
20609 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20610 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20611 NEXT_RULEPOS (rule_pos
);
20612 NEXT_RPTOI (rule
, rule_pos
, upos
);
20613 NEXT_RULEPOS (rule_pos
);
20614 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20615 NEXT_RULEPOS (rule_pos
);
20616 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20617 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20620 case RULE_OP_MANGLE_APPEND_MEMORY
:
20621 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20622 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20623 memcpy (out
+ out_len
, mem
, mem_len
);
20624 out_len
+= mem_len
;
20627 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20628 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20629 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20630 memcpy (mem
+ mem_len
, out
, out_len
);
20631 out_len
+= mem_len
;
20632 memcpy (out
, mem
, out_len
);
20635 case RULE_OP_MEMORIZE_WORD
:
20636 memcpy (mem
, out
, out_len
);
20640 case RULE_OP_REJECT_LESS
:
20641 NEXT_RULEPOS (rule_pos
);
20642 NEXT_RPTOI (rule
, rule_pos
, upos
);
20643 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20646 case RULE_OP_REJECT_GREATER
:
20647 NEXT_RULEPOS (rule_pos
);
20648 NEXT_RPTOI (rule
, rule_pos
, upos
);
20649 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20652 case RULE_OP_REJECT_CONTAIN
:
20653 NEXT_RULEPOS (rule_pos
);
20654 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20657 case RULE_OP_REJECT_NOT_CONTAIN
:
20658 NEXT_RULEPOS (rule_pos
);
20659 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20662 case RULE_OP_REJECT_EQUAL_FIRST
:
20663 NEXT_RULEPOS (rule_pos
);
20664 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20667 case RULE_OP_REJECT_EQUAL_LAST
:
20668 NEXT_RULEPOS (rule_pos
);
20669 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20672 case RULE_OP_REJECT_EQUAL_AT
:
20673 NEXT_RULEPOS (rule_pos
);
20674 NEXT_RPTOI (rule
, rule_pos
, upos
);
20675 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20676 NEXT_RULEPOS (rule_pos
);
20677 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20680 case RULE_OP_REJECT_CONTAINS
:
20681 NEXT_RULEPOS (rule_pos
);
20682 NEXT_RPTOI (rule
, rule_pos
, upos
);
20683 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20684 NEXT_RULEPOS (rule_pos
);
20685 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20686 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20689 case RULE_OP_REJECT_MEMORY
:
20690 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20694 return (RULE_RC_SYNTAX_ERROR
);
20699 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);