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
);
4790 const int res4
= t1
->workload_profile
4791 - t2
->workload_profile
;
4793 if (res4
!= 0) return (res4
);
4798 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
)
4800 uint outfile_autohex
= data
.outfile_autohex
;
4802 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4804 FILE *debug_fp
= NULL
;
4806 if (debug_file
!= NULL
)
4808 debug_fp
= fopen (debug_file
, "ab");
4810 lock_file (debug_fp
);
4817 if (debug_fp
== NULL
)
4819 log_info ("WARNING: Could not open debug-file for writing");
4823 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4825 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4827 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4830 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4832 if (debug_mode
== 4)
4834 fputc (':', debug_fp
);
4836 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4839 fputc ('\n', debug_fp
);
4841 if (debug_file
!= NULL
) fclose (debug_fp
);
4845 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4847 int needs_hexify
= 0;
4849 if (outfile_autohex
== 1)
4851 for (uint i
= 0; i
< plain_len
; i
++)
4853 if (plain_ptr
[i
] < 0x20)
4860 if (plain_ptr
[i
] > 0x7f)
4869 if (needs_hexify
== 1)
4871 fprintf (fp
, "$HEX[");
4873 for (uint i
= 0; i
< plain_len
; i
++)
4875 fprintf (fp
, "%02x", plain_ptr
[i
]);
4882 fwrite (plain_ptr
, plain_len
, 1, fp
);
4886 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
)
4888 uint outfile_format
= data
.outfile_format
;
4890 char separator
= data
.separator
;
4892 if (outfile_format
& OUTFILE_FMT_HASH
)
4894 fprintf (out_fp
, "%s", out_buf
);
4896 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4898 fputc (separator
, out_fp
);
4901 else if (data
.username
)
4903 if (username
!= NULL
)
4905 for (uint i
= 0; i
< user_len
; i
++)
4907 fprintf (out_fp
, "%c", username
[i
]);
4910 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4912 fputc (separator
, out_fp
);
4917 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4919 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4921 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4923 fputc (separator
, out_fp
);
4927 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4929 for (uint i
= 0; i
< plain_len
; i
++)
4931 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4934 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4936 fputc (separator
, out_fp
);
4940 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4943 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4948 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
4950 fprintf (out_fp
, "%llu", crackpos
);
4955 fputc ('\n', out_fp
);
4958 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
)
4962 pot_key
.hash
.salt
= hashes_buf
->salt
;
4963 pot_key
.hash
.digest
= hashes_buf
->digest
;
4965 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4971 input_buf
[input_len
] = 0;
4974 unsigned char *username
= NULL
;
4979 user_t
*user
= hashes_buf
->hash_info
->user
;
4983 username
= (unsigned char *) (user
->user_name
);
4985 user_len
= user
->user_len
;
4989 // do output the line
4990 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
4994 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
4995 #define LM_MASKED_PLAIN "[notfound]"
4997 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
)
5003 pot_left_key
.hash
.salt
= hash_left
->salt
;
5004 pot_left_key
.hash
.digest
= hash_left
->digest
;
5006 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5010 uint weak_hash_found
= 0;
5012 pot_t pot_right_key
;
5014 pot_right_key
.hash
.salt
= hash_right
->salt
;
5015 pot_right_key
.hash
.digest
= hash_right
->digest
;
5017 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5019 if (pot_right_ptr
== NULL
)
5021 // special case, if "weak hash"
5023 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5025 weak_hash_found
= 1;
5027 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5029 // in theory this is not needed, but we are paranoia:
5031 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5032 pot_right_ptr
->plain_len
= 0;
5036 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5038 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
5043 // at least one half was found:
5047 input_buf
[input_len
] = 0;
5051 unsigned char *username
= NULL
;
5056 user_t
*user
= hash_left
->hash_info
->user
;
5060 username
= (unsigned char *) (user
->user_name
);
5062 user_len
= user
->user_len
;
5066 // mask the part which was not found
5068 uint left_part_masked
= 0;
5069 uint right_part_masked
= 0;
5071 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5073 if (pot_left_ptr
== NULL
)
5075 left_part_masked
= 1;
5077 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5079 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5081 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5082 pot_left_ptr
->plain_len
= mask_plain_len
;
5085 if (pot_right_ptr
== NULL
)
5087 right_part_masked
= 1;
5089 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5091 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5093 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5094 pot_right_ptr
->plain_len
= mask_plain_len
;
5097 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5101 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5103 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5105 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5107 // do output the line
5109 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5111 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5113 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5114 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5117 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
)
5121 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5123 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5125 if (pot_ptr
== NULL
)
5129 input_buf
[input_len
] = 0;
5131 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5135 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
)
5141 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5143 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5147 pot_t pot_right_key
;
5149 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5151 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5153 uint weak_hash_found
= 0;
5155 if (pot_right_ptr
== NULL
)
5157 // special case, if "weak hash"
5159 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5161 weak_hash_found
= 1;
5163 // we just need that pot_right_ptr is not a NULL pointer
5165 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5169 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5171 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5176 // ... at least one part was not cracked
5180 input_buf
[input_len
] = 0;
5182 // only show the hash part which is still not cracked
5184 uint user_len
= input_len
- 32;
5186 char *hash_output
= (char *) mymalloc (33);
5188 memcpy (hash_output
, input_buf
, input_len
);
5190 if (pot_left_ptr
!= NULL
)
5192 // only show right part (because left part was already found)
5194 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5196 hash_output
[user_len
+ 16] = 0;
5199 if (pot_right_ptr
!= NULL
)
5201 // only show left part (because right part was already found)
5203 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5205 hash_output
[user_len
+ 16] = 0;
5208 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5210 myfree (hash_output
);
5212 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5215 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5217 uint opencl_platforms_filter
= 0;
5219 if (opencl_platforms
)
5221 char *platforms
= strdup (opencl_platforms
);
5223 char *next
= strtok (platforms
, ",");
5227 int platform
= atoi (next
);
5229 if (platform
< 1 || platform
> 32)
5231 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5236 opencl_platforms_filter
|= 1 << (platform
- 1);
5238 } while ((next
= strtok (NULL
, ",")) != NULL
);
5244 opencl_platforms_filter
= -1;
5247 return opencl_platforms_filter
;
5250 u32
setup_devices_filter (char *opencl_devices
)
5252 u32 devices_filter
= 0;
5256 char *devices
= strdup (opencl_devices
);
5258 char *next
= strtok (devices
, ",");
5262 int device_id
= atoi (next
);
5264 if (device_id
< 1 || device_id
> 32)
5266 log_error ("ERROR: invalid device_id %u specified", device_id
);
5271 devices_filter
|= 1 << (device_id
- 1);
5273 } while ((next
= strtok (NULL
, ",")) != NULL
);
5279 devices_filter
= -1;
5282 return devices_filter
;
5285 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5287 cl_device_type device_types_filter
= 0;
5289 if (opencl_device_types
)
5291 char *device_types
= strdup (opencl_device_types
);
5293 char *next
= strtok (device_types
, ",");
5297 int device_type
= atoi (next
);
5299 if (device_type
< 1 || device_type
> 3)
5301 log_error ("ERROR: invalid device_type %u specified", device_type
);
5306 device_types_filter
|= 1 << device_type
;
5308 } while ((next
= strtok (NULL
, ",")) != NULL
);
5310 free (device_types
);
5314 // Do not use CPU by default, this often reduces GPU performance because
5315 // the CPU is too busy to handle GPU synchronization
5317 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5320 return device_types_filter
;
5323 u32
get_random_num (const u32 min
, const u32 max
)
5325 if (min
== max
) return (min
);
5327 return ((rand () % (max
- min
)) + min
);
5330 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5332 u32 quotient
= dividend
/ divisor
;
5334 if (dividend
% divisor
) quotient
++;
5339 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5341 u64 quotient
= dividend
/ divisor
;
5343 if (dividend
% divisor
) quotient
++;
5348 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5350 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5351 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5353 if (tm
->tm_year
- 70)
5355 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5356 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5358 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5360 else if (tm
->tm_yday
)
5362 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5363 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5365 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5367 else if (tm
->tm_hour
)
5369 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5370 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5372 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5374 else if (tm
->tm_min
)
5376 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5377 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5379 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5383 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5385 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5389 void format_speed_display (float val
, char *buf
, size_t len
)
5400 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5411 /* generate output */
5415 snprintf (buf
, len
- 1, "%.0f ", val
);
5419 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5423 void lowercase (u8
*buf
, int len
)
5425 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5428 void uppercase (u8
*buf
, int len
)
5430 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5433 int fgetl (FILE *fp
, char *line_buf
)
5439 const int c
= fgetc (fp
);
5441 if (c
== EOF
) break;
5443 line_buf
[line_len
] = (char) c
;
5447 if (line_len
== BUFSIZ
) line_len
--;
5449 if (c
== '\n') break;
5452 if (line_len
== 0) return 0;
5454 if (line_buf
[line_len
- 1] == '\n')
5458 line_buf
[line_len
] = 0;
5461 if (line_len
== 0) return 0;
5463 if (line_buf
[line_len
- 1] == '\r')
5467 line_buf
[line_len
] = 0;
5473 int in_superchop (char *buf
)
5475 int len
= strlen (buf
);
5479 if (buf
[len
- 1] == '\n')
5486 if (buf
[len
- 1] == '\r')
5501 char **scan_directory (const char *path
)
5503 char *tmp_path
= mystrdup (path
);
5505 size_t tmp_path_len
= strlen (tmp_path
);
5507 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5509 tmp_path
[tmp_path_len
- 1] = 0;
5511 tmp_path_len
= strlen (tmp_path
);
5514 char **files
= NULL
;
5520 if ((d
= opendir (tmp_path
)) != NULL
)
5526 memset (&e
, 0, sizeof (e
));
5527 struct dirent
*de
= NULL
;
5529 if (readdir_r (d
, &e
, &de
) != 0)
5531 log_error ("ERROR: readdir_r() failed");
5536 if (de
== NULL
) break;
5540 while ((de
= readdir (d
)) != NULL
)
5543 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5545 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5547 char *path_file
= (char *) mymalloc (path_size
+ 1);
5549 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5551 path_file
[path_size
] = 0;
5555 if ((d_test
= opendir (path_file
)) != NULL
)
5563 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5567 files
[num_files
- 1] = path_file
;
5573 else if (errno
== ENOTDIR
)
5575 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5579 files
[num_files
- 1] = mystrdup (path
);
5582 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5586 files
[num_files
- 1] = NULL
;
5593 int count_dictionaries (char **dictionary_files
)
5595 if (dictionary_files
== NULL
) return 0;
5599 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5607 char *stroptitype (const uint opti_type
)
5611 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5612 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5613 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5614 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5615 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5616 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5617 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5618 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5619 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5620 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5621 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5622 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5623 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5624 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5625 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5626 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5627 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5628 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5634 char *strparser (const uint parser_status
)
5636 switch (parser_status
)
5638 case PARSER_OK
: return ((char *) PA_000
); break;
5639 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5640 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5641 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5642 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5643 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5644 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5645 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5646 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5647 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5648 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5649 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5650 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5651 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5652 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5653 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5654 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5657 return ((char *) PA_255
);
5660 char *strhashtype (const uint hash_mode
)
5664 case 0: return ((char *) HT_00000
); break;
5665 case 10: return ((char *) HT_00010
); break;
5666 case 11: return ((char *) HT_00011
); break;
5667 case 12: return ((char *) HT_00012
); break;
5668 case 20: return ((char *) HT_00020
); break;
5669 case 21: return ((char *) HT_00021
); break;
5670 case 22: return ((char *) HT_00022
); break;
5671 case 23: return ((char *) HT_00023
); break;
5672 case 30: return ((char *) HT_00030
); break;
5673 case 40: return ((char *) HT_00040
); break;
5674 case 50: return ((char *) HT_00050
); break;
5675 case 60: return ((char *) HT_00060
); break;
5676 case 100: return ((char *) HT_00100
); break;
5677 case 101: return ((char *) HT_00101
); break;
5678 case 110: return ((char *) HT_00110
); break;
5679 case 111: return ((char *) HT_00111
); break;
5680 case 112: return ((char *) HT_00112
); break;
5681 case 120: return ((char *) HT_00120
); break;
5682 case 121: return ((char *) HT_00121
); break;
5683 case 122: return ((char *) HT_00122
); break;
5684 case 124: return ((char *) HT_00124
); break;
5685 case 130: return ((char *) HT_00130
); break;
5686 case 131: return ((char *) HT_00131
); break;
5687 case 132: return ((char *) HT_00132
); break;
5688 case 133: return ((char *) HT_00133
); break;
5689 case 140: return ((char *) HT_00140
); break;
5690 case 141: return ((char *) HT_00141
); break;
5691 case 150: return ((char *) HT_00150
); break;
5692 case 160: return ((char *) HT_00160
); break;
5693 case 190: return ((char *) HT_00190
); break;
5694 case 200: return ((char *) HT_00200
); break;
5695 case 300: return ((char *) HT_00300
); break;
5696 case 400: return ((char *) HT_00400
); break;
5697 case 500: return ((char *) HT_00500
); break;
5698 case 501: return ((char *) HT_00501
); break;
5699 case 900: return ((char *) HT_00900
); break;
5700 case 910: return ((char *) HT_00910
); break;
5701 case 1000: return ((char *) HT_01000
); break;
5702 case 1100: return ((char *) HT_01100
); break;
5703 case 1400: return ((char *) HT_01400
); break;
5704 case 1410: return ((char *) HT_01410
); break;
5705 case 1420: return ((char *) HT_01420
); break;
5706 case 1421: return ((char *) HT_01421
); break;
5707 case 1430: return ((char *) HT_01430
); break;
5708 case 1440: return ((char *) HT_01440
); break;
5709 case 1441: return ((char *) HT_01441
); break;
5710 case 1450: return ((char *) HT_01450
); break;
5711 case 1460: return ((char *) HT_01460
); break;
5712 case 1500: return ((char *) HT_01500
); break;
5713 case 1600: return ((char *) HT_01600
); break;
5714 case 1700: return ((char *) HT_01700
); break;
5715 case 1710: return ((char *) HT_01710
); break;
5716 case 1711: return ((char *) HT_01711
); break;
5717 case 1720: return ((char *) HT_01720
); break;
5718 case 1722: return ((char *) HT_01722
); break;
5719 case 1730: return ((char *) HT_01730
); break;
5720 case 1731: return ((char *) HT_01731
); break;
5721 case 1740: return ((char *) HT_01740
); break;
5722 case 1750: return ((char *) HT_01750
); break;
5723 case 1760: return ((char *) HT_01760
); break;
5724 case 1800: return ((char *) HT_01800
); break;
5725 case 2100: return ((char *) HT_02100
); break;
5726 case 2400: return ((char *) HT_02400
); break;
5727 case 2410: return ((char *) HT_02410
); break;
5728 case 2500: return ((char *) HT_02500
); break;
5729 case 2600: return ((char *) HT_02600
); break;
5730 case 2611: return ((char *) HT_02611
); break;
5731 case 2612: return ((char *) HT_02612
); break;
5732 case 2711: return ((char *) HT_02711
); break;
5733 case 2811: return ((char *) HT_02811
); break;
5734 case 3000: return ((char *) HT_03000
); break;
5735 case 3100: return ((char *) HT_03100
); break;
5736 case 3200: return ((char *) HT_03200
); break;
5737 case 3710: return ((char *) HT_03710
); break;
5738 case 3711: return ((char *) HT_03711
); break;
5739 case 3800: return ((char *) HT_03800
); break;
5740 case 4300: return ((char *) HT_04300
); break;
5741 case 4400: return ((char *) HT_04400
); break;
5742 case 4500: return ((char *) HT_04500
); break;
5743 case 4700: return ((char *) HT_04700
); break;
5744 case 4800: return ((char *) HT_04800
); break;
5745 case 4900: return ((char *) HT_04900
); break;
5746 case 5000: return ((char *) HT_05000
); break;
5747 case 5100: return ((char *) HT_05100
); break;
5748 case 5200: return ((char *) HT_05200
); break;
5749 case 5300: return ((char *) HT_05300
); break;
5750 case 5400: return ((char *) HT_05400
); break;
5751 case 5500: return ((char *) HT_05500
); break;
5752 case 5600: return ((char *) HT_05600
); break;
5753 case 5700: return ((char *) HT_05700
); break;
5754 case 5800: return ((char *) HT_05800
); break;
5755 case 6000: return ((char *) HT_06000
); break;
5756 case 6100: return ((char *) HT_06100
); break;
5757 case 6211: return ((char *) HT_06211
); break;
5758 case 6212: return ((char *) HT_06212
); break;
5759 case 6213: return ((char *) HT_06213
); break;
5760 case 6221: return ((char *) HT_06221
); break;
5761 case 6222: return ((char *) HT_06222
); break;
5762 case 6223: return ((char *) HT_06223
); break;
5763 case 6231: return ((char *) HT_06231
); break;
5764 case 6232: return ((char *) HT_06232
); break;
5765 case 6233: return ((char *) HT_06233
); break;
5766 case 6241: return ((char *) HT_06241
); break;
5767 case 6242: return ((char *) HT_06242
); break;
5768 case 6243: return ((char *) HT_06243
); break;
5769 case 6300: return ((char *) HT_06300
); break;
5770 case 6400: return ((char *) HT_06400
); break;
5771 case 6500: return ((char *) HT_06500
); break;
5772 case 6600: return ((char *) HT_06600
); break;
5773 case 6700: return ((char *) HT_06700
); break;
5774 case 6800: return ((char *) HT_06800
); break;
5775 case 6900: return ((char *) HT_06900
); break;
5776 case 7100: return ((char *) HT_07100
); break;
5777 case 7200: return ((char *) HT_07200
); break;
5778 case 7300: return ((char *) HT_07300
); break;
5779 case 7400: return ((char *) HT_07400
); break;
5780 case 7500: return ((char *) HT_07500
); break;
5781 case 7600: return ((char *) HT_07600
); break;
5782 case 7700: return ((char *) HT_07700
); break;
5783 case 7800: return ((char *) HT_07800
); break;
5784 case 7900: return ((char *) HT_07900
); break;
5785 case 8000: return ((char *) HT_08000
); break;
5786 case 8100: return ((char *) HT_08100
); break;
5787 case 8200: return ((char *) HT_08200
); break;
5788 case 8300: return ((char *) HT_08300
); break;
5789 case 8400: return ((char *) HT_08400
); break;
5790 case 8500: return ((char *) HT_08500
); break;
5791 case 8600: return ((char *) HT_08600
); break;
5792 case 8700: return ((char *) HT_08700
); break;
5793 case 8800: return ((char *) HT_08800
); break;
5794 case 8900: return ((char *) HT_08900
); break;
5795 case 9000: return ((char *) HT_09000
); break;
5796 case 9100: return ((char *) HT_09100
); break;
5797 case 9200: return ((char *) HT_09200
); break;
5798 case 9300: return ((char *) HT_09300
); break;
5799 case 9400: return ((char *) HT_09400
); break;
5800 case 9500: return ((char *) HT_09500
); break;
5801 case 9600: return ((char *) HT_09600
); break;
5802 case 9700: return ((char *) HT_09700
); break;
5803 case 9710: return ((char *) HT_09710
); break;
5804 case 9720: return ((char *) HT_09720
); break;
5805 case 9800: return ((char *) HT_09800
); break;
5806 case 9810: return ((char *) HT_09810
); break;
5807 case 9820: return ((char *) HT_09820
); break;
5808 case 9900: return ((char *) HT_09900
); break;
5809 case 10000: return ((char *) HT_10000
); break;
5810 case 10100: return ((char *) HT_10100
); break;
5811 case 10200: return ((char *) HT_10200
); break;
5812 case 10300: return ((char *) HT_10300
); break;
5813 case 10400: return ((char *) HT_10400
); break;
5814 case 10410: return ((char *) HT_10410
); break;
5815 case 10420: return ((char *) HT_10420
); break;
5816 case 10500: return ((char *) HT_10500
); break;
5817 case 10600: return ((char *) HT_10600
); break;
5818 case 10700: return ((char *) HT_10700
); break;
5819 case 10800: return ((char *) HT_10800
); break;
5820 case 10900: return ((char *) HT_10900
); break;
5821 case 11000: return ((char *) HT_11000
); break;
5822 case 11100: return ((char *) HT_11100
); break;
5823 case 11200: return ((char *) HT_11200
); break;
5824 case 11300: return ((char *) HT_11300
); break;
5825 case 11400: return ((char *) HT_11400
); break;
5826 case 11500: return ((char *) HT_11500
); break;
5827 case 11600: return ((char *) HT_11600
); break;
5828 case 11700: return ((char *) HT_11700
); break;
5829 case 11800: return ((char *) HT_11800
); break;
5830 case 11900: return ((char *) HT_11900
); break;
5831 case 12000: return ((char *) HT_12000
); break;
5832 case 12100: return ((char *) HT_12100
); break;
5833 case 12200: return ((char *) HT_12200
); break;
5834 case 12300: return ((char *) HT_12300
); break;
5835 case 12400: return ((char *) HT_12400
); break;
5836 case 12500: return ((char *) HT_12500
); break;
5837 case 12600: return ((char *) HT_12600
); break;
5838 case 12700: return ((char *) HT_12700
); break;
5839 case 12800: return ((char *) HT_12800
); break;
5840 case 12900: return ((char *) HT_12900
); break;
5841 case 13000: return ((char *) HT_13000
); break;
5844 return ((char *) "Unknown");
5847 char *strstatus (const uint devices_status
)
5849 switch (devices_status
)
5851 case STATUS_INIT
: return ((char *) ST_0000
); break;
5852 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5853 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5854 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5855 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5856 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5857 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5858 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5859 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5860 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5863 return ((char *) "Unknown");
5866 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5868 uint hash_type
= data
.hash_type
;
5869 uint hash_mode
= data
.hash_mode
;
5870 uint salt_type
= data
.salt_type
;
5871 uint opts_type
= data
.opts_type
;
5872 uint opti_type
= data
.opti_type
;
5873 uint dgst_size
= data
.dgst_size
;
5875 char *hashfile
= data
.hashfile
;
5879 uint digest_buf
[64] = { 0 };
5881 u64
*digest_buf64
= (u64
*) digest_buf
;
5883 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5885 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5887 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5893 case HASH_TYPE_DESCRYPT
:
5894 FP (digest_buf
[1], digest_buf
[0], tt
);
5897 case HASH_TYPE_DESRACF
:
5898 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5899 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5901 FP (digest_buf
[1], digest_buf
[0], tt
);
5905 FP (digest_buf
[1], digest_buf
[0], tt
);
5908 case HASH_TYPE_NETNTLM
:
5909 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5910 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5911 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5912 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5914 FP (digest_buf
[1], digest_buf
[0], tt
);
5915 FP (digest_buf
[3], digest_buf
[2], tt
);
5918 case HASH_TYPE_BSDICRYPT
:
5919 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5920 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5922 FP (digest_buf
[1], digest_buf
[0], tt
);
5927 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5932 digest_buf
[0] += MD4M_A
;
5933 digest_buf
[1] += MD4M_B
;
5934 digest_buf
[2] += MD4M_C
;
5935 digest_buf
[3] += MD4M_D
;
5939 digest_buf
[0] += MD5M_A
;
5940 digest_buf
[1] += MD5M_B
;
5941 digest_buf
[2] += MD5M_C
;
5942 digest_buf
[3] += MD5M_D
;
5945 case HASH_TYPE_SHA1
:
5946 digest_buf
[0] += SHA1M_A
;
5947 digest_buf
[1] += SHA1M_B
;
5948 digest_buf
[2] += SHA1M_C
;
5949 digest_buf
[3] += SHA1M_D
;
5950 digest_buf
[4] += SHA1M_E
;
5953 case HASH_TYPE_SHA256
:
5954 digest_buf
[0] += SHA256M_A
;
5955 digest_buf
[1] += SHA256M_B
;
5956 digest_buf
[2] += SHA256M_C
;
5957 digest_buf
[3] += SHA256M_D
;
5958 digest_buf
[4] += SHA256M_E
;
5959 digest_buf
[5] += SHA256M_F
;
5960 digest_buf
[6] += SHA256M_G
;
5961 digest_buf
[7] += SHA256M_H
;
5964 case HASH_TYPE_SHA384
:
5965 digest_buf64
[0] += SHA384M_A
;
5966 digest_buf64
[1] += SHA384M_B
;
5967 digest_buf64
[2] += SHA384M_C
;
5968 digest_buf64
[3] += SHA384M_D
;
5969 digest_buf64
[4] += SHA384M_E
;
5970 digest_buf64
[5] += SHA384M_F
;
5971 digest_buf64
[6] += 0;
5972 digest_buf64
[7] += 0;
5975 case HASH_TYPE_SHA512
:
5976 digest_buf64
[0] += SHA512M_A
;
5977 digest_buf64
[1] += SHA512M_B
;
5978 digest_buf64
[2] += SHA512M_C
;
5979 digest_buf64
[3] += SHA512M_D
;
5980 digest_buf64
[4] += SHA512M_E
;
5981 digest_buf64
[5] += SHA512M_F
;
5982 digest_buf64
[6] += SHA512M_G
;
5983 digest_buf64
[7] += SHA512M_H
;
5988 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
5990 if (dgst_size
== DGST_SIZE_4_2
)
5992 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5994 else if (dgst_size
== DGST_SIZE_4_4
)
5996 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5998 else if (dgst_size
== DGST_SIZE_4_5
)
6000 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6002 else if (dgst_size
== DGST_SIZE_4_6
)
6004 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6006 else if (dgst_size
== DGST_SIZE_4_8
)
6008 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6010 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6012 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6014 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6016 else if (hash_type
== HASH_TYPE_SHA384
)
6018 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6020 else if (hash_type
== HASH_TYPE_SHA512
)
6022 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6024 else if (hash_type
== HASH_TYPE_GOST
)
6026 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6029 else if (dgst_size
== DGST_SIZE_4_64
)
6031 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6033 else if (dgst_size
== DGST_SIZE_8_25
)
6035 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6039 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6040 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6041 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6047 memset (&salt
, 0, sizeof (salt_t
));
6049 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6051 char *ptr
= (char *) salt
.salt_buf
;
6053 uint len
= salt
.salt_len
;
6055 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6061 case HASH_TYPE_NETNTLM
:
6063 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6064 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6066 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6072 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6074 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6082 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6084 uint max
= salt
.salt_len
/ 4;
6088 for (uint i
= 0; i
< max
; i
++)
6090 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6094 if (opts_type
& OPTS_TYPE_ST_HEX
)
6096 char tmp
[64] = { 0 };
6098 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6100 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6105 memcpy (ptr
, tmp
, len
);
6108 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6110 memset (ptr
+ len
, 0, memset_size
);
6112 salt
.salt_len
= len
;
6116 // some modes require special encoding
6119 uint out_buf_plain
[256] = { 0 };
6120 uint out_buf_salt
[256] = { 0 };
6122 char tmp_buf
[1024] = { 0 };
6124 char *ptr_plain
= (char *) out_buf_plain
;
6125 char *ptr_salt
= (char *) out_buf_salt
;
6127 if (hash_mode
== 22)
6129 char username
[30] = { 0 };
6131 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6133 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6135 u16
*ptr
= (u16
*) digest_buf
;
6137 tmp_buf
[ 0] = sig
[0];
6138 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6139 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6140 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6141 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6142 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6143 tmp_buf
[ 6] = sig
[1];
6144 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6145 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6146 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6147 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6148 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6149 tmp_buf
[12] = sig
[2];
6150 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6151 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6152 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6153 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6154 tmp_buf
[17] = sig
[3];
6155 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6156 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6157 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6158 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6159 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6160 tmp_buf
[23] = sig
[4];
6161 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6162 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6163 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6164 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6165 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6166 tmp_buf
[29] = sig
[5];
6168 snprintf (out_buf
, len
-1, "%s:%s",
6172 else if (hash_mode
== 23)
6174 // do not show the \nskyper\n part in output
6176 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6178 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6180 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6187 else if (hash_mode
== 101)
6189 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6191 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6192 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6193 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6194 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6195 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6197 memcpy (tmp_buf
, digest_buf
, 20);
6199 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6201 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6203 else if (hash_mode
== 111)
6205 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6207 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6208 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6209 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6210 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6211 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6213 memcpy (tmp_buf
, digest_buf
, 20);
6214 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6216 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6218 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6220 else if (hash_mode
== 122)
6222 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6223 (char *) salt
.salt_buf
,
6230 else if (hash_mode
== 124)
6232 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6233 (char *) salt
.salt_buf
,
6240 else if (hash_mode
== 131)
6242 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6243 (char *) salt
.salt_buf
,
6251 else if (hash_mode
== 132)
6253 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6254 (char *) salt
.salt_buf
,
6261 else if (hash_mode
== 133)
6263 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6265 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6266 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6267 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6268 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6269 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6271 memcpy (tmp_buf
, digest_buf
, 20);
6273 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6275 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6277 else if (hash_mode
== 141)
6279 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6281 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6283 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6285 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6287 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6288 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6289 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6290 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6291 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6293 memcpy (tmp_buf
, digest_buf
, 20);
6295 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6299 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6301 else if (hash_mode
== 400)
6303 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6305 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6306 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6307 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6308 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6310 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6312 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6314 else if (hash_mode
== 500)
6316 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6318 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6319 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6320 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6321 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6323 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6325 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6327 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6331 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6334 else if (hash_mode
== 501)
6336 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6338 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6339 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6341 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6343 else if (hash_mode
== 1421)
6345 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6347 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6363 else if (hash_mode
== 1441)
6365 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6367 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6369 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6371 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6373 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6374 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6375 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6376 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6377 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6378 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6379 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6380 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6382 memcpy (tmp_buf
, digest_buf
, 32);
6384 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6388 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6390 else if (hash_mode
== 1500)
6392 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6393 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6394 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6395 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6396 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6398 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6400 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6402 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6403 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6405 memcpy (tmp_buf
, digest_buf
, 8);
6407 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6409 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6413 else if (hash_mode
== 1600)
6415 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6417 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6418 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6419 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6420 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6422 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6424 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6426 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6430 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6433 else if (hash_mode
== 1711)
6435 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6437 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6438 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6439 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6440 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6441 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6442 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6443 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6444 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6446 memcpy (tmp_buf
, digest_buf
, 64);
6447 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6449 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6451 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6453 else if (hash_mode
== 1722)
6455 uint
*ptr
= digest_buf
;
6457 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6458 (unsigned char *) salt
.salt_buf
,
6468 else if (hash_mode
== 1731)
6470 uint
*ptr
= digest_buf
;
6472 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6473 (unsigned char *) salt
.salt_buf
,
6483 else if (hash_mode
== 1800)
6487 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6488 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6489 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6490 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6491 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6492 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6493 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6494 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6496 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6498 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6500 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6504 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6507 else if (hash_mode
== 2100)
6511 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6513 salt
.salt_iter
+ 1);
6515 uint signature_len
= strlen (out_buf
);
6517 pos
+= signature_len
;
6518 len
-= signature_len
;
6520 char *salt_ptr
= (char *) salt
.salt_buf
;
6522 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6524 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6525 byte_swap_32 (digest_buf
[0]),
6526 byte_swap_32 (digest_buf
[1]),
6527 byte_swap_32 (digest_buf
[2]),
6528 byte_swap_32 (digest_buf
[3]));
6530 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6532 memcpy (tmp_buf
, digest_buf
, 16);
6534 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6536 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6537 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6538 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6539 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6541 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6542 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6543 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6544 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6546 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6547 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6548 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6549 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6551 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6552 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6553 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6554 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6556 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6557 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6558 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6559 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6563 else if (hash_mode
== 2500)
6565 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6567 wpa_t
*wpa
= &wpas
[salt_pos
];
6569 uint pke
[25] = { 0 };
6571 char *pke_ptr
= (char *) pke
;
6573 for (uint i
= 0; i
< 25; i
++)
6575 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6578 unsigned char mac1
[6] = { 0 };
6579 unsigned char mac2
[6] = { 0 };
6581 memcpy (mac1
, pke_ptr
+ 23, 6);
6582 memcpy (mac2
, pke_ptr
+ 29, 6);
6584 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6585 (char *) salt
.salt_buf
,
6599 else if (hash_mode
== 4400)
6601 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6602 byte_swap_32 (digest_buf
[0]),
6603 byte_swap_32 (digest_buf
[1]),
6604 byte_swap_32 (digest_buf
[2]),
6605 byte_swap_32 (digest_buf
[3]));
6607 else if (hash_mode
== 4700)
6609 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6610 byte_swap_32 (digest_buf
[0]),
6611 byte_swap_32 (digest_buf
[1]),
6612 byte_swap_32 (digest_buf
[2]),
6613 byte_swap_32 (digest_buf
[3]),
6614 byte_swap_32 (digest_buf
[4]));
6616 else if (hash_mode
== 4800)
6618 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6620 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6625 byte_swap_32 (salt
.salt_buf
[0]),
6626 byte_swap_32 (salt
.salt_buf
[1]),
6627 byte_swap_32 (salt
.salt_buf
[2]),
6628 byte_swap_32 (salt
.salt_buf
[3]),
6631 else if (hash_mode
== 4900)
6633 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6634 byte_swap_32 (digest_buf
[0]),
6635 byte_swap_32 (digest_buf
[1]),
6636 byte_swap_32 (digest_buf
[2]),
6637 byte_swap_32 (digest_buf
[3]),
6638 byte_swap_32 (digest_buf
[4]));
6640 else if (hash_mode
== 5100)
6642 snprintf (out_buf
, len
-1, "%08x%08x",
6646 else if (hash_mode
== 5200)
6648 snprintf (out_buf
, len
-1, "%s", hashfile
);
6650 else if (hash_mode
== 5300)
6652 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6654 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6656 int buf_len
= len
-1;
6660 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6662 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6664 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6666 snprintf (out_buf
, buf_len
, ":");
6672 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6680 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6682 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6684 if ((i
== 0) || (i
== 5))
6686 snprintf (out_buf
, buf_len
, ":");
6692 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6700 for (uint i
= 0; i
< 4; i
++)
6704 snprintf (out_buf
, buf_len
, ":");
6710 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6716 else if (hash_mode
== 5400)
6718 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6720 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6722 int buf_len
= len
-1;
6726 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6728 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6730 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6732 snprintf (out_buf
, buf_len
, ":");
6738 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6746 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6748 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6750 if ((i
== 0) || (i
== 5))
6752 snprintf (out_buf
, buf_len
, ":");
6758 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6766 for (uint i
= 0; i
< 5; i
++)
6770 snprintf (out_buf
, buf_len
, ":");
6776 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6782 else if (hash_mode
== 5500)
6784 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6786 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6788 char user_buf
[64] = { 0 };
6789 char domain_buf
[64] = { 0 };
6790 char srvchall_buf
[1024] = { 0 };
6791 char clichall_buf
[1024] = { 0 };
6793 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6795 char *ptr
= (char *) netntlm
->userdomain_buf
;
6797 user_buf
[i
] = ptr
[j
];
6800 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6802 char *ptr
= (char *) netntlm
->userdomain_buf
;
6804 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6807 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6809 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6811 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6814 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6816 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6818 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6821 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6829 byte_swap_32 (salt
.salt_buf_pc
[0]),
6830 byte_swap_32 (salt
.salt_buf_pc
[1]),
6833 else if (hash_mode
== 5600)
6835 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6837 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6839 char user_buf
[64] = { 0 };
6840 char domain_buf
[64] = { 0 };
6841 char srvchall_buf
[1024] = { 0 };
6842 char clichall_buf
[1024] = { 0 };
6844 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6846 char *ptr
= (char *) netntlm
->userdomain_buf
;
6848 user_buf
[i
] = ptr
[j
];
6851 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6853 char *ptr
= (char *) netntlm
->userdomain_buf
;
6855 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6858 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6860 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6862 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6865 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6867 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6869 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6872 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6882 else if (hash_mode
== 5700)
6884 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6886 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6887 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6888 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6889 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6890 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6891 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6892 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6893 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6895 memcpy (tmp_buf
, digest_buf
, 32);
6897 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6901 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6903 else if (hash_mode
== 5800)
6905 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6906 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6907 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6908 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6909 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6911 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6918 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6920 snprintf (out_buf
, len
-1, "%s", hashfile
);
6922 else if (hash_mode
== 6300)
6924 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6926 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6927 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6928 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6929 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6931 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6933 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6935 else if (hash_mode
== 6400)
6937 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6939 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6941 else if (hash_mode
== 6500)
6943 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6945 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6947 else if (hash_mode
== 6600)
6949 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6951 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6953 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6954 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6956 uint buf_len
= len
- 1;
6958 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6961 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6963 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6968 else if (hash_mode
== 6700)
6970 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6972 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6974 else if (hash_mode
== 6800)
6976 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6978 else if (hash_mode
== 7100)
6980 uint
*ptr
= digest_buf
;
6982 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6984 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6986 uint esalt
[8] = { 0 };
6988 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6989 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6990 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6991 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6992 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6993 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6994 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6995 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6997 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",
6998 SIGNATURE_SHA512OSX
,
7000 esalt
[ 0], esalt
[ 1],
7001 esalt
[ 2], esalt
[ 3],
7002 esalt
[ 4], esalt
[ 5],
7003 esalt
[ 6], esalt
[ 7],
7011 ptr
[15], ptr
[14]);
7013 else if (hash_mode
== 7200)
7015 uint
*ptr
= digest_buf
;
7017 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7019 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7023 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7025 len_used
= strlen (out_buf
);
7027 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7029 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7031 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7034 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",
7042 ptr
[15], ptr
[14]);
7044 else if (hash_mode
== 7300)
7046 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7048 rakp_t
*rakp
= &rakps
[salt_pos
];
7050 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7052 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7055 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7062 else if (hash_mode
== 7400)
7064 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7066 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7067 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7068 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7069 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7070 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7071 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7072 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7073 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7075 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7077 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7079 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7083 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7086 else if (hash_mode
== 7500)
7088 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7090 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7092 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7093 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7095 char data
[128] = { 0 };
7097 char *ptr_data
= data
;
7099 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7101 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7104 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7106 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7111 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7113 (char *) krb5pa
->user
,
7114 (char *) krb5pa
->realm
,
7115 (char *) krb5pa
->salt
,
7118 else if (hash_mode
== 7700)
7120 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7121 (char *) salt
.salt_buf
,
7125 else if (hash_mode
== 7800)
7127 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7128 (char *) salt
.salt_buf
,
7135 else if (hash_mode
== 7900)
7137 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7141 char *tmp
= (char *) salt
.salt_buf_pc
;
7143 ptr_plain
[42] = tmp
[0];
7149 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7151 else if (hash_mode
== 8000)
7153 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7154 (unsigned char *) salt
.salt_buf
,
7164 else if (hash_mode
== 8100)
7166 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7167 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7169 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7170 (unsigned char *) salt
.salt_buf
,
7177 else if (hash_mode
== 8200)
7179 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7181 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7183 char data_buf
[4096] = { 0 };
7185 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7187 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7190 data_buf
[cloudkey
->data_len
* 2] = 0;
7192 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7193 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7194 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7195 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7196 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7197 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7198 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7199 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7201 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7202 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7203 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7204 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7206 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7222 else if (hash_mode
== 8300)
7224 char digest_buf_c
[34] = { 0 };
7226 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7228 digest_buf_c
[32] = 0;
7232 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7234 char domain_buf_c
[33] = { 0 };
7236 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7238 for (uint i
= 0; i
< salt_pc_len
; i
++)
7240 const char next
= domain_buf_c
[i
];
7242 domain_buf_c
[i
] = '.';
7247 domain_buf_c
[salt_pc_len
] = 0;
7251 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7253 else if (hash_mode
== 8500)
7255 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7257 else if (hash_mode
== 2612)
7259 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7261 (char *) salt
.salt_buf
,
7267 else if (hash_mode
== 3711)
7269 char *salt_ptr
= (char *) salt
.salt_buf
;
7271 salt_ptr
[salt
.salt_len
- 1] = 0;
7273 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7274 SIGNATURE_MEDIAWIKI_B
,
7281 else if (hash_mode
== 8800)
7283 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7285 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7287 char tmp
[3073] = { 0 };
7289 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7291 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7296 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7297 SIGNATURE_ANDROIDFDE
,
7298 byte_swap_32 (salt
.salt_buf
[0]),
7299 byte_swap_32 (salt
.salt_buf
[1]),
7300 byte_swap_32 (salt
.salt_buf
[2]),
7301 byte_swap_32 (salt
.salt_buf
[3]),
7302 byte_swap_32 (digest_buf
[0]),
7303 byte_swap_32 (digest_buf
[1]),
7304 byte_swap_32 (digest_buf
[2]),
7305 byte_swap_32 (digest_buf
[3]),
7308 else if (hash_mode
== 8900)
7310 uint N
= salt
.scrypt_N
;
7311 uint r
= salt
.scrypt_r
;
7312 uint p
= salt
.scrypt_p
;
7314 char base64_salt
[32] = { 0 };
7316 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7318 memset (tmp_buf
, 0, 46);
7320 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7321 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7322 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7323 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7324 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7325 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7326 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7327 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7328 digest_buf
[8] = 0; // needed for base64_encode ()
7330 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7332 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7340 else if (hash_mode
== 9000)
7342 snprintf (out_buf
, len
-1, "%s", hashfile
);
7344 else if (hash_mode
== 9200)
7348 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7350 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7352 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7356 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7357 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7358 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7359 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7360 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7361 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7362 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7363 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7364 digest_buf
[8] = 0; // needed for base64_encode ()
7366 char tmp_buf
[64] = { 0 };
7368 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7369 tmp_buf
[43] = 0; // cut it here
7373 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7375 else if (hash_mode
== 9300)
7377 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7378 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7379 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7380 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7381 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7382 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7383 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7384 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7385 digest_buf
[8] = 0; // needed for base64_encode ()
7387 char tmp_buf
[64] = { 0 };
7389 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7390 tmp_buf
[43] = 0; // cut it here
7392 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7394 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7396 else if (hash_mode
== 9400)
7398 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7400 office2007_t
*office2007
= &office2007s
[salt_pos
];
7402 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7403 SIGNATURE_OFFICE2007
,
7406 office2007
->keySize
,
7412 office2007
->encryptedVerifier
[0],
7413 office2007
->encryptedVerifier
[1],
7414 office2007
->encryptedVerifier
[2],
7415 office2007
->encryptedVerifier
[3],
7416 office2007
->encryptedVerifierHash
[0],
7417 office2007
->encryptedVerifierHash
[1],
7418 office2007
->encryptedVerifierHash
[2],
7419 office2007
->encryptedVerifierHash
[3],
7420 office2007
->encryptedVerifierHash
[4]);
7422 else if (hash_mode
== 9500)
7424 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7426 office2010_t
*office2010
= &office2010s
[salt_pos
];
7428 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,
7434 office2010
->encryptedVerifier
[0],
7435 office2010
->encryptedVerifier
[1],
7436 office2010
->encryptedVerifier
[2],
7437 office2010
->encryptedVerifier
[3],
7438 office2010
->encryptedVerifierHash
[0],
7439 office2010
->encryptedVerifierHash
[1],
7440 office2010
->encryptedVerifierHash
[2],
7441 office2010
->encryptedVerifierHash
[3],
7442 office2010
->encryptedVerifierHash
[4],
7443 office2010
->encryptedVerifierHash
[5],
7444 office2010
->encryptedVerifierHash
[6],
7445 office2010
->encryptedVerifierHash
[7]);
7447 else if (hash_mode
== 9600)
7449 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7451 office2013_t
*office2013
= &office2013s
[salt_pos
];
7453 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,
7459 office2013
->encryptedVerifier
[0],
7460 office2013
->encryptedVerifier
[1],
7461 office2013
->encryptedVerifier
[2],
7462 office2013
->encryptedVerifier
[3],
7463 office2013
->encryptedVerifierHash
[0],
7464 office2013
->encryptedVerifierHash
[1],
7465 office2013
->encryptedVerifierHash
[2],
7466 office2013
->encryptedVerifierHash
[3],
7467 office2013
->encryptedVerifierHash
[4],
7468 office2013
->encryptedVerifierHash
[5],
7469 office2013
->encryptedVerifierHash
[6],
7470 office2013
->encryptedVerifierHash
[7]);
7472 else if (hash_mode
== 9700)
7474 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7476 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7478 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7479 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7480 byte_swap_32 (salt
.salt_buf
[0]),
7481 byte_swap_32 (salt
.salt_buf
[1]),
7482 byte_swap_32 (salt
.salt_buf
[2]),
7483 byte_swap_32 (salt
.salt_buf
[3]),
7484 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7485 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7486 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7487 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7488 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7489 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7490 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7491 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7493 else if (hash_mode
== 9710)
7495 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7497 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7499 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7500 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7501 byte_swap_32 (salt
.salt_buf
[0]),
7502 byte_swap_32 (salt
.salt_buf
[1]),
7503 byte_swap_32 (salt
.salt_buf
[2]),
7504 byte_swap_32 (salt
.salt_buf
[3]),
7505 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7506 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7507 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7508 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7509 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7510 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7511 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7512 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7514 else if (hash_mode
== 9720)
7516 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7518 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7520 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7522 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7523 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7524 byte_swap_32 (salt
.salt_buf
[0]),
7525 byte_swap_32 (salt
.salt_buf
[1]),
7526 byte_swap_32 (salt
.salt_buf
[2]),
7527 byte_swap_32 (salt
.salt_buf
[3]),
7528 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7529 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7530 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7531 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7532 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7533 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7534 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7535 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7542 else if (hash_mode
== 9800)
7544 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7546 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7548 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7549 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7554 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7555 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7556 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7557 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7558 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7559 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7560 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7561 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7562 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7564 else if (hash_mode
== 9810)
7566 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7568 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7570 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7571 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7576 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7577 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7578 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7579 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7580 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7581 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7582 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7583 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7584 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7586 else if (hash_mode
== 9820)
7588 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7590 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7592 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7594 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7595 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7600 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7601 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7602 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7603 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7604 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7605 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7606 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7607 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7608 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7615 else if (hash_mode
== 10000)
7619 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7621 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7623 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7627 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7628 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7629 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7630 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7631 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7632 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7633 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7634 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7635 digest_buf
[8] = 0; // needed for base64_encode ()
7637 char tmp_buf
[64] = { 0 };
7639 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7643 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7645 else if (hash_mode
== 10100)
7647 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7652 byte_swap_32 (salt
.salt_buf
[0]),
7653 byte_swap_32 (salt
.salt_buf
[1]),
7654 byte_swap_32 (salt
.salt_buf
[2]),
7655 byte_swap_32 (salt
.salt_buf
[3]));
7657 else if (hash_mode
== 10200)
7659 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7661 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7665 char challenge
[100] = { 0 };
7667 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7671 char tmp_buf
[100] = { 0 };
7673 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7674 (char *) cram_md5
->user
,
7680 char response
[100] = { 0 };
7682 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7684 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7686 else if (hash_mode
== 10300)
7688 char tmp_buf
[100] = { 0 };
7690 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7691 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7693 uint tmp_len
= 20 + salt
.salt_len
;
7697 char base64_encoded
[100] = { 0 };
7699 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7701 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7703 else if (hash_mode
== 10400)
7705 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7707 pdf_t
*pdf
= &pdfs
[salt_pos
];
7709 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",
7717 byte_swap_32 (pdf
->id_buf
[0]),
7718 byte_swap_32 (pdf
->id_buf
[1]),
7719 byte_swap_32 (pdf
->id_buf
[2]),
7720 byte_swap_32 (pdf
->id_buf
[3]),
7722 byte_swap_32 (pdf
->u_buf
[0]),
7723 byte_swap_32 (pdf
->u_buf
[1]),
7724 byte_swap_32 (pdf
->u_buf
[2]),
7725 byte_swap_32 (pdf
->u_buf
[3]),
7726 byte_swap_32 (pdf
->u_buf
[4]),
7727 byte_swap_32 (pdf
->u_buf
[5]),
7728 byte_swap_32 (pdf
->u_buf
[6]),
7729 byte_swap_32 (pdf
->u_buf
[7]),
7731 byte_swap_32 (pdf
->o_buf
[0]),
7732 byte_swap_32 (pdf
->o_buf
[1]),
7733 byte_swap_32 (pdf
->o_buf
[2]),
7734 byte_swap_32 (pdf
->o_buf
[3]),
7735 byte_swap_32 (pdf
->o_buf
[4]),
7736 byte_swap_32 (pdf
->o_buf
[5]),
7737 byte_swap_32 (pdf
->o_buf
[6]),
7738 byte_swap_32 (pdf
->o_buf
[7])
7741 else if (hash_mode
== 10410)
7743 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7745 pdf_t
*pdf
= &pdfs
[salt_pos
];
7747 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",
7755 byte_swap_32 (pdf
->id_buf
[0]),
7756 byte_swap_32 (pdf
->id_buf
[1]),
7757 byte_swap_32 (pdf
->id_buf
[2]),
7758 byte_swap_32 (pdf
->id_buf
[3]),
7760 byte_swap_32 (pdf
->u_buf
[0]),
7761 byte_swap_32 (pdf
->u_buf
[1]),
7762 byte_swap_32 (pdf
->u_buf
[2]),
7763 byte_swap_32 (pdf
->u_buf
[3]),
7764 byte_swap_32 (pdf
->u_buf
[4]),
7765 byte_swap_32 (pdf
->u_buf
[5]),
7766 byte_swap_32 (pdf
->u_buf
[6]),
7767 byte_swap_32 (pdf
->u_buf
[7]),
7769 byte_swap_32 (pdf
->o_buf
[0]),
7770 byte_swap_32 (pdf
->o_buf
[1]),
7771 byte_swap_32 (pdf
->o_buf
[2]),
7772 byte_swap_32 (pdf
->o_buf
[3]),
7773 byte_swap_32 (pdf
->o_buf
[4]),
7774 byte_swap_32 (pdf
->o_buf
[5]),
7775 byte_swap_32 (pdf
->o_buf
[6]),
7776 byte_swap_32 (pdf
->o_buf
[7])
7779 else if (hash_mode
== 10420)
7781 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7783 pdf_t
*pdf
= &pdfs
[salt_pos
];
7785 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7787 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",
7795 byte_swap_32 (pdf
->id_buf
[0]),
7796 byte_swap_32 (pdf
->id_buf
[1]),
7797 byte_swap_32 (pdf
->id_buf
[2]),
7798 byte_swap_32 (pdf
->id_buf
[3]),
7800 byte_swap_32 (pdf
->u_buf
[0]),
7801 byte_swap_32 (pdf
->u_buf
[1]),
7802 byte_swap_32 (pdf
->u_buf
[2]),
7803 byte_swap_32 (pdf
->u_buf
[3]),
7804 byte_swap_32 (pdf
->u_buf
[4]),
7805 byte_swap_32 (pdf
->u_buf
[5]),
7806 byte_swap_32 (pdf
->u_buf
[6]),
7807 byte_swap_32 (pdf
->u_buf
[7]),
7809 byte_swap_32 (pdf
->o_buf
[0]),
7810 byte_swap_32 (pdf
->o_buf
[1]),
7811 byte_swap_32 (pdf
->o_buf
[2]),
7812 byte_swap_32 (pdf
->o_buf
[3]),
7813 byte_swap_32 (pdf
->o_buf
[4]),
7814 byte_swap_32 (pdf
->o_buf
[5]),
7815 byte_swap_32 (pdf
->o_buf
[6]),
7816 byte_swap_32 (pdf
->o_buf
[7]),
7824 else if (hash_mode
== 10500)
7826 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7828 pdf_t
*pdf
= &pdfs
[salt_pos
];
7830 if (pdf
->id_len
== 32)
7832 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",
7840 byte_swap_32 (pdf
->id_buf
[0]),
7841 byte_swap_32 (pdf
->id_buf
[1]),
7842 byte_swap_32 (pdf
->id_buf
[2]),
7843 byte_swap_32 (pdf
->id_buf
[3]),
7844 byte_swap_32 (pdf
->id_buf
[4]),
7845 byte_swap_32 (pdf
->id_buf
[5]),
7846 byte_swap_32 (pdf
->id_buf
[6]),
7847 byte_swap_32 (pdf
->id_buf
[7]),
7849 byte_swap_32 (pdf
->u_buf
[0]),
7850 byte_swap_32 (pdf
->u_buf
[1]),
7851 byte_swap_32 (pdf
->u_buf
[2]),
7852 byte_swap_32 (pdf
->u_buf
[3]),
7853 byte_swap_32 (pdf
->u_buf
[4]),
7854 byte_swap_32 (pdf
->u_buf
[5]),
7855 byte_swap_32 (pdf
->u_buf
[6]),
7856 byte_swap_32 (pdf
->u_buf
[7]),
7858 byte_swap_32 (pdf
->o_buf
[0]),
7859 byte_swap_32 (pdf
->o_buf
[1]),
7860 byte_swap_32 (pdf
->o_buf
[2]),
7861 byte_swap_32 (pdf
->o_buf
[3]),
7862 byte_swap_32 (pdf
->o_buf
[4]),
7863 byte_swap_32 (pdf
->o_buf
[5]),
7864 byte_swap_32 (pdf
->o_buf
[6]),
7865 byte_swap_32 (pdf
->o_buf
[7])
7870 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",
7878 byte_swap_32 (pdf
->id_buf
[0]),
7879 byte_swap_32 (pdf
->id_buf
[1]),
7880 byte_swap_32 (pdf
->id_buf
[2]),
7881 byte_swap_32 (pdf
->id_buf
[3]),
7883 byte_swap_32 (pdf
->u_buf
[0]),
7884 byte_swap_32 (pdf
->u_buf
[1]),
7885 byte_swap_32 (pdf
->u_buf
[2]),
7886 byte_swap_32 (pdf
->u_buf
[3]),
7887 byte_swap_32 (pdf
->u_buf
[4]),
7888 byte_swap_32 (pdf
->u_buf
[5]),
7889 byte_swap_32 (pdf
->u_buf
[6]),
7890 byte_swap_32 (pdf
->u_buf
[7]),
7892 byte_swap_32 (pdf
->o_buf
[0]),
7893 byte_swap_32 (pdf
->o_buf
[1]),
7894 byte_swap_32 (pdf
->o_buf
[2]),
7895 byte_swap_32 (pdf
->o_buf
[3]),
7896 byte_swap_32 (pdf
->o_buf
[4]),
7897 byte_swap_32 (pdf
->o_buf
[5]),
7898 byte_swap_32 (pdf
->o_buf
[6]),
7899 byte_swap_32 (pdf
->o_buf
[7])
7903 else if (hash_mode
== 10600)
7905 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7907 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7908 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7910 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7912 else if (hash_mode
== 10700)
7914 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7916 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7917 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7919 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7921 else if (hash_mode
== 10900)
7923 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7925 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7926 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7928 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7930 else if (hash_mode
== 11100)
7932 u32 salt_challenge
= salt
.salt_buf
[0];
7934 salt_challenge
= byte_swap_32 (salt_challenge
);
7936 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7938 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7939 SIGNATURE_POSTGRESQL_AUTH
,
7947 else if (hash_mode
== 11200)
7949 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7950 SIGNATURE_MYSQL_AUTH
,
7951 (unsigned char *) salt
.salt_buf
,
7958 else if (hash_mode
== 11300)
7960 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7962 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7964 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7965 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7966 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7968 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7969 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7970 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7972 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7974 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7976 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7979 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7981 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7983 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7986 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7988 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
7990 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7993 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
7994 SIGNATURE_BITCOIN_WALLET
,
7998 (unsigned char *) salt
.salt_buf
,
8006 free (cry_master_buf
);
8008 free (public_key_buf
);
8010 else if (hash_mode
== 11400)
8012 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8014 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8015 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8017 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8019 else if (hash_mode
== 11600)
8021 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8023 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8025 const uint data_len
= seven_zip
->data_len
;
8027 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8029 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8031 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8033 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8036 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8037 SIGNATURE_SEVEN_ZIP
,
8041 (char *) seven_zip
->salt_buf
,
8043 seven_zip
->iv_buf
[0],
8044 seven_zip
->iv_buf
[1],
8045 seven_zip
->iv_buf
[2],
8046 seven_zip
->iv_buf
[3],
8048 seven_zip
->data_len
,
8049 seven_zip
->unpack_size
,
8054 else if (hash_mode
== 11700)
8056 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8066 else if (hash_mode
== 11800)
8068 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8086 else if (hash_mode
== 11900)
8088 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8090 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8091 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8093 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8095 else if (hash_mode
== 12000)
8097 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8099 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8100 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8102 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8104 else if (hash_mode
== 12100)
8106 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8108 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8109 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8111 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8113 else if (hash_mode
== 12200)
8115 uint
*ptr_digest
= digest_buf
;
8116 uint
*ptr_salt
= salt
.salt_buf
;
8118 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8125 else if (hash_mode
== 12300)
8127 uint
*ptr_digest
= digest_buf
;
8128 uint
*ptr_salt
= salt
.salt_buf
;
8130 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",
8131 ptr_digest
[ 0], ptr_digest
[ 1],
8132 ptr_digest
[ 2], ptr_digest
[ 3],
8133 ptr_digest
[ 4], ptr_digest
[ 5],
8134 ptr_digest
[ 6], ptr_digest
[ 7],
8135 ptr_digest
[ 8], ptr_digest
[ 9],
8136 ptr_digest
[10], ptr_digest
[11],
8137 ptr_digest
[12], ptr_digest
[13],
8138 ptr_digest
[14], ptr_digest
[15],
8144 else if (hash_mode
== 12400)
8146 // encode iteration count
8148 char salt_iter
[5] = { 0 };
8150 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8151 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8152 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8153 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8158 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8159 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8160 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8161 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8166 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8168 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8169 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8171 memcpy (tmp_buf
, digest_buf
, 8);
8173 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8177 // fill the resulting buffer
8179 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8181 else if (hash_mode
== 12500)
8183 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8185 byte_swap_32 (salt
.salt_buf
[0]),
8186 byte_swap_32 (salt
.salt_buf
[1]),
8192 else if (hash_mode
== 12600)
8194 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8195 digest_buf
[0] + salt
.salt_buf_pc
[0],
8196 digest_buf
[1] + salt
.salt_buf_pc
[1],
8197 digest_buf
[2] + salt
.salt_buf_pc
[2],
8198 digest_buf
[3] + salt
.salt_buf_pc
[3],
8199 digest_buf
[4] + salt
.salt_buf_pc
[4],
8200 digest_buf
[5] + salt
.salt_buf_pc
[5],
8201 digest_buf
[6] + salt
.salt_buf_pc
[6],
8202 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8204 else if (hash_mode
== 12700)
8206 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8208 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8209 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8211 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8213 else if (hash_mode
== 12800)
8215 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8217 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",
8230 byte_swap_32 (digest_buf
[0]),
8231 byte_swap_32 (digest_buf
[1]),
8232 byte_swap_32 (digest_buf
[2]),
8233 byte_swap_32 (digest_buf
[3]),
8234 byte_swap_32 (digest_buf
[4]),
8235 byte_swap_32 (digest_buf
[5]),
8236 byte_swap_32 (digest_buf
[6]),
8237 byte_swap_32 (digest_buf
[7])
8240 else if (hash_mode
== 12900)
8242 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",
8251 byte_swap_32 (digest_buf
[0]),
8252 byte_swap_32 (digest_buf
[1]),
8253 byte_swap_32 (digest_buf
[2]),
8254 byte_swap_32 (digest_buf
[3]),
8255 byte_swap_32 (digest_buf
[4]),
8256 byte_swap_32 (digest_buf
[5]),
8257 byte_swap_32 (digest_buf
[6]),
8258 byte_swap_32 (digest_buf
[7]),
8265 else if (hash_mode
== 13000)
8267 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8269 rar5_t
*rar5
= &rar5s
[salt_pos
];
8271 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8281 byte_swap_32 (digest_buf
[0]),
8282 byte_swap_32 (digest_buf
[1])
8287 if (hash_type
== HASH_TYPE_MD4
)
8289 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8295 else if (hash_type
== HASH_TYPE_MD5
)
8297 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8303 else if (hash_type
== HASH_TYPE_SHA1
)
8305 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8312 else if (hash_type
== HASH_TYPE_SHA256
)
8314 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8324 else if (hash_type
== HASH_TYPE_SHA384
)
8326 uint
*ptr
= digest_buf
;
8328 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8336 else if (hash_type
== HASH_TYPE_SHA512
)
8338 uint
*ptr
= digest_buf
;
8340 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8350 else if (hash_type
== HASH_TYPE_LM
)
8352 snprintf (out_buf
, len
-1, "%08x%08x",
8356 else if (hash_type
== HASH_TYPE_ORACLEH
)
8358 snprintf (out_buf
, len
-1, "%08X%08X",
8362 else if (hash_type
== HASH_TYPE_BCRYPT
)
8364 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8365 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8367 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8369 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8371 else if (hash_type
== HASH_TYPE_KECCAK
)
8373 uint
*ptr
= digest_buf
;
8375 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",
8403 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8405 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8407 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8414 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8416 digest_buf
[ 0] = digest_buf
[ 0];
8417 digest_buf
[ 1] = digest_buf
[ 1];
8418 digest_buf
[ 2] = digest_buf
[ 2];
8419 digest_buf
[ 3] = digest_buf
[ 3];
8420 digest_buf
[ 4] = digest_buf
[ 4];
8421 digest_buf
[ 5] = digest_buf
[ 5];
8422 digest_buf
[ 6] = digest_buf
[ 6];
8423 digest_buf
[ 7] = digest_buf
[ 7];
8424 digest_buf
[ 8] = digest_buf
[ 8];
8425 digest_buf
[ 9] = digest_buf
[ 9];
8426 digest_buf
[10] = digest_buf
[10];
8427 digest_buf
[11] = digest_buf
[11];
8428 digest_buf
[12] = digest_buf
[12];
8429 digest_buf
[13] = digest_buf
[13];
8430 digest_buf
[14] = digest_buf
[14];
8431 digest_buf
[15] = digest_buf
[15];
8433 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8451 else if (hash_type
== HASH_TYPE_GOST
)
8453 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8463 else if (hash_type
== HASH_TYPE_MYSQL
)
8465 snprintf (out_buf
, len
-1, "%08x%08x",
8469 else if (hash_type
== HASH_TYPE_LOTUS5
)
8471 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8477 else if (hash_type
== HASH_TYPE_LOTUS6
)
8479 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8480 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8481 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8482 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8484 char buf
[16] = { 0 };
8486 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8487 memcpy (buf
+ 5, digest_buf
, 9);
8491 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8493 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8496 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8498 else if (hash_type
== HASH_TYPE_LOTUS8
)
8500 char buf
[52] = { 0 };
8504 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8510 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8514 buf
[26] = salt
.salt_buf_pc
[0];
8515 buf
[27] = salt
.salt_buf_pc
[1];
8519 memcpy (buf
+ 28, digest_buf
, 8);
8521 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8525 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8527 else if (hash_type
== HASH_TYPE_CRC32
)
8529 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8533 if (salt_type
== SALT_TYPE_INTERN
)
8535 size_t pos
= strlen (out_buf
);
8537 out_buf
[pos
] = data
.separator
;
8539 char *ptr
= (char *) salt
.salt_buf
;
8541 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8543 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8547 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8549 memset (hccap
, 0, sizeof (hccap_t
));
8551 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8553 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8555 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8556 wpa_t
*wpa
= &wpas
[salt_pos
];
8558 hccap
->keyver
= wpa
->keyver
;
8560 hccap
->eapol_size
= wpa
->eapol_size
;
8562 if (wpa
->keyver
!= 1)
8564 uint eapol_tmp
[64] = { 0 };
8566 for (uint i
= 0; i
< 64; i
++)
8568 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8571 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8575 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8578 uint pke_tmp
[25] = { 0 };
8580 for (int i
= 5; i
< 25; i
++)
8582 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8585 char *pke_ptr
= (char *) pke_tmp
;
8587 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8588 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8589 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8590 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8592 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8594 uint dgst_size
= data
.dgst_size
;
8596 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8598 if (wpa
->keyver
!= 1)
8600 uint digest_tmp
[4] = { 0 };
8602 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8603 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8604 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8605 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8607 memcpy (hccap
->keymic
, digest_tmp
, 16);
8611 memcpy (hccap
->keymic
, digest_ptr
, 16);
8615 void SuspendThreads ()
8617 if (data
.devices_status
== STATUS_RUNNING
)
8619 hc_timer_set (&data
.timer_paused
);
8621 data
.devices_status
= STATUS_PAUSED
;
8623 log_info ("Paused");
8627 void ResumeThreads ()
8629 if (data
.devices_status
== STATUS_PAUSED
)
8633 hc_timer_get (data
.timer_paused
, ms_paused
);
8635 data
.ms_paused
+= ms_paused
;
8637 data
.devices_status
= STATUS_RUNNING
;
8639 log_info ("Resumed");
8645 if (data
.devices_status
!= STATUS_RUNNING
) return;
8647 data
.devices_status
= STATUS_BYPASS
;
8649 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8652 void stop_at_checkpoint ()
8654 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8656 if (data
.devices_status
!= STATUS_RUNNING
) return;
8659 // this feature only makes sense if --restore-disable was not specified
8661 if (data
.restore_disable
== 1)
8663 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8668 // check if monitoring of Restore Point updates should be enabled or disabled
8670 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8672 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8674 // save the current restore point value
8676 data
.checkpoint_cur_words
= get_lowest_words_done ();
8678 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8682 data
.devices_status
= STATUS_RUNNING
;
8684 // reset the global value for checkpoint checks
8686 data
.checkpoint_cur_words
= 0;
8688 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8694 if (data
.devices_status
== STATUS_INIT
) return;
8695 if (data
.devices_status
== STATUS_STARTING
) return;
8697 data
.devices_status
= STATUS_ABORTED
;
8702 if (data
.devices_status
== STATUS_INIT
) return;
8703 if (data
.devices_status
== STATUS_STARTING
) return;
8705 data
.devices_status
= STATUS_QUIT
;
8708 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8710 FILE *fp
= fopen (kernel_file
, "rb");
8716 memset (&st
, 0, sizeof (st
));
8718 stat (kernel_file
, &st
);
8720 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8722 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8724 if (num_read
!= (size_t) st
.st_size
)
8726 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8733 buf
[st
.st_size
] = 0;
8735 for (int i
= 0; i
< num_devices
; i
++)
8737 kernel_lengths
[i
] = (size_t) st
.st_size
;
8739 kernel_sources
[i
] = buf
;
8744 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8752 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8754 if (binary_size
> 0)
8756 FILE *fp
= fopen (dst
, "wb");
8759 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8770 restore_data_t
*init_restore (int argc
, char **argv
)
8772 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8774 if (data
.restore_disable
== 0)
8776 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8780 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8784 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8793 char pidbin
[BUFSIZ
] = { 0 };
8795 int pidbin_len
= -1;
8798 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8800 FILE *fd
= fopen (pidbin
, "rb");
8804 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8806 pidbin
[pidbin_len
] = 0;
8810 char *argv0_r
= strrchr (argv
[0], '/');
8812 char *pidbin_r
= strrchr (pidbin
, '/');
8814 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8816 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8818 if (strcmp (argv0_r
, pidbin_r
) == 0)
8820 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8827 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8829 char pidbin2
[BUFSIZ
] = { 0 };
8831 int pidbin2_len
= -1;
8833 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8834 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8836 pidbin
[pidbin_len
] = 0;
8837 pidbin2
[pidbin2_len
] = 0;
8841 if (strcmp (pidbin
, pidbin2
) == 0)
8843 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8851 if (rd
->version_bin
< RESTORE_MIN
)
8853 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8860 memset (rd
, 0, sizeof (restore_data_t
));
8862 rd
->version_bin
= VERSION_BIN
;
8865 rd
->pid
= getpid ();
8867 rd
->pid
= GetCurrentProcessId ();
8870 if (getcwd (rd
->cwd
, 255) == NULL
)
8883 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8885 FILE *fp
= fopen (eff_restore_file
, "rb");
8889 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8894 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8896 log_error ("ERROR: cannot read %s", eff_restore_file
);
8901 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8903 for (uint i
= 0; i
< rd
->argc
; i
++)
8905 char buf
[BUFSIZ
] = { 0 };
8907 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8909 log_error ("ERROR: cannot read %s", eff_restore_file
);
8914 size_t len
= strlen (buf
);
8916 if (len
) buf
[len
- 1] = 0;
8918 rd
->argv
[i
] = mystrdup (buf
);
8923 char new_cwd
[1024] = { 0 };
8925 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8929 log_error ("Restore file is corrupted");
8932 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8934 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8936 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8941 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8944 if (chdir (rd
->cwd
))
8946 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8952 u64
get_lowest_words_done ()
8956 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8958 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8960 if (device_param
->skipped
) continue;
8962 const u64 words_done
= device_param
->words_done
;
8964 if (words_done
< words_cur
) words_cur
= words_done
;
8967 // It's possible that a device's workload isn't finished right after a restore-case.
8968 // In that case, this function would return 0 and overwrite the real restore point
8969 // There's also data.words_cur which is set to rd->words_cur but it changes while
8970 // the attack is running therefore we should stick to rd->words_cur.
8971 // Note that -s influences rd->words_cur we should keep a close look on that.
8973 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
8978 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
8980 u64 words_cur
= get_lowest_words_done ();
8982 rd
->words_cur
= words_cur
;
8984 FILE *fp
= fopen (new_restore_file
, "wb");
8988 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
8993 if (setvbuf (fp
, NULL
, _IONBF
, 0))
8995 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9000 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9002 for (uint i
= 0; i
< rd
->argc
; i
++)
9004 fprintf (fp
, "%s", rd
->argv
[i
]);
9010 fsync (fileno (fp
));
9015 void cycle_restore ()
9017 const char *eff_restore_file
= data
.eff_restore_file
;
9018 const char *new_restore_file
= data
.new_restore_file
;
9020 restore_data_t
*rd
= data
.rd
;
9022 write_restore (new_restore_file
, rd
);
9026 memset (&st
, 0, sizeof(st
));
9028 if (stat (eff_restore_file
, &st
) == 0)
9030 if (unlink (eff_restore_file
))
9032 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9036 if (rename (new_restore_file
, eff_restore_file
))
9038 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9042 void check_checkpoint ()
9044 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9046 u64 words_cur
= get_lowest_words_done ();
9048 if (words_cur
!= data
.checkpoint_cur_words
)
9058 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9062 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9064 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9066 myfree (alias
->device_name
);
9067 myfree (alias
->alias_name
);
9070 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9072 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9074 myfree (entry
->device_name
);
9077 myfree (tuning_db
->alias_buf
);
9078 myfree (tuning_db
->entry_buf
);
9083 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9085 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9087 int num_lines
= count_lines (fp
);
9089 // a bit over-allocated
9091 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9092 tuning_db
->alias_cnt
= 0;
9094 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9095 tuning_db
->entry_cnt
= 0;
9100 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9102 FILE *fp
= fopen (tuning_db_file
, "rb");
9106 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9111 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9121 char *line_buf
= fgets (buf
, sizeof (buf
) - 1, fp
);
9123 if (line_buf
== NULL
) break;
9127 const int line_len
= in_superchop (line_buf
);
9129 if (line_len
== 0) continue;
9131 if (line_buf
[0] == '#') continue;
9135 char *token_ptr
[7] = { NULL
};
9139 char *next
= strtok (line_buf
, "\t ");
9141 token_ptr
[token_cnt
] = next
;
9145 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9147 token_ptr
[token_cnt
] = next
;
9154 char *device_name
= token_ptr
[0];
9155 char *alias_name
= token_ptr
[1];
9157 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9159 alias
->device_name
= mystrdup (device_name
);
9160 alias
->alias_name
= mystrdup (alias_name
);
9162 tuning_db
->alias_cnt
++;
9164 else if (token_cnt
== 7)
9166 if ((token_ptr
[1][0] != '0') &&
9167 (token_ptr
[1][0] != '1') &&
9168 (token_ptr
[1][0] != '3') &&
9169 (token_ptr
[1][0] != '*'))
9171 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9176 if ((token_ptr
[3][0] != '1') &&
9177 (token_ptr
[3][0] != '2') &&
9178 (token_ptr
[3][0] != '3') &&
9179 (token_ptr
[3][0] != '*'))
9181 log_info ("WARNING: Tuning-db: Invalid workload_profile '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9186 if ((token_ptr
[4][0] != '1') &&
9187 (token_ptr
[4][0] != '2') &&
9188 (token_ptr
[4][0] != '4') &&
9189 (token_ptr
[4][0] != '8') &&
9190 (token_ptr
[4][0] != 'N'))
9192 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[4][0], line_num
);
9197 char *device_name
= token_ptr
[0];
9199 int attack_mode
= -1;
9201 int workload_profile
= -1;
9202 int vector_width
= -1;
9203 int kernel_accel
= -1;
9204 int kernel_loops
= -1;
9206 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9207 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9208 if (token_ptr
[3][0] != '*') workload_profile
= atoi (token_ptr
[3]);
9209 if (token_ptr
[4][0] != 'N') vector_width
= atoi (token_ptr
[4]);
9211 kernel_accel
= atoi (token_ptr
[5]);
9213 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9215 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9220 kernel_loops
= atoi (token_ptr
[6]);
9222 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9224 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9229 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9231 entry
->device_name
= mystrdup (device_name
);
9232 entry
->attack_mode
= attack_mode
;
9233 entry
->hash_type
= hash_type
;
9234 entry
->workload_profile
= workload_profile
;
9235 entry
->vector_width
= vector_width
;
9236 entry
->kernel_accel
= kernel_accel
;
9237 entry
->kernel_loops
= kernel_loops
;
9239 tuning_db
->entry_cnt
++;
9243 // todo: some warning message
9251 // todo: print loaded 'cnt' message
9253 // sort the database
9255 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9256 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9261 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, char *device_name
, int attack_mode
, int hash_type
, int workload_profile
)
9263 static tuning_db_entry_t s
;
9265 // first we need to convert all spaces in the device_name to underscore
9267 char *device_name_nospace
= strdup (device_name
);
9269 int device_name_length
= strlen (device_name_nospace
);
9273 for (i
= 0; i
< device_name_length
; i
++)
9275 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9278 // find out if there's an alias configured
9280 tuning_db_alias_t a
;
9282 a
.device_name
= device_name_nospace
;
9284 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
);
9286 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9288 // attack-mode 6 and 7 are attack-mode 1 basically
9290 if (attack_mode
== 6) attack_mode
= 1;
9291 if (attack_mode
== 7) attack_mode
= 1;
9293 // bsearch is not ideal but fast enough
9295 s
.device_name
= device_name_nospace
;
9296 s
.attack_mode
= attack_mode
;
9297 s
.hash_type
= hash_type
;
9298 s
.workload_profile
= workload_profile
;
9300 tuning_db_entry_t
*entry
= NULL
;
9302 // this will produce all 2^4 combinations required
9304 for (i
= 0; i
< 16; i
++)
9306 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9307 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9308 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9309 s
.workload_profile
= (i
& 8) ? -1 : workload_profile
;
9311 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9313 if (entry
!= NULL
) break;
9315 // in non-wildcard mode also check the alias_name
9317 if (((i
& 1) == 0) && (alias_name
!= NULL
))
9319 s
.device_name
= alias_name
;
9321 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9323 if (entry
!= NULL
) break;
9327 // if still not found use some defaults
9331 s
.vector_width
= TUNING_DB_DEFAULT_VECTOR_WIDTH
;
9332 s
.kernel_accel
= TUNING_DB_DEFAULT_KERNEL_ACCEL
;
9333 s
.kernel_loops
= TUNING_DB_DEFAULT_KERNEL_LOOPS
;
9338 // free converted device_name
9340 myfree (device_name_nospace
);
9349 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9351 u8 tmp
[256] = { 0 };
9353 if (salt_len
> sizeof (tmp
))
9358 memcpy (tmp
, in
, salt_len
);
9360 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9362 if ((salt_len
% 2) == 0)
9364 u32 new_salt_len
= salt_len
/ 2;
9366 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9371 tmp
[i
] = hex_convert (p1
) << 0;
9372 tmp
[i
] |= hex_convert (p0
) << 4;
9375 salt_len
= new_salt_len
;
9382 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9384 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9387 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9389 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9393 u32
*tmp_uint
= (u32
*) tmp
;
9395 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9396 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9397 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9398 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9399 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9400 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9401 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9402 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9403 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9404 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9406 salt_len
= salt_len
* 2;
9414 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9416 lowercase (tmp
, salt_len
);
9419 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9421 uppercase (tmp
, salt_len
);
9426 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9431 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9436 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9438 u32
*tmp_uint
= (uint
*) tmp
;
9444 for (u32 i
= 0; i
< max
; i
++)
9446 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9449 // Important: we may need to increase the length of memcpy since
9450 // we don't want to "loose" some swapped bytes (could happen if
9451 // they do not perfectly fit in the 4-byte blocks)
9452 // Memcpy does always copy the bytes in the BE order, but since
9453 // we swapped them, some important bytes could be in positions
9454 // we normally skip with the original len
9456 if (len
% 4) len
+= 4 - (len
% 4);
9459 memcpy (out
, tmp
, len
);
9464 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9466 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9468 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9470 u32
*digest
= (u32
*) hash_buf
->digest
;
9472 salt_t
*salt
= hash_buf
->salt
;
9474 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9476 char *iter_pos
= input_buf
+ 4;
9478 salt
->salt_iter
= 1 << atoi (iter_pos
);
9480 char *salt_pos
= strchr (iter_pos
, '$');
9482 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9488 salt
->salt_len
= salt_len
;
9490 u8 tmp_buf
[100] = { 0 };
9492 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9494 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9496 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9498 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9499 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9500 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9501 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9503 char *hash_pos
= salt_pos
+ 22;
9505 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9507 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9509 memcpy (digest
, tmp_buf
, 24);
9511 digest
[0] = byte_swap_32 (digest
[0]);
9512 digest
[1] = byte_swap_32 (digest
[1]);
9513 digest
[2] = byte_swap_32 (digest
[2]);
9514 digest
[3] = byte_swap_32 (digest
[3]);
9515 digest
[4] = byte_swap_32 (digest
[4]);
9516 digest
[5] = byte_swap_32 (digest
[5]);
9518 digest
[5] &= ~0xff; // its just 23 not 24 !
9523 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9525 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9527 u32
*digest
= (u32
*) hash_buf
->digest
;
9529 u8 tmp_buf
[100] = { 0 };
9531 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9533 memcpy (digest
, tmp_buf
, 32);
9535 digest
[0] = byte_swap_32 (digest
[0]);
9536 digest
[1] = byte_swap_32 (digest
[1]);
9537 digest
[2] = byte_swap_32 (digest
[2]);
9538 digest
[3] = byte_swap_32 (digest
[3]);
9539 digest
[4] = byte_swap_32 (digest
[4]);
9540 digest
[5] = byte_swap_32 (digest
[5]);
9541 digest
[6] = byte_swap_32 (digest
[6]);
9542 digest
[7] = byte_swap_32 (digest
[7]);
9544 digest
[0] -= SHA256M_A
;
9545 digest
[1] -= SHA256M_B
;
9546 digest
[2] -= SHA256M_C
;
9547 digest
[3] -= SHA256M_D
;
9548 digest
[4] -= SHA256M_E
;
9549 digest
[5] -= SHA256M_F
;
9550 digest
[6] -= SHA256M_G
;
9551 digest
[7] -= SHA256M_H
;
9556 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9558 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9560 u32
*digest
= (u32
*) hash_buf
->digest
;
9562 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9563 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9565 digest
[0] = byte_swap_32 (digest
[0]);
9566 digest
[1] = byte_swap_32 (digest
[1]);
9570 IP (digest
[0], digest
[1], tt
);
9572 digest
[0] = digest
[0];
9573 digest
[1] = digest
[1];
9580 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9582 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9584 u32
*digest
= (u32
*) hash_buf
->digest
;
9586 salt_t
*salt
= hash_buf
->salt
;
9588 char *hash_pos
= input_buf
+ 8;
9590 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9591 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9592 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9593 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9594 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9596 digest
[0] -= SHA1M_A
;
9597 digest
[1] -= SHA1M_B
;
9598 digest
[2] -= SHA1M_C
;
9599 digest
[3] -= SHA1M_D
;
9600 digest
[4] -= SHA1M_E
;
9604 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9606 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9608 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9610 salt
->salt_len
= salt_len
;
9615 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9617 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9619 u64
*digest
= (u64
*) hash_buf
->digest
;
9621 salt_t
*salt
= hash_buf
->salt
;
9623 char *hash_pos
= input_buf
+ 8;
9625 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9626 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9627 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9628 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9629 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9630 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9631 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9632 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9634 digest
[0] -= SHA512M_A
;
9635 digest
[1] -= SHA512M_B
;
9636 digest
[2] -= SHA512M_C
;
9637 digest
[3] -= SHA512M_D
;
9638 digest
[4] -= SHA512M_E
;
9639 digest
[5] -= SHA512M_F
;
9640 digest
[6] -= SHA512M_G
;
9641 digest
[7] -= SHA512M_H
;
9645 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9647 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9649 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9651 salt
->salt_len
= salt_len
;
9656 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9658 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9660 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9664 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9667 u32
*digest
= (u32
*) hash_buf
->digest
;
9669 salt_t
*salt
= hash_buf
->salt
;
9671 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9672 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9673 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9674 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9676 digest
[0] = byte_swap_32 (digest
[0]);
9677 digest
[1] = byte_swap_32 (digest
[1]);
9678 digest
[2] = byte_swap_32 (digest
[2]);
9679 digest
[3] = byte_swap_32 (digest
[3]);
9681 digest
[0] -= MD5M_A
;
9682 digest
[1] -= MD5M_B
;
9683 digest
[2] -= MD5M_C
;
9684 digest
[3] -= MD5M_D
;
9686 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9688 uint salt_len
= input_len
- 32 - 1;
9690 char *salt_buf
= input_buf
+ 32 + 1;
9692 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9694 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9696 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9698 salt
->salt_len
= salt_len
;
9703 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9705 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9707 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9711 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9716 char clean_input_buf
[32] = { 0 };
9718 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9719 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9721 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9725 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9731 clean_input_buf
[k
] = input_buf
[i
];
9739 u32
*digest
= (u32
*) hash_buf
->digest
;
9741 salt_t
*salt
= hash_buf
->salt
;
9743 u32 a
, b
, c
, d
, e
, f
;
9745 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9746 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9747 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9748 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9749 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9750 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9752 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9753 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9755 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9756 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9757 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9758 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9759 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9760 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9762 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9763 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9765 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9766 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9767 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9768 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9769 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9770 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9772 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9773 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9775 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9776 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9777 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9778 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9779 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9780 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9782 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9783 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9785 digest
[0] = byte_swap_32 (digest
[0]);
9786 digest
[1] = byte_swap_32 (digest
[1]);
9787 digest
[2] = byte_swap_32 (digest
[2]);
9788 digest
[3] = byte_swap_32 (digest
[3]);
9790 digest
[0] -= MD5M_A
;
9791 digest
[1] -= MD5M_B
;
9792 digest
[2] -= MD5M_C
;
9793 digest
[3] -= MD5M_D
;
9795 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9797 uint salt_len
= input_len
- 30 - 1;
9799 char *salt_buf
= input_buf
+ 30 + 1;
9801 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9803 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9805 // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
9806 if (salt_len
> 10) return (PARSER_SALT_LENGTH
);
9808 salt
->salt_len
= salt_len
;
9810 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9812 salt
->salt_len
+= 22;
9817 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9819 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9821 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9825 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9828 u32
*digest
= (u32
*) hash_buf
->digest
;
9830 salt_t
*salt
= hash_buf
->salt
;
9832 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9833 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9834 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9835 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9836 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
9838 digest
[0] -= SHA1M_A
;
9839 digest
[1] -= SHA1M_B
;
9840 digest
[2] -= SHA1M_C
;
9841 digest
[3] -= SHA1M_D
;
9842 digest
[4] -= SHA1M_E
;
9844 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9846 uint salt_len
= input_len
- 40 - 1;
9848 char *salt_buf
= input_buf
+ 40 + 1;
9850 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9852 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9854 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9856 salt
->salt_len
= salt_len
;
9861 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9863 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9865 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9869 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9872 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9874 char *iter_pos
= input_buf
+ 6;
9876 salt_t
*salt
= hash_buf
->salt
;
9878 uint iter
= atoi (iter_pos
);
9885 salt
->salt_iter
= iter
- 1;
9887 char *salt_pos
= strchr (iter_pos
, '#');
9889 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9893 char *digest_pos
= strchr (salt_pos
, '#');
9895 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9899 uint salt_len
= digest_pos
- salt_pos
- 1;
9901 u32
*digest
= (u32
*) hash_buf
->digest
;
9903 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
9904 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
9905 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
9906 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
9908 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9910 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9912 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9914 salt
->salt_len
= salt_len
;
9919 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9921 u32
*digest
= (u32
*) hash_buf
->digest
;
9923 salt_t
*salt
= hash_buf
->salt
;
9925 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
9929 memcpy (&in
, input_buf
, input_len
);
9931 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
9933 memcpy (digest
, in
.keymic
, 16);
9936 http://www.one-net.eu/jsw/j_sec/m_ptype.html
9937 The phrase "Pairwise key expansion"
9938 Access Point Address (referred to as Authenticator Address AA)
9939 Supplicant Address (referred to as Supplicant Address SA)
9940 Access Point Nonce (referred to as Authenticator Anonce)
9941 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
9944 uint salt_len
= strlen (in
.essid
);
9946 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
9948 salt
->salt_len
= salt_len
;
9950 salt
->salt_iter
= ROUNDS_WPA2
- 1;
9952 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
9954 memcpy (pke_ptr
, "Pairwise key expansion", 23);
9956 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
9958 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
9959 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
9963 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
9964 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
9967 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
9969 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
9970 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
9974 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
9975 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
9978 for (int i
= 0; i
< 25; i
++)
9980 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
9983 wpa
->keyver
= in
.keyver
;
9985 if (wpa
->keyver
> 255)
9987 log_info ("ATTENTION!");
9988 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
9989 log_info (" This could be due to a recent aircrack-ng bug.");
9990 log_info (" The key version was automatically reset to a reasonable value.");
9993 wpa
->keyver
&= 0xff;
9996 wpa
->eapol_size
= in
.eapol_size
;
9998 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10000 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10002 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10004 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10006 if (wpa
->keyver
== 1)
10012 digest
[0] = byte_swap_32 (digest
[0]);
10013 digest
[1] = byte_swap_32 (digest
[1]);
10014 digest
[2] = byte_swap_32 (digest
[2]);
10015 digest
[3] = byte_swap_32 (digest
[3]);
10017 for (int i
= 0; i
< 64; i
++)
10019 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10023 salt
->salt_buf
[10] = digest
[1];
10024 salt
->salt_buf
[11] = digest
[2];
10026 return (PARSER_OK
);
10029 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10031 u32
*digest
= (u32
*) hash_buf
->digest
;
10033 salt_t
*salt
= hash_buf
->salt
;
10035 if (input_len
== 0)
10037 log_error ("Password Safe v2 container not specified");
10042 FILE *fp
= fopen (input_buf
, "rb");
10046 log_error ("%s: %s", input_buf
, strerror (errno
));
10053 memset (&buf
, 0, sizeof (psafe2_hdr
));
10055 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10059 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10061 salt
->salt_buf
[0] = buf
.random
[0];
10062 salt
->salt_buf
[1] = buf
.random
[1];
10064 salt
->salt_len
= 8;
10065 salt
->salt_iter
= 1000;
10067 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10068 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10069 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10070 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10071 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10073 return (PARSER_OK
);
10076 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10078 u32
*digest
= (u32
*) hash_buf
->digest
;
10080 salt_t
*salt
= hash_buf
->salt
;
10082 if (input_len
== 0)
10084 log_error (".psafe3 not specified");
10089 FILE *fp
= fopen (input_buf
, "rb");
10093 log_error ("%s: %s", input_buf
, strerror (errno
));
10100 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10104 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10106 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10108 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10110 salt
->salt_iter
= in
.iterations
+ 1;
10112 salt
->salt_buf
[0] = in
.salt_buf
[0];
10113 salt
->salt_buf
[1] = in
.salt_buf
[1];
10114 salt
->salt_buf
[2] = in
.salt_buf
[2];
10115 salt
->salt_buf
[3] = in
.salt_buf
[3];
10116 salt
->salt_buf
[4] = in
.salt_buf
[4];
10117 salt
->salt_buf
[5] = in
.salt_buf
[5];
10118 salt
->salt_buf
[6] = in
.salt_buf
[6];
10119 salt
->salt_buf
[7] = in
.salt_buf
[7];
10121 salt
->salt_len
= 32;
10123 digest
[0] = in
.hash_buf
[0];
10124 digest
[1] = in
.hash_buf
[1];
10125 digest
[2] = in
.hash_buf
[2];
10126 digest
[3] = in
.hash_buf
[3];
10127 digest
[4] = in
.hash_buf
[4];
10128 digest
[5] = in
.hash_buf
[5];
10129 digest
[6] = in
.hash_buf
[6];
10130 digest
[7] = in
.hash_buf
[7];
10132 digest
[0] = byte_swap_32 (digest
[0]);
10133 digest
[1] = byte_swap_32 (digest
[1]);
10134 digest
[2] = byte_swap_32 (digest
[2]);
10135 digest
[3] = byte_swap_32 (digest
[3]);
10136 digest
[4] = byte_swap_32 (digest
[4]);
10137 digest
[5] = byte_swap_32 (digest
[5]);
10138 digest
[6] = byte_swap_32 (digest
[6]);
10139 digest
[7] = byte_swap_32 (digest
[7]);
10141 return (PARSER_OK
);
10144 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10146 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10148 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10150 u32
*digest
= (u32
*) hash_buf
->digest
;
10152 salt_t
*salt
= hash_buf
->salt
;
10154 char *iter_pos
= input_buf
+ 3;
10156 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10158 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10160 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10162 salt
->salt_iter
= salt_iter
;
10164 char *salt_pos
= iter_pos
+ 1;
10168 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10170 salt
->salt_len
= salt_len
;
10172 char *hash_pos
= salt_pos
+ salt_len
;
10174 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10176 return (PARSER_OK
);
10179 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10181 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10183 u32
*digest
= (u32
*) hash_buf
->digest
;
10185 salt_t
*salt
= hash_buf
->salt
;
10187 char *salt_pos
= input_buf
+ 3;
10189 uint iterations_len
= 0;
10191 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10195 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10197 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10198 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10202 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10206 iterations_len
+= 8;
10210 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10213 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10215 char *hash_pos
= strchr (salt_pos
, '$');
10217 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10219 uint salt_len
= hash_pos
- salt_pos
;
10221 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10223 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10225 salt
->salt_len
= salt_len
;
10229 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10231 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10233 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10235 return (PARSER_OK
);
10238 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10240 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10242 u32
*digest
= (u32
*) hash_buf
->digest
;
10244 salt_t
*salt
= hash_buf
->salt
;
10246 char *salt_pos
= input_buf
+ 6;
10248 uint iterations_len
= 0;
10250 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10254 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10256 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10257 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10261 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10265 iterations_len
+= 8;
10269 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10272 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10274 char *hash_pos
= strchr (salt_pos
, '$');
10276 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10278 uint salt_len
= hash_pos
- salt_pos
;
10280 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10282 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10284 salt
->salt_len
= salt_len
;
10288 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10290 return (PARSER_OK
);
10293 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10295 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10297 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10299 u32
*digest
= (u32
*) hash_buf
->digest
;
10301 salt_t
*salt
= hash_buf
->salt
;
10303 char *salt_pos
= input_buf
+ 14;
10305 char *hash_pos
= strchr (salt_pos
, '*');
10307 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10311 uint salt_len
= hash_pos
- salt_pos
- 1;
10313 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10315 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10317 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10319 salt
->salt_len
= salt_len
;
10321 u8 tmp_buf
[100] = { 0 };
10323 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10325 memcpy (digest
, tmp_buf
, 20);
10327 digest
[0] = byte_swap_32 (digest
[0]);
10328 digest
[1] = byte_swap_32 (digest
[1]);
10329 digest
[2] = byte_swap_32 (digest
[2]);
10330 digest
[3] = byte_swap_32 (digest
[3]);
10331 digest
[4] = byte_swap_32 (digest
[4]);
10333 digest
[0] -= SHA1M_A
;
10334 digest
[1] -= SHA1M_B
;
10335 digest
[2] -= SHA1M_C
;
10336 digest
[3] -= SHA1M_D
;
10337 digest
[4] -= SHA1M_E
;
10339 return (PARSER_OK
);
10342 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10344 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10346 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10348 if (c12
& 3) return (PARSER_HASH_VALUE
);
10350 u32
*digest
= (u32
*) hash_buf
->digest
;
10352 salt_t
*salt
= hash_buf
->salt
;
10354 // for ascii_digest
10355 salt
->salt_sign
[0] = input_buf
[0];
10356 salt
->salt_sign
[1] = input_buf
[1];
10358 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10359 | itoa64_to_int (input_buf
[1]) << 6;
10361 salt
->salt_len
= 2;
10363 u8 tmp_buf
[100] = { 0 };
10365 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10367 memcpy (digest
, tmp_buf
, 8);
10371 IP (digest
[0], digest
[1], tt
);
10376 return (PARSER_OK
);
10379 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10381 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10383 u32
*digest
= (u32
*) hash_buf
->digest
;
10385 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10386 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10387 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10388 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10390 digest
[0] = byte_swap_32 (digest
[0]);
10391 digest
[1] = byte_swap_32 (digest
[1]);
10392 digest
[2] = byte_swap_32 (digest
[2]);
10393 digest
[3] = byte_swap_32 (digest
[3]);
10395 digest
[0] -= MD4M_A
;
10396 digest
[1] -= MD4M_B
;
10397 digest
[2] -= MD4M_C
;
10398 digest
[3] -= MD4M_D
;
10400 return (PARSER_OK
);
10403 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10405 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10407 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10411 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10414 u32
*digest
= (u32
*) hash_buf
->digest
;
10416 salt_t
*salt
= hash_buf
->salt
;
10418 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10419 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10420 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10421 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10423 digest
[0] = byte_swap_32 (digest
[0]);
10424 digest
[1] = byte_swap_32 (digest
[1]);
10425 digest
[2] = byte_swap_32 (digest
[2]);
10426 digest
[3] = byte_swap_32 (digest
[3]);
10428 digest
[0] -= MD4M_A
;
10429 digest
[1] -= MD4M_B
;
10430 digest
[2] -= MD4M_C
;
10431 digest
[3] -= MD4M_D
;
10433 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10435 uint salt_len
= input_len
- 32 - 1;
10437 char *salt_buf
= input_buf
+ 32 + 1;
10439 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10441 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10443 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10445 salt
->salt_len
= salt_len
;
10447 return (PARSER_OK
);
10450 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10452 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10454 u32
*digest
= (u32
*) hash_buf
->digest
;
10456 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10457 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10458 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10459 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10461 digest
[0] = byte_swap_32 (digest
[0]);
10462 digest
[1] = byte_swap_32 (digest
[1]);
10463 digest
[2] = byte_swap_32 (digest
[2]);
10464 digest
[3] = byte_swap_32 (digest
[3]);
10466 digest
[0] -= MD5M_A
;
10467 digest
[1] -= MD5M_B
;
10468 digest
[2] -= MD5M_C
;
10469 digest
[3] -= MD5M_D
;
10471 return (PARSER_OK
);
10474 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10476 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10478 u32
*digest
= (u32
*) hash_buf
->digest
;
10480 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10481 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10485 digest
[0] = byte_swap_32 (digest
[0]);
10486 digest
[1] = byte_swap_32 (digest
[1]);
10488 return (PARSER_OK
);
10491 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10493 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10495 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10499 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10502 u32
*digest
= (u32
*) hash_buf
->digest
;
10504 salt_t
*salt
= hash_buf
->salt
;
10506 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10507 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10508 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10509 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10511 digest
[0] = byte_swap_32 (digest
[0]);
10512 digest
[1] = byte_swap_32 (digest
[1]);
10513 digest
[2] = byte_swap_32 (digest
[2]);
10514 digest
[3] = byte_swap_32 (digest
[3]);
10516 digest
[0] -= MD5M_A
;
10517 digest
[1] -= MD5M_B
;
10518 digest
[2] -= MD5M_C
;
10519 digest
[3] -= MD5M_D
;
10521 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10523 uint salt_len
= input_len
- 32 - 1;
10525 char *salt_buf
= input_buf
+ 32 + 1;
10527 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10529 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10531 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10533 salt
->salt_len
= salt_len
;
10535 return (PARSER_OK
);
10538 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10540 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10542 u32
*digest
= (u32
*) hash_buf
->digest
;
10544 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10545 | itoa64_to_int (input_buf
[ 1]) << 6
10546 | itoa64_to_int (input_buf
[ 2]) << 12
10547 | itoa64_to_int (input_buf
[ 3]) << 18;
10548 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10549 | itoa64_to_int (input_buf
[ 5]) << 6
10550 | itoa64_to_int (input_buf
[ 6]) << 12
10551 | itoa64_to_int (input_buf
[ 7]) << 18;
10552 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10553 | itoa64_to_int (input_buf
[ 9]) << 6
10554 | itoa64_to_int (input_buf
[10]) << 12
10555 | itoa64_to_int (input_buf
[11]) << 18;
10556 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10557 | itoa64_to_int (input_buf
[13]) << 6
10558 | itoa64_to_int (input_buf
[14]) << 12
10559 | itoa64_to_int (input_buf
[15]) << 18;
10561 digest
[0] -= MD5M_A
;
10562 digest
[1] -= MD5M_B
;
10563 digest
[2] -= MD5M_C
;
10564 digest
[3] -= MD5M_D
;
10566 digest
[0] &= 0x00ffffff;
10567 digest
[1] &= 0x00ffffff;
10568 digest
[2] &= 0x00ffffff;
10569 digest
[3] &= 0x00ffffff;
10571 return (PARSER_OK
);
10574 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10576 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10578 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10582 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10585 u32
*digest
= (u32
*) hash_buf
->digest
;
10587 salt_t
*salt
= hash_buf
->salt
;
10589 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10590 | itoa64_to_int (input_buf
[ 1]) << 6
10591 | itoa64_to_int (input_buf
[ 2]) << 12
10592 | itoa64_to_int (input_buf
[ 3]) << 18;
10593 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10594 | itoa64_to_int (input_buf
[ 5]) << 6
10595 | itoa64_to_int (input_buf
[ 6]) << 12
10596 | itoa64_to_int (input_buf
[ 7]) << 18;
10597 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10598 | itoa64_to_int (input_buf
[ 9]) << 6
10599 | itoa64_to_int (input_buf
[10]) << 12
10600 | itoa64_to_int (input_buf
[11]) << 18;
10601 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10602 | itoa64_to_int (input_buf
[13]) << 6
10603 | itoa64_to_int (input_buf
[14]) << 12
10604 | itoa64_to_int (input_buf
[15]) << 18;
10606 digest
[0] -= MD5M_A
;
10607 digest
[1] -= MD5M_B
;
10608 digest
[2] -= MD5M_C
;
10609 digest
[3] -= MD5M_D
;
10611 digest
[0] &= 0x00ffffff;
10612 digest
[1] &= 0x00ffffff;
10613 digest
[2] &= 0x00ffffff;
10614 digest
[3] &= 0x00ffffff;
10616 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10618 uint salt_len
= input_len
- 16 - 1;
10620 char *salt_buf
= input_buf
+ 16 + 1;
10622 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10624 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10626 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10628 salt
->salt_len
= salt_len
;
10630 return (PARSER_OK
);
10633 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10635 key
[0] = (nthash
[0] >> 0);
10636 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10637 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10638 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10639 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10640 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10641 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10642 key
[7] = (nthash
[6] << 1);
10654 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10656 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10658 u32
*digest
= (u32
*) hash_buf
->digest
;
10660 salt_t
*salt
= hash_buf
->salt
;
10662 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10668 char *user_pos
= input_buf
;
10670 char *unused_pos
= strchr (user_pos
, ':');
10672 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10674 uint user_len
= unused_pos
- user_pos
;
10676 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10680 char *domain_pos
= strchr (unused_pos
, ':');
10682 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10684 uint unused_len
= domain_pos
- unused_pos
;
10686 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10690 char *srvchall_pos
= strchr (domain_pos
, ':');
10692 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10694 uint domain_len
= srvchall_pos
- domain_pos
;
10696 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10700 char *hash_pos
= strchr (srvchall_pos
, ':');
10702 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10704 uint srvchall_len
= hash_pos
- srvchall_pos
;
10706 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10710 char *clichall_pos
= strchr (hash_pos
, ':');
10712 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10714 uint hash_len
= clichall_pos
- hash_pos
;
10716 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10720 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10722 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10725 * store some data for later use
10728 netntlm
->user_len
= user_len
* 2;
10729 netntlm
->domain_len
= domain_len
* 2;
10730 netntlm
->srvchall_len
= srvchall_len
/ 2;
10731 netntlm
->clichall_len
= clichall_len
/ 2;
10733 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10734 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10737 * handle username and domainname
10740 for (uint i
= 0; i
< user_len
; i
++)
10742 *userdomain_ptr
++ = user_pos
[i
];
10743 *userdomain_ptr
++ = 0;
10746 for (uint i
= 0; i
< domain_len
; i
++)
10748 *userdomain_ptr
++ = domain_pos
[i
];
10749 *userdomain_ptr
++ = 0;
10753 * handle server challenge encoding
10756 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10758 const char p0
= srvchall_pos
[i
+ 0];
10759 const char p1
= srvchall_pos
[i
+ 1];
10761 *chall_ptr
++ = hex_convert (p1
) << 0
10762 | hex_convert (p0
) << 4;
10766 * handle client challenge encoding
10769 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10771 const char p0
= clichall_pos
[i
+ 0];
10772 const char p1
= clichall_pos
[i
+ 1];
10774 *chall_ptr
++ = hex_convert (p1
) << 0
10775 | hex_convert (p0
) << 4;
10782 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10784 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10786 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10788 salt
->salt_len
= salt_len
;
10790 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10791 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10792 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10793 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10795 digest
[0] = byte_swap_32 (digest
[0]);
10796 digest
[1] = byte_swap_32 (digest
[1]);
10797 digest
[2] = byte_swap_32 (digest
[2]);
10798 digest
[3] = byte_swap_32 (digest
[3]);
10800 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10802 uint digest_tmp
[2] = { 0 };
10804 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10805 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
10807 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10808 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10810 /* special case 2: ESS */
10812 if (srvchall_len
== 48)
10814 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10816 uint w
[16] = { 0 };
10818 w
[ 0] = netntlm
->chall_buf
[6];
10819 w
[ 1] = netntlm
->chall_buf
[7];
10820 w
[ 2] = netntlm
->chall_buf
[0];
10821 w
[ 3] = netntlm
->chall_buf
[1];
10825 uint dgst
[4] = { 0 };
10834 salt
->salt_buf
[0] = dgst
[0];
10835 salt
->salt_buf
[1] = dgst
[1];
10839 /* precompute netntlmv1 exploit start */
10841 for (uint i
= 0; i
< 0x10000; i
++)
10843 uint key_md4
[2] = { i
, 0 };
10844 uint key_des
[2] = { 0, 0 };
10846 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
10848 uint Kc
[16] = { 0 };
10849 uint Kd
[16] = { 0 };
10851 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10853 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10855 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10857 if (data3
[0] != digest_tmp
[0]) continue;
10858 if (data3
[1] != digest_tmp
[1]) continue;
10860 salt
->salt_buf
[2] = i
;
10862 salt
->salt_len
= 24;
10867 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10868 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10870 /* precompute netntlmv1 exploit stop */
10874 IP (digest
[0], digest
[1], tt
);
10875 IP (digest
[2], digest
[3], tt
);
10877 digest
[0] = rotr32 (digest
[0], 29);
10878 digest
[1] = rotr32 (digest
[1], 29);
10879 digest
[2] = rotr32 (digest
[2], 29);
10880 digest
[3] = rotr32 (digest
[3], 29);
10882 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10884 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
10885 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
10887 return (PARSER_OK
);
10890 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10892 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10894 u32
*digest
= (u32
*) hash_buf
->digest
;
10896 salt_t
*salt
= hash_buf
->salt
;
10898 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10904 char *user_pos
= input_buf
;
10906 char *unused_pos
= strchr (user_pos
, ':');
10908 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10910 uint user_len
= unused_pos
- user_pos
;
10912 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10916 char *domain_pos
= strchr (unused_pos
, ':');
10918 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10920 uint unused_len
= domain_pos
- unused_pos
;
10922 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10926 char *srvchall_pos
= strchr (domain_pos
, ':');
10928 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10930 uint domain_len
= srvchall_pos
- domain_pos
;
10932 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10936 char *hash_pos
= strchr (srvchall_pos
, ':');
10938 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10940 uint srvchall_len
= hash_pos
- srvchall_pos
;
10942 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
10946 char *clichall_pos
= strchr (hash_pos
, ':');
10948 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10950 uint hash_len
= clichall_pos
- hash_pos
;
10952 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
10956 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10958 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
10960 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
10963 * store some data for later use
10966 netntlm
->user_len
= user_len
* 2;
10967 netntlm
->domain_len
= domain_len
* 2;
10968 netntlm
->srvchall_len
= srvchall_len
/ 2;
10969 netntlm
->clichall_len
= clichall_len
/ 2;
10971 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10972 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10975 * handle username and domainname
10978 for (uint i
= 0; i
< user_len
; i
++)
10980 *userdomain_ptr
++ = toupper (user_pos
[i
]);
10981 *userdomain_ptr
++ = 0;
10984 for (uint i
= 0; i
< domain_len
; i
++)
10986 *userdomain_ptr
++ = domain_pos
[i
];
10987 *userdomain_ptr
++ = 0;
10990 *userdomain_ptr
++ = 0x80;
10993 * handle server challenge encoding
10996 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10998 const char p0
= srvchall_pos
[i
+ 0];
10999 const char p1
= srvchall_pos
[i
+ 1];
11001 *chall_ptr
++ = hex_convert (p1
) << 0
11002 | hex_convert (p0
) << 4;
11006 * handle client challenge encoding
11009 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11011 const char p0
= clichall_pos
[i
+ 0];
11012 const char p1
= clichall_pos
[i
+ 1];
11014 *chall_ptr
++ = hex_convert (p1
) << 0
11015 | hex_convert (p0
) << 4;
11018 *chall_ptr
++ = 0x80;
11021 * handle hash itself
11024 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11025 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11026 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11027 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11029 digest
[0] = byte_swap_32 (digest
[0]);
11030 digest
[1] = byte_swap_32 (digest
[1]);
11031 digest
[2] = byte_swap_32 (digest
[2]);
11032 digest
[3] = byte_swap_32 (digest
[3]);
11035 * reuse challange data as salt_buf, its the buffer that is most likely unique
11038 salt
->salt_buf
[0] = 0;
11039 salt
->salt_buf
[1] = 0;
11040 salt
->salt_buf
[2] = 0;
11041 salt
->salt_buf
[3] = 0;
11042 salt
->salt_buf
[4] = 0;
11043 salt
->salt_buf
[5] = 0;
11044 salt
->salt_buf
[6] = 0;
11045 salt
->salt_buf
[7] = 0;
11049 uptr
= (uint
*) netntlm
->userdomain_buf
;
11051 for (uint i
= 0; i
< 16; i
+= 16)
11053 md5_64 (uptr
, salt
->salt_buf
);
11056 uptr
= (uint
*) netntlm
->chall_buf
;
11058 for (uint i
= 0; i
< 256; i
+= 16)
11060 md5_64 (uptr
, salt
->salt_buf
);
11063 salt
->salt_len
= 16;
11065 return (PARSER_OK
);
11068 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11070 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11072 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11076 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11079 u32
*digest
= (u32
*) hash_buf
->digest
;
11081 salt_t
*salt
= hash_buf
->salt
;
11083 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11084 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11085 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11086 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11088 digest
[0] = byte_swap_32 (digest
[0]);
11089 digest
[1] = byte_swap_32 (digest
[1]);
11090 digest
[2] = byte_swap_32 (digest
[2]);
11091 digest
[3] = byte_swap_32 (digest
[3]);
11093 digest
[0] -= MD5M_A
;
11094 digest
[1] -= MD5M_B
;
11095 digest
[2] -= MD5M_C
;
11096 digest
[3] -= MD5M_D
;
11098 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11100 uint salt_len
= input_len
- 32 - 1;
11102 char *salt_buf
= input_buf
+ 32 + 1;
11104 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11106 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11108 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11110 salt
->salt_len
= salt_len
;
11112 return (PARSER_OK
);
11115 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11117 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11119 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11123 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11126 u32
*digest
= (u32
*) hash_buf
->digest
;
11128 salt_t
*salt
= hash_buf
->salt
;
11130 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11131 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11132 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11133 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11135 digest
[0] = byte_swap_32 (digest
[0]);
11136 digest
[1] = byte_swap_32 (digest
[1]);
11137 digest
[2] = byte_swap_32 (digest
[2]);
11138 digest
[3] = byte_swap_32 (digest
[3]);
11140 digest
[0] -= MD5M_A
;
11141 digest
[1] -= MD5M_B
;
11142 digest
[2] -= MD5M_C
;
11143 digest
[3] -= MD5M_D
;
11145 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11147 uint salt_len
= input_len
- 32 - 1;
11149 char *salt_buf
= input_buf
+ 32 + 1;
11151 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11153 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11155 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11157 salt
->salt_len
= salt_len
;
11159 return (PARSER_OK
);
11162 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11164 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11166 u32
*digest
= (u32
*) hash_buf
->digest
;
11168 salt_t
*salt
= hash_buf
->salt
;
11170 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11171 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11172 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11173 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11175 digest
[0] = byte_swap_32 (digest
[0]);
11176 digest
[1] = byte_swap_32 (digest
[1]);
11177 digest
[2] = byte_swap_32 (digest
[2]);
11178 digest
[3] = byte_swap_32 (digest
[3]);
11180 digest
[0] -= MD5M_A
;
11181 digest
[1] -= MD5M_B
;
11182 digest
[2] -= MD5M_C
;
11183 digest
[3] -= MD5M_D
;
11186 * This is a virtual salt. While the algorithm is basically not salted
11187 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11188 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11191 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11193 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11195 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11197 salt
->salt_len
= salt_len
;
11199 return (PARSER_OK
);
11202 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11204 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11206 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11210 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11213 u32
*digest
= (u32
*) hash_buf
->digest
;
11215 salt_t
*salt
= hash_buf
->salt
;
11217 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11218 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11219 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11220 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11222 digest
[0] = byte_swap_32 (digest
[0]);
11223 digest
[1] = byte_swap_32 (digest
[1]);
11224 digest
[2] = byte_swap_32 (digest
[2]);
11225 digest
[3] = byte_swap_32 (digest
[3]);
11227 digest
[0] -= MD5M_A
;
11228 digest
[1] -= MD5M_B
;
11229 digest
[2] -= MD5M_C
;
11230 digest
[3] -= MD5M_D
;
11232 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11234 uint salt_len
= input_len
- 32 - 1;
11236 char *salt_buf
= input_buf
+ 32 + 1;
11238 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11240 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11242 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11244 salt
->salt_len
= salt_len
;
11246 return (PARSER_OK
);
11249 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11251 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11253 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11257 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11260 u32
*digest
= (u32
*) hash_buf
->digest
;
11262 salt_t
*salt
= hash_buf
->salt
;
11264 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11265 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11266 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11267 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11269 digest
[0] = byte_swap_32 (digest
[0]);
11270 digest
[1] = byte_swap_32 (digest
[1]);
11271 digest
[2] = byte_swap_32 (digest
[2]);
11272 digest
[3] = byte_swap_32 (digest
[3]);
11274 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11276 uint salt_len
= input_len
- 32 - 1;
11278 char *salt_buf
= input_buf
+ 32 + 1;
11280 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11282 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11284 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11286 salt
->salt_len
= salt_len
;
11288 return (PARSER_OK
);
11291 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11293 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11295 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11299 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11302 u32
*digest
= (u32
*) hash_buf
->digest
;
11304 salt_t
*salt
= hash_buf
->salt
;
11306 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11307 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11308 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11309 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11311 digest
[0] = byte_swap_32 (digest
[0]);
11312 digest
[1] = byte_swap_32 (digest
[1]);
11313 digest
[2] = byte_swap_32 (digest
[2]);
11314 digest
[3] = byte_swap_32 (digest
[3]);
11316 digest
[0] -= MD4M_A
;
11317 digest
[1] -= MD4M_B
;
11318 digest
[2] -= MD4M_C
;
11319 digest
[3] -= MD4M_D
;
11321 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11323 uint salt_len
= input_len
- 32 - 1;
11325 char *salt_buf
= input_buf
+ 32 + 1;
11327 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11329 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11331 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11333 salt
->salt_len
= salt_len
;
11335 return (PARSER_OK
);
11338 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11340 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11342 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11346 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11349 u32
*digest
= (u32
*) hash_buf
->digest
;
11351 salt_t
*salt
= hash_buf
->salt
;
11353 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11354 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11355 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11356 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11358 digest
[0] = byte_swap_32 (digest
[0]);
11359 digest
[1] = byte_swap_32 (digest
[1]);
11360 digest
[2] = byte_swap_32 (digest
[2]);
11361 digest
[3] = byte_swap_32 (digest
[3]);
11363 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11365 uint salt_len
= input_len
- 32 - 1;
11367 char *salt_buf
= input_buf
+ 32 + 1;
11369 uint salt_pc_block
[16] = { 0 };
11371 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11373 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11375 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11377 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11379 salt_pc_block
[14] = salt_len
* 8;
11381 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11383 md5_64 (salt_pc_block
, salt_pc_digest
);
11385 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11386 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11387 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11388 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11390 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11392 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11394 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11396 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11397 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11398 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11399 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11401 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11403 return (PARSER_OK
);
11406 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11408 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11410 u32
*digest
= (u32
*) hash_buf
->digest
;
11412 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11413 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11414 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11415 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11416 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11418 digest
[0] -= SHA1M_A
;
11419 digest
[1] -= SHA1M_B
;
11420 digest
[2] -= SHA1M_C
;
11421 digest
[3] -= SHA1M_D
;
11422 digest
[4] -= SHA1M_E
;
11424 return (PARSER_OK
);
11427 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11429 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11431 u32
*digest
= (u32
*) hash_buf
->digest
;
11433 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11434 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11435 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11436 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11437 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11439 return (PARSER_OK
);
11442 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11444 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11446 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11450 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11453 u32
*digest
= (u32
*) hash_buf
->digest
;
11455 salt_t
*salt
= hash_buf
->salt
;
11457 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11458 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11459 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11460 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11461 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11463 digest
[0] -= SHA1M_A
;
11464 digest
[1] -= SHA1M_B
;
11465 digest
[2] -= SHA1M_C
;
11466 digest
[3] -= SHA1M_D
;
11467 digest
[4] -= SHA1M_E
;
11469 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11471 uint salt_len
= input_len
- 40 - 1;
11473 char *salt_buf
= input_buf
+ 40 + 1;
11475 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11477 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11479 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11481 salt
->salt_len
= salt_len
;
11483 return (PARSER_OK
);
11486 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11488 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11490 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11492 u32
*digest
= (u32
*) hash_buf
->digest
;
11494 u8 tmp_buf
[100] = { 0 };
11496 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11498 memcpy (digest
, tmp_buf
, 20);
11500 digest
[0] = byte_swap_32 (digest
[0]);
11501 digest
[1] = byte_swap_32 (digest
[1]);
11502 digest
[2] = byte_swap_32 (digest
[2]);
11503 digest
[3] = byte_swap_32 (digest
[3]);
11504 digest
[4] = byte_swap_32 (digest
[4]);
11506 digest
[0] -= SHA1M_A
;
11507 digest
[1] -= SHA1M_B
;
11508 digest
[2] -= SHA1M_C
;
11509 digest
[3] -= SHA1M_D
;
11510 digest
[4] -= SHA1M_E
;
11512 return (PARSER_OK
);
11515 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11517 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11519 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11521 u32
*digest
= (u32
*) hash_buf
->digest
;
11523 salt_t
*salt
= hash_buf
->salt
;
11525 u8 tmp_buf
[100] = { 0 };
11527 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11529 memcpy (digest
, tmp_buf
, 20);
11531 salt
->salt_len
= tmp_len
- 20;
11533 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11535 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11537 char *ptr
= (char *) salt
->salt_buf
;
11539 ptr
[salt
->salt_len
] = 0x80;
11542 digest
[0] = byte_swap_32 (digest
[0]);
11543 digest
[1] = byte_swap_32 (digest
[1]);
11544 digest
[2] = byte_swap_32 (digest
[2]);
11545 digest
[3] = byte_swap_32 (digest
[3]);
11546 digest
[4] = byte_swap_32 (digest
[4]);
11548 digest
[0] -= SHA1M_A
;
11549 digest
[1] -= SHA1M_B
;
11550 digest
[2] -= SHA1M_C
;
11551 digest
[3] -= SHA1M_D
;
11552 digest
[4] -= SHA1M_E
;
11554 return (PARSER_OK
);
11557 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11559 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11561 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11563 u32
*digest
= (u32
*) hash_buf
->digest
;
11565 salt_t
*salt
= hash_buf
->salt
;
11567 char *salt_buf
= input_buf
+ 6;
11571 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11573 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11575 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11577 salt
->salt_len
= salt_len
;
11579 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11581 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11582 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11583 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11584 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11585 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11587 digest
[0] -= SHA1M_A
;
11588 digest
[1] -= SHA1M_B
;
11589 digest
[2] -= SHA1M_C
;
11590 digest
[3] -= SHA1M_D
;
11591 digest
[4] -= SHA1M_E
;
11593 return (PARSER_OK
);
11596 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11598 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11600 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11602 u32
*digest
= (u32
*) hash_buf
->digest
;
11604 salt_t
*salt
= hash_buf
->salt
;
11606 char *salt_buf
= input_buf
+ 6;
11610 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11612 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11614 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11616 salt
->salt_len
= salt_len
;
11618 char *hash_pos
= input_buf
+ 6 + 8;
11620 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11621 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11622 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11623 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11624 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11626 digest
[0] -= SHA1M_A
;
11627 digest
[1] -= SHA1M_B
;
11628 digest
[2] -= SHA1M_C
;
11629 digest
[3] -= SHA1M_D
;
11630 digest
[4] -= SHA1M_E
;
11632 return (PARSER_OK
);
11635 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11637 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11639 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11641 u64
*digest
= (u64
*) hash_buf
->digest
;
11643 salt_t
*salt
= hash_buf
->salt
;
11645 char *salt_buf
= input_buf
+ 6;
11649 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11651 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11653 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11655 salt
->salt_len
= salt_len
;
11657 char *hash_pos
= input_buf
+ 6 + 8;
11659 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11660 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11661 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11662 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11663 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11664 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11665 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11666 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11668 digest
[0] -= SHA512M_A
;
11669 digest
[1] -= SHA512M_B
;
11670 digest
[2] -= SHA512M_C
;
11671 digest
[3] -= SHA512M_D
;
11672 digest
[4] -= SHA512M_E
;
11673 digest
[5] -= SHA512M_F
;
11674 digest
[6] -= SHA512M_G
;
11675 digest
[7] -= SHA512M_H
;
11677 return (PARSER_OK
);
11680 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11682 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11684 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11688 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11691 u32
*digest
= (u32
*) hash_buf
->digest
;
11693 salt_t
*salt
= hash_buf
->salt
;
11695 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11696 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11700 digest
[0] = byte_swap_32 (digest
[0]);
11701 digest
[1] = byte_swap_32 (digest
[1]);
11703 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11705 uint salt_len
= input_len
- 16 - 1;
11707 char *salt_buf
= input_buf
+ 16 + 1;
11709 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11711 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11713 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11715 salt
->salt_len
= salt_len
;
11717 return (PARSER_OK
);
11720 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11722 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11724 u32
*digest
= (u32
*) hash_buf
->digest
;
11726 salt_t
*salt
= hash_buf
->salt
;
11728 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11729 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11730 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11731 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11732 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11734 digest
[0] -= SHA1M_A
;
11735 digest
[1] -= SHA1M_B
;
11736 digest
[2] -= SHA1M_C
;
11737 digest
[3] -= SHA1M_D
;
11738 digest
[4] -= SHA1M_E
;
11740 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11742 uint salt_len
= input_len
- 40 - 1;
11744 char *salt_buf
= input_buf
+ 40 + 1;
11746 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11748 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11750 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11752 salt
->salt_len
= salt_len
;
11754 return (PARSER_OK
);
11757 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11759 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11761 u32
*digest
= (u32
*) hash_buf
->digest
;
11763 salt_t
*salt
= hash_buf
->salt
;
11765 char *hash_pos
= input_buf
;
11767 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11768 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11769 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
11770 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
11771 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
11772 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
11773 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
11774 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
11775 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
11776 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
11777 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
11778 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
11779 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
11780 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
11781 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
11782 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
11784 char *salt_pos
= input_buf
+ 128;
11786 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
11787 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
11788 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
11789 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
11791 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11792 salt
->salt_len
= 16;
11794 return (PARSER_OK
);
11797 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11799 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11801 u32
*digest
= (u32
*) hash_buf
->digest
;
11803 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11804 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11805 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11806 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11807 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11808 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11809 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11810 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11812 digest
[0] -= SHA256M_A
;
11813 digest
[1] -= SHA256M_B
;
11814 digest
[2] -= SHA256M_C
;
11815 digest
[3] -= SHA256M_D
;
11816 digest
[4] -= SHA256M_E
;
11817 digest
[5] -= SHA256M_F
;
11818 digest
[6] -= SHA256M_G
;
11819 digest
[7] -= SHA256M_H
;
11821 return (PARSER_OK
);
11824 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11826 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11828 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11832 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11835 u32
*digest
= (u32
*) hash_buf
->digest
;
11837 salt_t
*salt
= hash_buf
->salt
;
11839 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11840 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11841 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11842 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11843 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11844 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11845 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11846 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11848 digest
[0] -= SHA256M_A
;
11849 digest
[1] -= SHA256M_B
;
11850 digest
[2] -= SHA256M_C
;
11851 digest
[3] -= SHA256M_D
;
11852 digest
[4] -= SHA256M_E
;
11853 digest
[5] -= SHA256M_F
;
11854 digest
[6] -= SHA256M_G
;
11855 digest
[7] -= SHA256M_H
;
11857 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11859 uint salt_len
= input_len
- 64 - 1;
11861 char *salt_buf
= input_buf
+ 64 + 1;
11863 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11865 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11867 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11869 salt
->salt_len
= salt_len
;
11871 return (PARSER_OK
);
11874 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11876 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11878 u64
*digest
= (u64
*) hash_buf
->digest
;
11880 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11881 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11882 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11883 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11884 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11885 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11889 digest
[0] -= SHA384M_A
;
11890 digest
[1] -= SHA384M_B
;
11891 digest
[2] -= SHA384M_C
;
11892 digest
[3] -= SHA384M_D
;
11893 digest
[4] -= SHA384M_E
;
11894 digest
[5] -= SHA384M_F
;
11898 return (PARSER_OK
);
11901 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11903 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
11905 u64
*digest
= (u64
*) hash_buf
->digest
;
11907 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11908 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11909 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11910 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11911 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11912 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11913 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11914 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11916 digest
[0] -= SHA512M_A
;
11917 digest
[1] -= SHA512M_B
;
11918 digest
[2] -= SHA512M_C
;
11919 digest
[3] -= SHA512M_D
;
11920 digest
[4] -= SHA512M_E
;
11921 digest
[5] -= SHA512M_F
;
11922 digest
[6] -= SHA512M_G
;
11923 digest
[7] -= SHA512M_H
;
11925 return (PARSER_OK
);
11928 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11930 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11932 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
11936 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
11939 u64
*digest
= (u64
*) hash_buf
->digest
;
11941 salt_t
*salt
= hash_buf
->salt
;
11943 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11944 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11945 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11946 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11947 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11948 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11949 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11950 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11952 digest
[0] -= SHA512M_A
;
11953 digest
[1] -= SHA512M_B
;
11954 digest
[2] -= SHA512M_C
;
11955 digest
[3] -= SHA512M_D
;
11956 digest
[4] -= SHA512M_E
;
11957 digest
[5] -= SHA512M_F
;
11958 digest
[6] -= SHA512M_G
;
11959 digest
[7] -= SHA512M_H
;
11961 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11963 uint salt_len
= input_len
- 128 - 1;
11965 char *salt_buf
= input_buf
+ 128 + 1;
11967 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11969 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11971 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11973 salt
->salt_len
= salt_len
;
11975 return (PARSER_OK
);
11978 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11980 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
11982 u64
*digest
= (u64
*) hash_buf
->digest
;
11984 salt_t
*salt
= hash_buf
->salt
;
11986 char *salt_pos
= input_buf
+ 3;
11988 uint iterations_len
= 0;
11990 if (memcmp (salt_pos
, "rounds=", 7) == 0)
11994 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
11996 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
11997 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12001 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12005 iterations_len
+= 8;
12009 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12012 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12014 char *hash_pos
= strchr (salt_pos
, '$');
12016 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12018 uint salt_len
= hash_pos
- salt_pos
;
12020 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12022 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12024 salt
->salt_len
= salt_len
;
12028 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12030 return (PARSER_OK
);
12033 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12035 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12037 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12039 u64
*digest
= (u64
*) hash_buf
->digest
;
12041 salt_t
*salt
= hash_buf
->salt
;
12043 uint keccak_mdlen
= input_len
/ 2;
12045 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12047 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12049 digest
[i
] = byte_swap_64 (digest
[i
]);
12052 salt
->keccak_mdlen
= keccak_mdlen
;
12054 return (PARSER_OK
);
12057 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12059 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12061 u32
*digest
= (u32
*) hash_buf
->digest
;
12063 salt_t
*salt
= hash_buf
->salt
;
12065 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12068 * Parse that strange long line
12073 size_t in_len
[9] = { 0 };
12075 in_off
[0] = strtok (input_buf
, ":");
12077 in_len
[0] = strlen (in_off
[0]);
12081 for (i
= 1; i
< 9; i
++)
12083 in_off
[i
] = strtok (NULL
, ":");
12085 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12087 in_len
[i
] = strlen (in_off
[i
]);
12090 char *ptr
= (char *) ikepsk
->msg_buf
;
12092 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12093 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12094 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12095 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12096 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12097 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12101 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12103 ptr
= (char *) ikepsk
->nr_buf
;
12105 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12106 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12110 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12113 * Store to database
12118 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12119 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12120 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12121 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12123 digest
[0] = byte_swap_32 (digest
[0]);
12124 digest
[1] = byte_swap_32 (digest
[1]);
12125 digest
[2] = byte_swap_32 (digest
[2]);
12126 digest
[3] = byte_swap_32 (digest
[3]);
12128 salt
->salt_len
= 32;
12130 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12131 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12132 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12133 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12134 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12135 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12136 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12137 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12139 return (PARSER_OK
);
12142 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12144 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12146 u32
*digest
= (u32
*) hash_buf
->digest
;
12148 salt_t
*salt
= hash_buf
->salt
;
12150 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12153 * Parse that strange long line
12158 size_t in_len
[9] = { 0 };
12160 in_off
[0] = strtok (input_buf
, ":");
12162 in_len
[0] = strlen (in_off
[0]);
12166 for (i
= 1; i
< 9; i
++)
12168 in_off
[i
] = strtok (NULL
, ":");
12170 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12172 in_len
[i
] = strlen (in_off
[i
]);
12175 char *ptr
= (char *) ikepsk
->msg_buf
;
12177 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12178 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12179 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12180 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12181 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12182 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12186 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12188 ptr
= (char *) ikepsk
->nr_buf
;
12190 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12191 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12195 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12198 * Store to database
12203 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12204 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12205 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12206 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12207 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12209 salt
->salt_len
= 32;
12211 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12212 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12213 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12214 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12215 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12216 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12217 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12218 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12220 return (PARSER_OK
);
12223 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12225 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12227 u32
*digest
= (u32
*) hash_buf
->digest
;
12229 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12230 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12231 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12232 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12233 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12235 digest
[0] = byte_swap_32 (digest
[0]);
12236 digest
[1] = byte_swap_32 (digest
[1]);
12237 digest
[2] = byte_swap_32 (digest
[2]);
12238 digest
[3] = byte_swap_32 (digest
[3]);
12239 digest
[4] = byte_swap_32 (digest
[4]);
12241 return (PARSER_OK
);
12244 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12246 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12248 u32
*digest
= (u32
*) hash_buf
->digest
;
12250 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12251 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12252 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12253 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12254 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12255 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12256 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12257 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12258 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12259 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12260 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12261 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12262 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12263 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12264 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12265 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12267 return (PARSER_OK
);
12270 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12272 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12274 u32
*digest
= (u32
*) hash_buf
->digest
;
12276 salt_t
*salt
= hash_buf
->salt
;
12278 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12279 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12280 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12281 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12282 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12284 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12286 uint salt_len
= input_len
- 40 - 1;
12288 char *salt_buf
= input_buf
+ 40 + 1;
12290 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12292 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12294 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12296 salt
->salt_len
= salt_len
;
12298 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12300 return (PARSER_OK
);
12303 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12305 u32
*digest
= (u32
*) hash_buf
->digest
;
12307 salt_t
*salt
= hash_buf
->salt
;
12309 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12311 if (input_len
== 0)
12313 log_error ("TrueCrypt container not specified");
12318 FILE *fp
= fopen (input_buf
, "rb");
12322 log_error ("%s: %s", input_buf
, strerror (errno
));
12327 char buf
[512] = { 0 };
12329 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12333 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12335 memcpy (tc
->salt_buf
, buf
, 64);
12337 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12339 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12341 salt
->salt_len
= 4;
12343 salt
->salt_iter
= 1000 - 1;
12345 digest
[0] = tc
->data_buf
[0];
12347 return (PARSER_OK
);
12350 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12352 u32
*digest
= (u32
*) hash_buf
->digest
;
12354 salt_t
*salt
= hash_buf
->salt
;
12356 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12358 if (input_len
== 0)
12360 log_error ("TrueCrypt container not specified");
12365 FILE *fp
= fopen (input_buf
, "rb");
12369 log_error ("%s: %s", input_buf
, strerror (errno
));
12374 char buf
[512] = { 0 };
12376 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12380 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12382 memcpy (tc
->salt_buf
, buf
, 64);
12384 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12386 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12388 salt
->salt_len
= 4;
12390 salt
->salt_iter
= 2000 - 1;
12392 digest
[0] = tc
->data_buf
[0];
12394 return (PARSER_OK
);
12397 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12399 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12401 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12403 u32
*digest
= (u32
*) hash_buf
->digest
;
12405 salt_t
*salt
= hash_buf
->salt
;
12407 char *salt_pos
= input_buf
+ 6;
12409 char *hash_pos
= strchr (salt_pos
, '$');
12411 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12413 uint salt_len
= hash_pos
- salt_pos
;
12415 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12417 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12419 salt
->salt_len
= salt_len
;
12421 salt
->salt_iter
= 1000;
12425 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12427 return (PARSER_OK
);
12430 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12432 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12434 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12436 u32
*digest
= (u32
*) hash_buf
->digest
;
12438 salt_t
*salt
= hash_buf
->salt
;
12440 char *iter_pos
= input_buf
+ 7;
12442 char *salt_pos
= strchr (iter_pos
, '$');
12444 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12448 char *hash_pos
= strchr (salt_pos
, '$');
12450 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12452 uint salt_len
= hash_pos
- salt_pos
;
12454 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12456 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12458 salt
->salt_len
= salt_len
;
12460 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12462 salt
->salt_sign
[0] = atoi (salt_iter
);
12464 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12468 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12470 digest
[0] = byte_swap_32 (digest
[0]);
12471 digest
[1] = byte_swap_32 (digest
[1]);
12472 digest
[2] = byte_swap_32 (digest
[2]);
12473 digest
[3] = byte_swap_32 (digest
[3]);
12474 digest
[4] = byte_swap_32 (digest
[4]);
12476 return (PARSER_OK
);
12479 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12481 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12483 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12485 u32
*digest
= (u32
*) hash_buf
->digest
;
12487 salt_t
*salt
= hash_buf
->salt
;
12489 char *iter_pos
= input_buf
+ 9;
12491 char *salt_pos
= strchr (iter_pos
, '$');
12493 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12497 char *hash_pos
= strchr (salt_pos
, '$');
12499 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12501 uint salt_len
= hash_pos
- salt_pos
;
12503 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12505 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12507 salt
->salt_len
= salt_len
;
12509 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12511 salt
->salt_sign
[0] = atoi (salt_iter
);
12513 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12517 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12519 digest
[0] = byte_swap_32 (digest
[0]);
12520 digest
[1] = byte_swap_32 (digest
[1]);
12521 digest
[2] = byte_swap_32 (digest
[2]);
12522 digest
[3] = byte_swap_32 (digest
[3]);
12523 digest
[4] = byte_swap_32 (digest
[4]);
12524 digest
[5] = byte_swap_32 (digest
[5]);
12525 digest
[6] = byte_swap_32 (digest
[6]);
12526 digest
[7] = byte_swap_32 (digest
[7]);
12528 return (PARSER_OK
);
12531 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12533 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12535 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12537 u64
*digest
= (u64
*) hash_buf
->digest
;
12539 salt_t
*salt
= hash_buf
->salt
;
12541 char *iter_pos
= input_buf
+ 9;
12543 char *salt_pos
= strchr (iter_pos
, '$');
12545 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12549 char *hash_pos
= strchr (salt_pos
, '$');
12551 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12553 uint salt_len
= hash_pos
- salt_pos
;
12555 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12557 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12559 salt
->salt_len
= salt_len
;
12561 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12563 salt
->salt_sign
[0] = atoi (salt_iter
);
12565 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12569 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12571 digest
[0] = byte_swap_64 (digest
[0]);
12572 digest
[1] = byte_swap_64 (digest
[1]);
12573 digest
[2] = byte_swap_64 (digest
[2]);
12574 digest
[3] = byte_swap_64 (digest
[3]);
12575 digest
[4] = byte_swap_64 (digest
[4]);
12576 digest
[5] = byte_swap_64 (digest
[5]);
12577 digest
[6] = byte_swap_64 (digest
[6]);
12578 digest
[7] = byte_swap_64 (digest
[7]);
12580 return (PARSER_OK
);
12583 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12585 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12587 u32
*digest
= (u32
*) hash_buf
->digest
;
12589 salt_t
*salt
= hash_buf
->salt
;
12591 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12597 char *iterations_pos
= input_buf
;
12599 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12601 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12603 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12605 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12609 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12611 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12613 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12615 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12617 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12619 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12624 * pbkdf2 iterations
12627 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12630 * handle salt encoding
12633 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12635 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12637 const char p0
= saltbuf_pos
[i
+ 0];
12638 const char p1
= saltbuf_pos
[i
+ 1];
12640 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12641 | hex_convert (p0
) << 4;
12644 salt
->salt_len
= saltbuf_len
/ 2;
12647 * handle cipher encoding
12650 uint
*tmp
= (uint
*) mymalloc (32);
12652 char *cipherbuf_ptr
= (char *) tmp
;
12654 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12656 const char p0
= cipherbuf_pos
[i
+ 0];
12657 const char p1
= cipherbuf_pos
[i
+ 1];
12659 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12660 | hex_convert (p0
) << 4;
12663 // iv is stored at salt_buf 4 (length 16)
12664 // data is stored at salt_buf 8 (length 16)
12666 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12667 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12668 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12669 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12671 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12672 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12673 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12674 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12678 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12680 const char p0
= cipherbuf_pos
[j
+ 0];
12681 const char p1
= cipherbuf_pos
[j
+ 1];
12683 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12684 | hex_convert (p0
) << 4;
12691 digest
[0] = 0x10101010;
12692 digest
[1] = 0x10101010;
12693 digest
[2] = 0x10101010;
12694 digest
[3] = 0x10101010;
12696 return (PARSER_OK
);
12699 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12701 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12703 u32
*digest
= (u32
*) hash_buf
->digest
;
12705 salt_t
*salt
= hash_buf
->salt
;
12707 char *hashbuf_pos
= input_buf
;
12709 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12711 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12713 uint hash_len
= iterations_pos
- hashbuf_pos
;
12715 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12719 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12721 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12723 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12727 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12729 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12731 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12733 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12735 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12737 salt
->salt_len
= salt_len
;
12739 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12741 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
12742 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
12743 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
12744 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
12746 return (PARSER_OK
);
12749 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12751 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12753 u32
*digest
= (u32
*) hash_buf
->digest
;
12755 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12756 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12757 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12758 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12759 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12760 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12761 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12762 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12764 digest
[0] = byte_swap_32 (digest
[0]);
12765 digest
[1] = byte_swap_32 (digest
[1]);
12766 digest
[2] = byte_swap_32 (digest
[2]);
12767 digest
[3] = byte_swap_32 (digest
[3]);
12768 digest
[4] = byte_swap_32 (digest
[4]);
12769 digest
[5] = byte_swap_32 (digest
[5]);
12770 digest
[6] = byte_swap_32 (digest
[6]);
12771 digest
[7] = byte_swap_32 (digest
[7]);
12773 return (PARSER_OK
);
12776 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12778 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12780 u32
*digest
= (u32
*) hash_buf
->digest
;
12782 salt_t
*salt
= hash_buf
->salt
;
12784 char *salt_pos
= input_buf
+ 3;
12786 uint iterations_len
= 0;
12788 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12792 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12794 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12795 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12799 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12803 iterations_len
+= 8;
12807 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12810 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12812 char *hash_pos
= strchr (salt_pos
, '$');
12814 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12816 uint salt_len
= hash_pos
- salt_pos
;
12818 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12820 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12822 salt
->salt_len
= salt_len
;
12826 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12828 return (PARSER_OK
);
12831 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12833 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12835 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12837 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12839 u64
*digest
= (u64
*) hash_buf
->digest
;
12841 salt_t
*salt
= hash_buf
->salt
;
12843 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12845 char *iter_pos
= input_buf
+ 4;
12847 char *salt_pos
= strchr (iter_pos
, '$');
12849 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12853 char *hash_pos
= strchr (salt_pos
, '$');
12855 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12857 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12861 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12862 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12863 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12864 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12865 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12866 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12867 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12868 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12870 uint salt_len
= hash_pos
- salt_pos
- 1;
12872 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12874 salt
->salt_len
= salt_len
/ 2;
12876 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12877 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12878 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12879 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12880 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
12881 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
12882 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
12883 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
12885 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12886 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12887 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12888 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12889 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12890 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12891 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12892 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12893 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12894 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12896 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12898 salt
->salt_iter
= atoi (iter_pos
) - 1;
12900 return (PARSER_OK
);
12903 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12905 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12907 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12909 u32
*digest
= (u32
*) hash_buf
->digest
;
12911 salt_t
*salt
= hash_buf
->salt
;
12913 char *salt_pos
= input_buf
+ 14;
12915 char *hash_pos
= strchr (salt_pos
, '*');
12917 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12921 uint salt_len
= hash_pos
- salt_pos
- 1;
12923 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12925 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
12927 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12929 salt
->salt_len
= salt_len
;
12931 u8 tmp_buf
[100] = { 0 };
12933 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
12935 memcpy (digest
, tmp_buf
, 32);
12937 digest
[0] = byte_swap_32 (digest
[0]);
12938 digest
[1] = byte_swap_32 (digest
[1]);
12939 digest
[2] = byte_swap_32 (digest
[2]);
12940 digest
[3] = byte_swap_32 (digest
[3]);
12941 digest
[4] = byte_swap_32 (digest
[4]);
12942 digest
[5] = byte_swap_32 (digest
[5]);
12943 digest
[6] = byte_swap_32 (digest
[6]);
12944 digest
[7] = byte_swap_32 (digest
[7]);
12946 digest
[0] -= SHA256M_A
;
12947 digest
[1] -= SHA256M_B
;
12948 digest
[2] -= SHA256M_C
;
12949 digest
[3] -= SHA256M_D
;
12950 digest
[4] -= SHA256M_E
;
12951 digest
[5] -= SHA256M_F
;
12952 digest
[6] -= SHA256M_G
;
12953 digest
[7] -= SHA256M_H
;
12955 return (PARSER_OK
);
12958 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12960 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
12962 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12964 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
12966 u64
*digest
= (u64
*) hash_buf
->digest
;
12968 salt_t
*salt
= hash_buf
->salt
;
12970 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12972 char *iter_pos
= input_buf
+ 19;
12974 char *salt_pos
= strchr (iter_pos
, '.');
12976 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12980 char *hash_pos
= strchr (salt_pos
, '.');
12982 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12984 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12988 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12989 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12990 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12991 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12992 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12993 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12994 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12995 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12997 uint salt_len
= hash_pos
- salt_pos
- 1;
13001 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13005 for (i
= 0; i
< salt_len
; i
++)
13007 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13010 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13011 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13013 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13015 salt
->salt_len
= salt_len
;
13017 salt
->salt_iter
= atoi (iter_pos
) - 1;
13019 return (PARSER_OK
);
13022 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13024 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13026 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13028 u64
*digest
= (u64
*) hash_buf
->digest
;
13030 salt_t
*salt
= hash_buf
->salt
;
13032 u8 tmp_buf
[120] = { 0 };
13034 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13036 memcpy (digest
, tmp_buf
, 64);
13038 digest
[0] = byte_swap_64 (digest
[0]);
13039 digest
[1] = byte_swap_64 (digest
[1]);
13040 digest
[2] = byte_swap_64 (digest
[2]);
13041 digest
[3] = byte_swap_64 (digest
[3]);
13042 digest
[4] = byte_swap_64 (digest
[4]);
13043 digest
[5] = byte_swap_64 (digest
[5]);
13044 digest
[6] = byte_swap_64 (digest
[6]);
13045 digest
[7] = byte_swap_64 (digest
[7]);
13047 digest
[0] -= SHA512M_A
;
13048 digest
[1] -= SHA512M_B
;
13049 digest
[2] -= SHA512M_C
;
13050 digest
[3] -= SHA512M_D
;
13051 digest
[4] -= SHA512M_E
;
13052 digest
[5] -= SHA512M_F
;
13053 digest
[6] -= SHA512M_G
;
13054 digest
[7] -= SHA512M_H
;
13056 salt
->salt_len
= tmp_len
- 64;
13058 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13060 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13062 char *ptr
= (char *) salt
->salt_buf
;
13064 ptr
[salt
->salt_len
] = 0x80;
13067 return (PARSER_OK
);
13070 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13072 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13074 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13078 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13081 u32
*digest
= (u32
*) hash_buf
->digest
;
13083 salt_t
*salt
= hash_buf
->salt
;
13085 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13086 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13087 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13088 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13090 digest
[0] = byte_swap_32 (digest
[0]);
13091 digest
[1] = byte_swap_32 (digest
[1]);
13092 digest
[2] = byte_swap_32 (digest
[2]);
13093 digest
[3] = byte_swap_32 (digest
[3]);
13095 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13097 uint salt_len
= input_len
- 32 - 1;
13099 char *salt_buf
= input_buf
+ 32 + 1;
13101 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13103 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13105 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13107 salt
->salt_len
= salt_len
;
13109 return (PARSER_OK
);
13112 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13114 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13116 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13120 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13123 u32
*digest
= (u32
*) hash_buf
->digest
;
13125 salt_t
*salt
= hash_buf
->salt
;
13127 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13128 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13129 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13130 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13131 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13133 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13135 uint salt_len
= input_len
- 40 - 1;
13137 char *salt_buf
= input_buf
+ 40 + 1;
13139 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13141 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13143 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13145 salt
->salt_len
= salt_len
;
13147 return (PARSER_OK
);
13150 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13152 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13154 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13158 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13161 u32
*digest
= (u32
*) hash_buf
->digest
;
13163 salt_t
*salt
= hash_buf
->salt
;
13165 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13166 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13167 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13168 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13169 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13170 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13171 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13172 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13174 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13176 uint salt_len
= input_len
- 64 - 1;
13178 char *salt_buf
= input_buf
+ 64 + 1;
13180 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13182 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13184 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13186 salt
->salt_len
= salt_len
;
13188 return (PARSER_OK
);
13191 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13193 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13195 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13199 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13202 u64
*digest
= (u64
*) hash_buf
->digest
;
13204 salt_t
*salt
= hash_buf
->salt
;
13206 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13207 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13208 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13209 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13210 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13211 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13212 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13213 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13215 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13217 uint salt_len
= input_len
- 128 - 1;
13219 char *salt_buf
= input_buf
+ 128 + 1;
13221 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13223 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13225 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13227 salt
->salt_len
= salt_len
;
13229 return (PARSER_OK
);
13232 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13234 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13236 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13238 u32
*digest
= (u32
*) hash_buf
->digest
;
13240 salt_t
*salt
= hash_buf
->salt
;
13242 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13248 char *user_pos
= input_buf
+ 10 + 1;
13250 char *realm_pos
= strchr (user_pos
, '$');
13252 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13254 uint user_len
= realm_pos
- user_pos
;
13256 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13260 char *salt_pos
= strchr (realm_pos
, '$');
13262 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13264 uint realm_len
= salt_pos
- realm_pos
;
13266 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13270 char *data_pos
= strchr (salt_pos
, '$');
13272 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13274 uint salt_len
= data_pos
- salt_pos
;
13276 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13280 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13282 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13288 memcpy (krb5pa
->user
, user_pos
, user_len
);
13289 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13290 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13292 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13294 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13296 const char p0
= data_pos
[i
+ 0];
13297 const char p1
= data_pos
[i
+ 1];
13299 *timestamp_ptr
++ = hex_convert (p1
) << 0
13300 | hex_convert (p0
) << 4;
13303 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13305 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13307 const char p0
= data_pos
[i
+ 0];
13308 const char p1
= data_pos
[i
+ 1];
13310 *checksum_ptr
++ = hex_convert (p1
) << 0
13311 | hex_convert (p0
) << 4;
13315 * copy some data to generic buffers to make sorting happy
13318 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13319 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13320 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13321 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13322 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13323 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13324 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13325 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13326 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13328 salt
->salt_len
= 36;
13330 digest
[0] = krb5pa
->checksum
[0];
13331 digest
[1] = krb5pa
->checksum
[1];
13332 digest
[2] = krb5pa
->checksum
[2];
13333 digest
[3] = krb5pa
->checksum
[3];
13335 return (PARSER_OK
);
13338 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13340 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13342 u32
*digest
= (u32
*) hash_buf
->digest
;
13344 salt_t
*salt
= hash_buf
->salt
;
13350 char *salt_pos
= input_buf
;
13352 char *hash_pos
= strchr (salt_pos
, '$');
13354 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13356 uint salt_len
= hash_pos
- salt_pos
;
13358 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13362 uint hash_len
= input_len
- 1 - salt_len
;
13364 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13372 for (uint i
= 0; i
< salt_len
; i
++)
13374 if (salt_pos
[i
] == ' ') continue;
13379 // SAP user names cannot be longer than 12 characters
13380 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13382 // SAP user name cannot start with ! or ?
13383 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13389 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13391 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13393 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13395 salt
->salt_len
= salt_len
;
13397 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13398 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13402 digest
[0] = byte_swap_32 (digest
[0]);
13403 digest
[1] = byte_swap_32 (digest
[1]);
13405 return (PARSER_OK
);
13408 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13410 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13412 u32
*digest
= (u32
*) hash_buf
->digest
;
13414 salt_t
*salt
= hash_buf
->salt
;
13420 char *salt_pos
= input_buf
;
13422 char *hash_pos
= strchr (salt_pos
, '$');
13424 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13426 uint salt_len
= hash_pos
- salt_pos
;
13428 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13432 uint hash_len
= input_len
- 1 - salt_len
;
13434 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13442 for (uint i
= 0; i
< salt_len
; i
++)
13444 if (salt_pos
[i
] == ' ') continue;
13449 // SAP user names cannot be longer than 12 characters
13450 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13451 // so far nobody complained so we stay with this because it helps in optimization
13452 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13454 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13456 // SAP user name cannot start with ! or ?
13457 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13463 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13465 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13467 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13469 salt
->salt_len
= salt_len
;
13471 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13472 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13473 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13474 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13475 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13477 return (PARSER_OK
);
13480 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13482 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13484 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13486 u64
*digest
= (u64
*) hash_buf
->digest
;
13488 salt_t
*salt
= hash_buf
->salt
;
13490 char *iter_pos
= input_buf
+ 3;
13492 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13494 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13496 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13498 salt
->salt_iter
= salt_iter
;
13500 char *salt_pos
= iter_pos
+ 1;
13504 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13506 salt
->salt_len
= salt_len
;
13508 char *hash_pos
= salt_pos
+ salt_len
;
13510 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13514 char *tmp
= (char *) salt
->salt_buf_pc
;
13516 tmp
[0] = hash_pos
[42];
13520 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13521 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13522 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13523 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13529 return (PARSER_OK
);
13532 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13534 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13536 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13538 u32
*digest
= (u32
*) hash_buf
->digest
;
13540 salt_t
*salt
= hash_buf
->salt
;
13542 char *salt_buf
= input_buf
+ 6;
13544 uint salt_len
= 16;
13546 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13548 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13550 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13552 salt
->salt_len
= salt_len
;
13554 char *hash_pos
= input_buf
+ 6 + 16;
13556 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13557 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13558 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13559 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13560 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13561 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13562 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13563 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13565 return (PARSER_OK
);
13568 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13570 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13572 u32
*digest
= (u32
*) hash_buf
->digest
;
13574 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13575 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13579 return (PARSER_OK
);
13582 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13584 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13586 u32
*digest
= (u32
*) hash_buf
->digest
;
13588 salt_t
*salt
= hash_buf
->salt
;
13590 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13592 char *saltbuf_pos
= input_buf
;
13594 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13596 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13598 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13600 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13601 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13603 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13607 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13609 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13611 char *salt_ptr
= (char *) saltbuf_pos
;
13612 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13617 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13619 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13622 rakp_ptr
[j
] = 0x80;
13624 rakp
->salt_len
= j
;
13626 for (i
= 0; i
< 64; i
++)
13628 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13631 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13632 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13633 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13634 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13635 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13636 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13637 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13638 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13640 salt
->salt_len
= 32; // muss min. 32 haben
13642 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13643 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13644 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13645 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13646 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13648 return (PARSER_OK
);
13651 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13653 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13655 u32
*digest
= (u32
*) hash_buf
->digest
;
13657 salt_t
*salt
= hash_buf
->salt
;
13659 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13661 char *salt_pos
= input_buf
+ 1;
13663 memcpy (salt
->salt_buf
, salt_pos
, 8);
13665 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13666 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13668 salt
->salt_len
= 8;
13670 char *hash_pos
= salt_pos
+ 8;
13672 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13673 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13674 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13675 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13676 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13678 digest
[0] -= SHA1M_A
;
13679 digest
[1] -= SHA1M_B
;
13680 digest
[2] -= SHA1M_C
;
13681 digest
[3] -= SHA1M_D
;
13682 digest
[4] -= SHA1M_E
;
13684 return (PARSER_OK
);
13687 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13689 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13691 u32
*digest
= (u32
*) hash_buf
->digest
;
13693 salt_t
*salt
= hash_buf
->salt
;
13695 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13696 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13697 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13698 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13700 digest
[0] = byte_swap_32 (digest
[0]);
13701 digest
[1] = byte_swap_32 (digest
[1]);
13702 digest
[2] = byte_swap_32 (digest
[2]);
13703 digest
[3] = byte_swap_32 (digest
[3]);
13705 digest
[0] -= MD5M_A
;
13706 digest
[1] -= MD5M_B
;
13707 digest
[2] -= MD5M_C
;
13708 digest
[3] -= MD5M_D
;
13710 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13712 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13714 u32
*salt_buf
= salt
->salt_buf
;
13716 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
13717 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
13718 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
13719 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
13721 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13722 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13723 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13724 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13726 salt
->salt_len
= 16 + 1;
13728 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13730 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13732 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
13734 return (PARSER_OK
);
13737 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13739 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13741 u32
*digest
= (u32
*) hash_buf
->digest
;
13743 salt_t
*salt
= hash_buf
->salt
;
13745 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13751 char *hashbuf_pos
= input_buf
;
13753 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13755 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13757 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13759 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13763 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13765 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13767 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13769 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13773 char *databuf_pos
= strchr (iteration_pos
, ':');
13775 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13777 const uint iteration_len
= databuf_pos
- iteration_pos
;
13779 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13780 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13782 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13784 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13785 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13791 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13792 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13793 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13794 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13795 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13796 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
13797 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
13798 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
13802 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13804 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13806 const char p0
= saltbuf_pos
[i
+ 0];
13807 const char p1
= saltbuf_pos
[i
+ 1];
13809 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13810 | hex_convert (p0
) << 4;
13813 salt
->salt_buf
[4] = 0x01000000;
13814 salt
->salt_buf
[5] = 0x80;
13816 salt
->salt_len
= saltbuf_len
/ 2;
13820 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13824 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13826 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13828 const char p0
= databuf_pos
[i
+ 0];
13829 const char p1
= databuf_pos
[i
+ 1];
13831 *databuf_ptr
++ = hex_convert (p1
) << 0
13832 | hex_convert (p0
) << 4;
13835 *databuf_ptr
++ = 0x80;
13837 for (uint i
= 0; i
< 512; i
++)
13839 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13842 cloudkey
->data_len
= databuf_len
/ 2;
13844 return (PARSER_OK
);
13847 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13849 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13851 u32
*digest
= (u32
*) hash_buf
->digest
;
13853 salt_t
*salt
= hash_buf
->salt
;
13859 char *hashbuf_pos
= input_buf
;
13861 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13863 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13865 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13867 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13871 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13873 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13875 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13877 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13879 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13883 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13885 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13887 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13889 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13891 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13895 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13897 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13898 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13900 // ok, the plan for this algorithm is the following:
13901 // we have 2 salts here, the domain-name and a random salt
13902 // while both are used in the initial transformation,
13903 // only the random salt is used in the following iterations
13904 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13905 // and one that includes only the real salt (stored into salt_buf[]).
13906 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13908 u8 tmp_buf
[100] = { 0 };
13910 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
13912 memcpy (digest
, tmp_buf
, 20);
13914 digest
[0] = byte_swap_32 (digest
[0]);
13915 digest
[1] = byte_swap_32 (digest
[1]);
13916 digest
[2] = byte_swap_32 (digest
[2]);
13917 digest
[3] = byte_swap_32 (digest
[3]);
13918 digest
[4] = byte_swap_32 (digest
[4]);
13922 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13924 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
13926 char *len_ptr
= NULL
;
13928 for (uint i
= 0; i
< domainbuf_len
; i
++)
13930 if (salt_buf_pc_ptr
[i
] == '.')
13932 len_ptr
= &salt_buf_pc_ptr
[i
];
13942 salt
->salt_buf_pc
[7] = domainbuf_len
;
13946 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13948 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
13950 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13952 salt
->salt_len
= salt_len
;
13956 salt
->salt_iter
= atoi (iteration_pos
);
13958 return (PARSER_OK
);
13961 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13963 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
13965 u32
*digest
= (u32
*) hash_buf
->digest
;
13967 salt_t
*salt
= hash_buf
->salt
;
13969 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13970 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13971 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13972 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13973 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13975 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13977 uint salt_len
= input_len
- 40 - 1;
13979 char *salt_buf
= input_buf
+ 40 + 1;
13981 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13983 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13985 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13987 salt
->salt_len
= salt_len
;
13989 return (PARSER_OK
);
13992 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13994 const u8 ascii_to_ebcdic
[] =
13996 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
13997 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
13998 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
13999 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14000 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14001 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14002 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14003 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14004 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14005 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14006 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14007 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14008 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14009 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14010 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14011 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14014 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14016 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14018 u32
*digest
= (u32
*) hash_buf
->digest
;
14020 salt_t
*salt
= hash_buf
->salt
;
14022 char *salt_pos
= input_buf
+ 6 + 1;
14024 char *digest_pos
= strchr (salt_pos
, '*');
14026 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14028 uint salt_len
= digest_pos
- salt_pos
;
14030 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14032 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14034 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14038 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14039 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14041 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14043 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14045 salt
->salt_len
= salt_len
;
14047 for (uint i
= 0; i
< salt_len
; i
++)
14049 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14051 for (uint i
= salt_len
; i
< 8; i
++)
14053 salt_buf_pc_ptr
[i
] = 0x40;
14058 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14060 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14061 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14063 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14064 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14066 digest
[0] = byte_swap_32 (digest
[0]);
14067 digest
[1] = byte_swap_32 (digest
[1]);
14069 IP (digest
[0], digest
[1], tt
);
14071 digest
[0] = rotr32 (digest
[0], 29);
14072 digest
[1] = rotr32 (digest
[1], 29);
14076 return (PARSER_OK
);
14079 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14081 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14083 u32
*digest
= (u32
*) hash_buf
->digest
;
14085 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14086 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14087 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14088 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14090 digest
[0] = byte_swap_32 (digest
[0]);
14091 digest
[1] = byte_swap_32 (digest
[1]);
14092 digest
[2] = byte_swap_32 (digest
[2]);
14093 digest
[3] = byte_swap_32 (digest
[3]);
14095 return (PARSER_OK
);
14098 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14100 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14102 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14104 u32
*digest
= (u32
*) hash_buf
->digest
;
14106 salt_t
*salt
= hash_buf
->salt
;
14108 u8 tmp_buf
[120] = { 0 };
14110 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14112 tmp_buf
[3] += -4; // dont ask!
14114 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14116 salt
->salt_len
= 5;
14118 memcpy (digest
, tmp_buf
+ 5, 9);
14120 // yes, only 9 byte are needed to crack, but 10 to display
14122 salt
->salt_buf_pc
[7] = input_buf
[20];
14124 return (PARSER_OK
);
14127 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14129 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14131 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14133 u32
*digest
= (u32
*) hash_buf
->digest
;
14135 salt_t
*salt
= hash_buf
->salt
;
14137 u8 tmp_buf
[120] = { 0 };
14139 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14141 tmp_buf
[3] += -4; // dont ask!
14145 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14147 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)
14151 char tmp_iter_buf
[11] = { 0 };
14153 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14155 tmp_iter_buf
[10] = 0;
14157 salt
->salt_iter
= atoi (tmp_iter_buf
);
14159 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14161 return (PARSER_SALT_ITERATION
);
14164 salt
->salt_iter
--; // first round in init
14166 // 2 additional bytes for display only
14168 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14169 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14173 memcpy (digest
, tmp_buf
+ 28, 8);
14175 digest
[0] = byte_swap_32 (digest
[0]);
14176 digest
[1] = byte_swap_32 (digest
[1]);
14180 return (PARSER_OK
);
14183 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14185 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14187 u32
*digest
= (u32
*) hash_buf
->digest
;
14189 salt_t
*salt
= hash_buf
->salt
;
14191 char *salt_buf_pos
= input_buf
;
14193 char *hash_buf_pos
= salt_buf_pos
+ 6;
14195 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14196 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14197 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14198 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14199 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14200 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14201 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14202 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14204 digest
[0] -= SHA256M_A
;
14205 digest
[1] -= SHA256M_B
;
14206 digest
[2] -= SHA256M_C
;
14207 digest
[3] -= SHA256M_D
;
14208 digest
[4] -= SHA256M_E
;
14209 digest
[5] -= SHA256M_F
;
14210 digest
[6] -= SHA256M_G
;
14211 digest
[7] -= SHA256M_H
;
14213 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14215 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14217 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14219 salt
->salt_len
= salt_len
;
14221 return (PARSER_OK
);
14224 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14226 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14228 u32
*digest
= (u32
*) hash_buf
->digest
;
14230 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14232 salt_t
*salt
= hash_buf
->salt
;
14234 char *salt_buf
= input_buf
+ 6;
14236 char *digest_buf
= strchr (salt_buf
, '$');
14238 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14240 uint salt_len
= digest_buf
- salt_buf
;
14242 digest_buf
++; // skip the '$' symbol
14244 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14246 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14248 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14250 salt
->salt_len
= salt_len
;
14252 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14253 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14254 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14255 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14257 digest
[0] = byte_swap_32 (digest
[0]);
14258 digest
[1] = byte_swap_32 (digest
[1]);
14259 digest
[2] = byte_swap_32 (digest
[2]);
14260 digest
[3] = byte_swap_32 (digest
[3]);
14262 digest
[0] -= MD5M_A
;
14263 digest
[1] -= MD5M_B
;
14264 digest
[2] -= MD5M_C
;
14265 digest
[3] -= MD5M_D
;
14267 return (PARSER_OK
);
14270 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14272 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14274 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14276 u32
*digest
= (u32
*) hash_buf
->digest
;
14278 salt_t
*salt
= hash_buf
->salt
;
14280 char *salt_buf
= input_buf
+ 3;
14282 char *digest_buf
= strchr (salt_buf
, '$');
14284 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14286 uint salt_len
= digest_buf
- salt_buf
;
14288 digest_buf
++; // skip the '$' symbol
14290 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14292 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14294 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14296 salt_buf_ptr
[salt_len
] = 0x2d;
14298 salt
->salt_len
= salt_len
+ 1;
14300 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14301 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14302 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14303 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14305 digest
[0] = byte_swap_32 (digest
[0]);
14306 digest
[1] = byte_swap_32 (digest
[1]);
14307 digest
[2] = byte_swap_32 (digest
[2]);
14308 digest
[3] = byte_swap_32 (digest
[3]);
14310 digest
[0] -= MD5M_A
;
14311 digest
[1] -= MD5M_B
;
14312 digest
[2] -= MD5M_C
;
14313 digest
[3] -= MD5M_D
;
14315 return (PARSER_OK
);
14318 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14320 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14322 u32
*digest
= (u32
*) hash_buf
->digest
;
14324 u8 tmp_buf
[100] = { 0 };
14326 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14328 memcpy (digest
, tmp_buf
, 20);
14330 digest
[0] = byte_swap_32 (digest
[0]);
14331 digest
[1] = byte_swap_32 (digest
[1]);
14332 digest
[2] = byte_swap_32 (digest
[2]);
14333 digest
[3] = byte_swap_32 (digest
[3]);
14334 digest
[4] = byte_swap_32 (digest
[4]);
14336 digest
[0] -= SHA1M_A
;
14337 digest
[1] -= SHA1M_B
;
14338 digest
[2] -= SHA1M_C
;
14339 digest
[3] -= SHA1M_D
;
14340 digest
[4] -= SHA1M_E
;
14342 return (PARSER_OK
);
14345 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14347 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14349 u32
*digest
= (u32
*) hash_buf
->digest
;
14351 salt_t
*salt
= hash_buf
->salt
;
14353 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14354 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14355 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14356 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14358 digest
[0] = byte_swap_32 (digest
[0]);
14359 digest
[1] = byte_swap_32 (digest
[1]);
14360 digest
[2] = byte_swap_32 (digest
[2]);
14361 digest
[3] = byte_swap_32 (digest
[3]);
14363 digest
[0] -= MD5M_A
;
14364 digest
[1] -= MD5M_B
;
14365 digest
[2] -= MD5M_C
;
14366 digest
[3] -= MD5M_D
;
14368 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14370 uint salt_len
= input_len
- 32 - 1;
14372 char *salt_buf
= input_buf
+ 32 + 1;
14374 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14376 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14378 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14381 * add static "salt" part
14384 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14388 salt
->salt_len
= salt_len
;
14390 return (PARSER_OK
);
14393 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14395 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14397 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14399 u32
*digest
= (u32
*) hash_buf
->digest
;
14401 salt_t
*salt
= hash_buf
->salt
;
14403 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14409 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14411 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14413 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14415 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14417 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14421 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14423 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14425 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14427 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14431 char *keybuf_pos
= strchr (keylen_pos
, '$');
14433 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14435 uint keylen_len
= keybuf_pos
- keylen_pos
;
14437 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14441 char *databuf_pos
= strchr (keybuf_pos
, '$');
14443 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14445 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14447 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14451 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14453 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14459 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14460 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14461 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14462 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14464 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14465 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14466 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14467 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14469 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14470 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14471 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14472 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14474 salt
->salt_len
= 16;
14475 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14477 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14479 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14482 return (PARSER_OK
);
14485 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14487 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14489 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14491 u32
*digest
= (u32
*) hash_buf
->digest
;
14493 salt_t
*salt
= hash_buf
->salt
;
14499 // first is the N salt parameter
14501 char *N_pos
= input_buf
+ 6;
14503 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14507 salt
->scrypt_N
= atoi (N_pos
);
14511 char *r_pos
= strchr (N_pos
, ':');
14513 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14517 salt
->scrypt_r
= atoi (r_pos
);
14521 char *p_pos
= strchr (r_pos
, ':');
14523 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14527 salt
->scrypt_p
= atoi (p_pos
);
14531 char *saltbuf_pos
= strchr (p_pos
, ':');
14533 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14537 char *hash_pos
= strchr (saltbuf_pos
, ':');
14539 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14545 u8 tmp_buf
[33] = { 0 };
14547 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14549 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14551 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14553 salt
->salt_len
= tmp_len
;
14554 salt
->salt_iter
= 1;
14556 // digest - base64 decode
14558 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14560 tmp_len
= input_len
- (hash_pos
- input_buf
);
14562 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14564 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14566 memcpy (digest
, tmp_buf
, 32);
14568 return (PARSER_OK
);
14571 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14573 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14575 u32
*digest
= (u32
*) hash_buf
->digest
;
14577 salt_t
*salt
= hash_buf
->salt
;
14583 char decrypted
[76] = { 0 }; // iv + hash
14585 juniper_decrypt_hash (input_buf
, decrypted
);
14587 char *md5crypt_hash
= decrypted
+ 12;
14589 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14591 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14593 char *salt_pos
= md5crypt_hash
+ 3;
14595 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14597 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14599 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14603 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14605 return (PARSER_OK
);
14608 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14610 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14612 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14614 u32
*digest
= (u32
*) hash_buf
->digest
;
14616 salt_t
*salt
= hash_buf
->salt
;
14618 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14624 // first is *raw* salt
14626 char *salt_pos
= input_buf
+ 3;
14628 char *hash_pos
= strchr (salt_pos
, '$');
14630 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14632 uint salt_len
= hash_pos
- salt_pos
;
14634 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14638 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14640 memcpy (salt_buf_ptr
, salt_pos
, 14);
14642 salt_buf_ptr
[17] = 0x01;
14643 salt_buf_ptr
[18] = 0x80;
14645 // add some stuff to normal salt to make sorted happy
14647 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14648 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14649 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14650 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14652 salt
->salt_len
= salt_len
;
14653 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14655 // base64 decode hash
14657 u8 tmp_buf
[100] = { 0 };
14659 uint hash_len
= input_len
- 3 - salt_len
- 1;
14661 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14663 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14665 memcpy (digest
, tmp_buf
, 32);
14667 digest
[0] = byte_swap_32 (digest
[0]);
14668 digest
[1] = byte_swap_32 (digest
[1]);
14669 digest
[2] = byte_swap_32 (digest
[2]);
14670 digest
[3] = byte_swap_32 (digest
[3]);
14671 digest
[4] = byte_swap_32 (digest
[4]);
14672 digest
[5] = byte_swap_32 (digest
[5]);
14673 digest
[6] = byte_swap_32 (digest
[6]);
14674 digest
[7] = byte_swap_32 (digest
[7]);
14676 return (PARSER_OK
);
14679 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14681 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14683 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14685 u32
*digest
= (u32
*) hash_buf
->digest
;
14687 salt_t
*salt
= hash_buf
->salt
;
14693 // first is *raw* salt
14695 char *salt_pos
= input_buf
+ 3;
14697 char *hash_pos
= strchr (salt_pos
, '$');
14699 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14701 uint salt_len
= hash_pos
- salt_pos
;
14703 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14705 salt
->salt_len
= salt_len
;
14708 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14710 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14711 salt_buf_ptr
[salt_len
] = 0;
14713 // base64 decode hash
14715 u8 tmp_buf
[100] = { 0 };
14717 uint hash_len
= input_len
- 3 - salt_len
- 1;
14719 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14721 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14723 memcpy (digest
, tmp_buf
, 32);
14726 salt
->scrypt_N
= 16384;
14727 salt
->scrypt_r
= 1;
14728 salt
->scrypt_p
= 1;
14729 salt
->salt_iter
= 1;
14731 return (PARSER_OK
);
14734 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14736 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14738 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14740 u32
*digest
= (u32
*) hash_buf
->digest
;
14742 salt_t
*salt
= hash_buf
->salt
;
14744 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14750 char *version_pos
= input_buf
+ 8 + 1;
14752 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14754 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14756 u32 version_len
= verifierHashSize_pos
- version_pos
;
14758 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14760 verifierHashSize_pos
++;
14762 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14764 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14766 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14768 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14772 char *saltSize_pos
= strchr (keySize_pos
, '*');
14774 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14776 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14778 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14782 char *osalt_pos
= strchr (saltSize_pos
, '*');
14784 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14786 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14788 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14792 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14794 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14796 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14798 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14800 encryptedVerifier_pos
++;
14802 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14804 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14806 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14808 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14810 encryptedVerifierHash_pos
++;
14812 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;
14814 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14816 const uint version
= atoi (version_pos
);
14818 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14820 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14822 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14824 const uint keySize
= atoi (keySize_pos
);
14826 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14828 office2007
->keySize
= keySize
;
14830 const uint saltSize
= atoi (saltSize_pos
);
14832 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14838 salt
->salt_len
= 16;
14839 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14841 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
14842 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
14843 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
14844 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
14850 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
14851 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
14852 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
14853 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
14855 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
14856 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
14857 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
14858 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
14859 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
14865 digest
[0] = office2007
->encryptedVerifierHash
[0];
14866 digest
[1] = office2007
->encryptedVerifierHash
[1];
14867 digest
[2] = office2007
->encryptedVerifierHash
[2];
14868 digest
[3] = office2007
->encryptedVerifierHash
[3];
14870 return (PARSER_OK
);
14873 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14875 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14877 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14879 u32
*digest
= (u32
*) hash_buf
->digest
;
14881 salt_t
*salt
= hash_buf
->salt
;
14883 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14889 char *version_pos
= input_buf
+ 8 + 1;
14891 char *spinCount_pos
= strchr (version_pos
, '*');
14893 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14895 u32 version_len
= spinCount_pos
- version_pos
;
14897 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14901 char *keySize_pos
= strchr (spinCount_pos
, '*');
14903 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14905 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
14907 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14911 char *saltSize_pos
= strchr (keySize_pos
, '*');
14913 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14915 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14917 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14921 char *osalt_pos
= strchr (saltSize_pos
, '*');
14923 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14925 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14927 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14931 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14933 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14935 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14937 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14939 encryptedVerifier_pos
++;
14941 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14943 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14945 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14947 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14949 encryptedVerifierHash_pos
++;
14951 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;
14953 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14955 const uint version
= atoi (version_pos
);
14957 if (version
!= 2010) return (PARSER_SALT_VALUE
);
14959 const uint spinCount
= atoi (spinCount_pos
);
14961 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
14963 const uint keySize
= atoi (keySize_pos
);
14965 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
14967 const uint saltSize
= atoi (saltSize_pos
);
14969 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14975 salt
->salt_len
= 16;
14976 salt
->salt_iter
= spinCount
;
14978 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
14979 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
14980 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
14981 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
14987 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
14988 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
14989 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
14990 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
14992 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
14993 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
14994 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
14995 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
14996 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
14997 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
14998 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
14999 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15005 digest
[0] = office2010
->encryptedVerifierHash
[0];
15006 digest
[1] = office2010
->encryptedVerifierHash
[1];
15007 digest
[2] = office2010
->encryptedVerifierHash
[2];
15008 digest
[3] = office2010
->encryptedVerifierHash
[3];
15010 return (PARSER_OK
);
15013 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15015 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15017 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15019 u32
*digest
= (u32
*) hash_buf
->digest
;
15021 salt_t
*salt
= hash_buf
->salt
;
15023 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15029 char *version_pos
= input_buf
+ 8 + 1;
15031 char *spinCount_pos
= strchr (version_pos
, '*');
15033 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15035 u32 version_len
= spinCount_pos
- version_pos
;
15037 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15041 char *keySize_pos
= strchr (spinCount_pos
, '*');
15043 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15045 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15047 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15051 char *saltSize_pos
= strchr (keySize_pos
, '*');
15053 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15055 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15057 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15061 char *osalt_pos
= strchr (saltSize_pos
, '*');
15063 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15065 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15067 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15071 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15073 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15075 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15077 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15079 encryptedVerifier_pos
++;
15081 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15083 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15085 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15087 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15089 encryptedVerifierHash_pos
++;
15091 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;
15093 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15095 const uint version
= atoi (version_pos
);
15097 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15099 const uint spinCount
= atoi (spinCount_pos
);
15101 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15103 const uint keySize
= atoi (keySize_pos
);
15105 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15107 const uint saltSize
= atoi (saltSize_pos
);
15109 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15115 salt
->salt_len
= 16;
15116 salt
->salt_iter
= spinCount
;
15118 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15119 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15120 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15121 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15127 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15128 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15129 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15130 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15132 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15133 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15134 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15135 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15136 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15137 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15138 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15139 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15145 digest
[0] = office2013
->encryptedVerifierHash
[0];
15146 digest
[1] = office2013
->encryptedVerifierHash
[1];
15147 digest
[2] = office2013
->encryptedVerifierHash
[2];
15148 digest
[3] = office2013
->encryptedVerifierHash
[3];
15150 return (PARSER_OK
);
15153 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15155 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15157 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15159 u32
*digest
= (u32
*) hash_buf
->digest
;
15161 salt_t
*salt
= hash_buf
->salt
;
15163 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15169 char *version_pos
= input_buf
+ 11;
15171 char *osalt_pos
= strchr (version_pos
, '*');
15173 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15175 u32 version_len
= osalt_pos
- version_pos
;
15177 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15181 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15183 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15185 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15187 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15189 encryptedVerifier_pos
++;
15191 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15193 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15195 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15197 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15199 encryptedVerifierHash_pos
++;
15201 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15203 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15205 const uint version
= *version_pos
- 0x30;
15207 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15213 oldoffice01
->version
= version
;
15215 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15216 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15217 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15218 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15220 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15221 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15222 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15223 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15225 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15226 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15227 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15228 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15230 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15231 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15232 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15233 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15239 salt
->salt_len
= 16;
15241 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15242 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15243 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15244 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15246 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15247 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15248 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15249 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15251 // this is a workaround as office produces multiple documents with the same salt
15253 salt
->salt_len
+= 32;
15255 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15256 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15257 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15258 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15259 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15260 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15261 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15262 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15268 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15269 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15270 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15271 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15273 return (PARSER_OK
);
15276 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15278 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15281 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15283 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15285 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15287 u32
*digest
= (u32
*) hash_buf
->digest
;
15289 salt_t
*salt
= hash_buf
->salt
;
15291 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15297 char *version_pos
= input_buf
+ 11;
15299 char *osalt_pos
= strchr (version_pos
, '*');
15301 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15303 u32 version_len
= osalt_pos
- version_pos
;
15305 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15309 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15311 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15313 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15315 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15317 encryptedVerifier_pos
++;
15319 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15321 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15323 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15325 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15327 encryptedVerifierHash_pos
++;
15329 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15331 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15333 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15335 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15339 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15341 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15343 const uint version
= *version_pos
- 0x30;
15345 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15351 oldoffice01
->version
= version
;
15353 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15354 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15355 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15356 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15358 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15359 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15360 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15361 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15363 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15364 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15365 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15366 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15368 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15369 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15370 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15371 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15373 oldoffice01
->rc4key
[1] = 0;
15374 oldoffice01
->rc4key
[0] = 0;
15376 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15377 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15378 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15379 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15380 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15381 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15382 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15383 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15384 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15385 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15387 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15388 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15394 salt
->salt_len
= 16;
15396 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15397 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15398 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15399 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15401 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15402 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15403 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15404 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15406 // this is a workaround as office produces multiple documents with the same salt
15408 salt
->salt_len
+= 32;
15410 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15411 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15412 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15413 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15414 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15415 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15416 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15417 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15423 digest
[0] = oldoffice01
->rc4key
[0];
15424 digest
[1] = oldoffice01
->rc4key
[1];
15428 return (PARSER_OK
);
15431 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15433 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15435 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15437 u32
*digest
= (u32
*) hash_buf
->digest
;
15439 salt_t
*salt
= hash_buf
->salt
;
15441 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15447 char *version_pos
= input_buf
+ 11;
15449 char *osalt_pos
= strchr (version_pos
, '*');
15451 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15453 u32 version_len
= osalt_pos
- version_pos
;
15455 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15459 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15461 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15463 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15465 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15467 encryptedVerifier_pos
++;
15469 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15471 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15473 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15475 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15477 encryptedVerifierHash_pos
++;
15479 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15481 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15483 const uint version
= *version_pos
- 0x30;
15485 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15491 oldoffice34
->version
= version
;
15493 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15494 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15495 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15496 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15498 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15499 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15500 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15501 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15503 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15504 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15505 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15506 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15507 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15509 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15510 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15511 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15512 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15513 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15519 salt
->salt_len
= 16;
15521 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15522 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15523 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15524 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15526 // this is a workaround as office produces multiple documents with the same salt
15528 salt
->salt_len
+= 32;
15530 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15531 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15532 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15533 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15534 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15535 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15536 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15537 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15543 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15544 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15545 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15546 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15548 return (PARSER_OK
);
15551 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15553 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15555 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15558 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15560 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15562 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15564 u32
*digest
= (u32
*) hash_buf
->digest
;
15566 salt_t
*salt
= hash_buf
->salt
;
15568 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15574 char *version_pos
= input_buf
+ 11;
15576 char *osalt_pos
= strchr (version_pos
, '*');
15578 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15580 u32 version_len
= osalt_pos
- version_pos
;
15582 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15586 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15588 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15590 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15592 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15594 encryptedVerifier_pos
++;
15596 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15598 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15600 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15602 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15604 encryptedVerifierHash_pos
++;
15606 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15608 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15610 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15612 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15616 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15618 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15620 const uint version
= *version_pos
- 0x30;
15622 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15628 oldoffice34
->version
= version
;
15630 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15631 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15632 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15633 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15635 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15636 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15637 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15638 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15640 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15641 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15642 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15643 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15644 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15646 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15647 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15648 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15649 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15650 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15652 oldoffice34
->rc4key
[1] = 0;
15653 oldoffice34
->rc4key
[0] = 0;
15655 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15656 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15657 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15658 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15659 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15660 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15661 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15662 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15663 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15664 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15666 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15667 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15673 salt
->salt_len
= 16;
15675 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15676 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15677 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15678 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15680 // this is a workaround as office produces multiple documents with the same salt
15682 salt
->salt_len
+= 32;
15684 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15685 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15686 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15687 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15688 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15689 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15690 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15691 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15697 digest
[0] = oldoffice34
->rc4key
[0];
15698 digest
[1] = oldoffice34
->rc4key
[1];
15702 return (PARSER_OK
);
15705 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15707 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15709 u32
*digest
= (u32
*) hash_buf
->digest
;
15711 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15712 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15713 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15714 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15716 digest
[0] = byte_swap_32 (digest
[0]);
15717 digest
[1] = byte_swap_32 (digest
[1]);
15718 digest
[2] = byte_swap_32 (digest
[2]);
15719 digest
[3] = byte_swap_32 (digest
[3]);
15721 return (PARSER_OK
);
15724 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15726 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15728 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15730 u32
*digest
= (u32
*) hash_buf
->digest
;
15732 salt_t
*salt
= hash_buf
->salt
;
15734 char *signature_pos
= input_buf
;
15736 char *salt_pos
= strchr (signature_pos
, '$');
15738 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15740 u32 signature_len
= salt_pos
- signature_pos
;
15742 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15746 char *hash_pos
= strchr (salt_pos
, '$');
15748 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15750 u32 salt_len
= hash_pos
- salt_pos
;
15752 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15756 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15758 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15760 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
15761 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
15762 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
15763 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
15764 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
15766 digest
[0] -= SHA1M_A
;
15767 digest
[1] -= SHA1M_B
;
15768 digest
[2] -= SHA1M_C
;
15769 digest
[3] -= SHA1M_D
;
15770 digest
[4] -= SHA1M_E
;
15772 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15774 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15776 salt
->salt_len
= salt_len
;
15778 return (PARSER_OK
);
15781 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15783 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15785 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15787 u32
*digest
= (u32
*) hash_buf
->digest
;
15789 salt_t
*salt
= hash_buf
->salt
;
15791 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15797 char *iter_pos
= input_buf
+ 14;
15799 const int iter
= atoi (iter_pos
);
15801 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15803 salt
->salt_iter
= iter
- 1;
15805 char *salt_pos
= strchr (iter_pos
, '$');
15807 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15811 char *hash_pos
= strchr (salt_pos
, '$');
15813 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15815 const uint salt_len
= hash_pos
- salt_pos
;
15819 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15821 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15823 salt
->salt_len
= salt_len
;
15825 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15826 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15828 // add some stuff to normal salt to make sorted happy
15830 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15831 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15832 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15833 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15834 salt
->salt_buf
[4] = salt
->salt_iter
;
15836 // base64 decode hash
15838 u8 tmp_buf
[100] = { 0 };
15840 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15842 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15844 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15846 memcpy (digest
, tmp_buf
, 32);
15848 digest
[0] = byte_swap_32 (digest
[0]);
15849 digest
[1] = byte_swap_32 (digest
[1]);
15850 digest
[2] = byte_swap_32 (digest
[2]);
15851 digest
[3] = byte_swap_32 (digest
[3]);
15852 digest
[4] = byte_swap_32 (digest
[4]);
15853 digest
[5] = byte_swap_32 (digest
[5]);
15854 digest
[6] = byte_swap_32 (digest
[6]);
15855 digest
[7] = byte_swap_32 (digest
[7]);
15857 return (PARSER_OK
);
15860 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15862 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15864 u32
*digest
= (u32
*) hash_buf
->digest
;
15866 salt_t
*salt
= hash_buf
->salt
;
15868 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15869 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15873 digest
[0] = byte_swap_32 (digest
[0]);
15874 digest
[1] = byte_swap_32 (digest
[1]);
15876 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15877 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15878 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15880 char iter_c
= input_buf
[17];
15881 char iter_d
= input_buf
[19];
15883 // atm only defaults, let's see if there's more request
15884 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15885 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15887 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15889 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
15890 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
15891 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
15892 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
15894 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15895 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15896 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15897 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15899 salt
->salt_len
= 16;
15901 return (PARSER_OK
);
15904 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15906 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
15908 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15910 u32
*digest
= (u32
*) hash_buf
->digest
;
15912 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
15914 salt_t
*salt
= hash_buf
->salt
;
15916 char *salt_pos
= input_buf
+ 10;
15918 char *hash_pos
= strchr (salt_pos
, '$');
15920 uint salt_len
= hash_pos
- salt_pos
;
15922 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15926 uint hash_len
= input_len
- 10 - salt_len
- 1;
15928 // base64 decode salt
15930 u8 tmp_buf
[100] = { 0 };
15932 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
15934 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
15936 tmp_buf
[salt_len
] = 0x80;
15938 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
15940 salt
->salt_len
= salt_len
;
15942 // base64 decode salt
15944 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15946 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15948 uint user_len
= hash_len
- 32;
15950 const u8
*tmp_hash
= tmp_buf
+ user_len
;
15952 user_len
--; // skip the trailing space
15954 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
15955 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
15956 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
15957 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
15959 digest
[0] = byte_swap_32 (digest
[0]);
15960 digest
[1] = byte_swap_32 (digest
[1]);
15961 digest
[2] = byte_swap_32 (digest
[2]);
15962 digest
[3] = byte_swap_32 (digest
[3]);
15964 // store username for host only (output hash if cracked)
15966 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
15967 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
15969 return (PARSER_OK
);
15972 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15974 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
15976 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15978 u32
*digest
= (u32
*) hash_buf
->digest
;
15980 salt_t
*salt
= hash_buf
->salt
;
15982 char *iter_pos
= input_buf
+ 10;
15984 u32 iter
= atoi (iter_pos
);
15988 return (PARSER_SALT_ITERATION
);
15991 iter
--; // first iteration is special
15993 salt
->salt_iter
= iter
;
15995 char *base64_pos
= strchr (iter_pos
, '}');
15997 if (base64_pos
== NULL
)
15999 return (PARSER_SIGNATURE_UNMATCHED
);
16004 // base64 decode salt
16006 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16008 u8 tmp_buf
[100] = { 0 };
16010 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16012 if (decoded_len
< 24)
16014 return (PARSER_SALT_LENGTH
);
16019 uint salt_len
= decoded_len
- 20;
16021 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16022 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16024 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16026 salt
->salt_len
= salt_len
;
16030 u32
*digest_ptr
= (u32
*) tmp_buf
;
16032 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16033 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16034 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16035 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16036 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16038 return (PARSER_OK
);
16041 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16043 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16045 u32
*digest
= (u32
*) hash_buf
->digest
;
16047 salt_t
*salt
= hash_buf
->salt
;
16049 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16050 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16051 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16052 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16053 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16055 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16057 uint salt_len
= input_len
- 40 - 1;
16059 char *salt_buf
= input_buf
+ 40 + 1;
16061 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16063 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16065 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16067 salt
->salt_len
= salt_len
;
16069 return (PARSER_OK
);
16072 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16074 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16076 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16078 u32
*digest
= (u32
*) hash_buf
->digest
;
16080 salt_t
*salt
= hash_buf
->salt
;
16082 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16088 char *V_pos
= input_buf
+ 5;
16090 char *R_pos
= strchr (V_pos
, '*');
16092 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16094 u32 V_len
= R_pos
- V_pos
;
16098 char *bits_pos
= strchr (R_pos
, '*');
16100 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16102 u32 R_len
= bits_pos
- R_pos
;
16106 char *P_pos
= strchr (bits_pos
, '*');
16108 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16110 u32 bits_len
= P_pos
- bits_pos
;
16114 char *enc_md_pos
= strchr (P_pos
, '*');
16116 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16118 u32 P_len
= enc_md_pos
- P_pos
;
16122 char *id_len_pos
= strchr (enc_md_pos
, '*');
16124 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16126 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16130 char *id_buf_pos
= strchr (id_len_pos
, '*');
16132 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16134 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16138 char *u_len_pos
= strchr (id_buf_pos
, '*');
16140 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16142 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16144 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16148 char *u_buf_pos
= strchr (u_len_pos
, '*');
16150 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16152 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16156 char *o_len_pos
= strchr (u_buf_pos
, '*');
16158 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16160 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16162 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16166 char *o_buf_pos
= strchr (o_len_pos
, '*');
16168 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16170 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16174 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;
16176 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16180 const int V
= atoi (V_pos
);
16181 const int R
= atoi (R_pos
);
16182 const int P
= atoi (P_pos
);
16184 if (V
!= 1) return (PARSER_SALT_VALUE
);
16185 if (R
!= 2) return (PARSER_SALT_VALUE
);
16187 const int enc_md
= atoi (enc_md_pos
);
16189 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16191 const int id_len
= atoi (id_len_pos
);
16192 const int u_len
= atoi (u_len_pos
);
16193 const int o_len
= atoi (o_len_pos
);
16195 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16196 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16197 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16199 const int bits
= atoi (bits_pos
);
16201 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16203 // copy data to esalt
16209 pdf
->enc_md
= enc_md
;
16211 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16212 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16213 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16214 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16215 pdf
->id_len
= id_len
;
16217 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16218 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16219 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16220 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16221 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16222 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16223 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16224 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16225 pdf
->u_len
= u_len
;
16227 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16228 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16229 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16230 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16231 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16232 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16233 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16234 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16235 pdf
->o_len
= o_len
;
16237 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16238 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16239 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16240 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16242 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16243 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16244 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16245 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16246 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16247 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16248 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16249 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16251 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16252 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16253 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16254 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16255 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16256 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16257 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16258 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16260 // we use ID for salt, maybe needs to change, we will see...
16262 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16263 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16264 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16265 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16266 salt
->salt_len
= pdf
->id_len
;
16268 digest
[0] = pdf
->u_buf
[0];
16269 digest
[1] = pdf
->u_buf
[1];
16270 digest
[2] = pdf
->u_buf
[2];
16271 digest
[3] = pdf
->u_buf
[3];
16273 return (PARSER_OK
);
16276 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16278 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16281 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16283 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16285 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16287 u32
*digest
= (u32
*) hash_buf
->digest
;
16289 salt_t
*salt
= hash_buf
->salt
;
16291 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16297 char *V_pos
= input_buf
+ 5;
16299 char *R_pos
= strchr (V_pos
, '*');
16301 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16303 u32 V_len
= R_pos
- V_pos
;
16307 char *bits_pos
= strchr (R_pos
, '*');
16309 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16311 u32 R_len
= bits_pos
- R_pos
;
16315 char *P_pos
= strchr (bits_pos
, '*');
16317 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16319 u32 bits_len
= P_pos
- bits_pos
;
16323 char *enc_md_pos
= strchr (P_pos
, '*');
16325 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16327 u32 P_len
= enc_md_pos
- P_pos
;
16331 char *id_len_pos
= strchr (enc_md_pos
, '*');
16333 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16335 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16339 char *id_buf_pos
= strchr (id_len_pos
, '*');
16341 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16343 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16347 char *u_len_pos
= strchr (id_buf_pos
, '*');
16349 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16351 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16353 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16357 char *u_buf_pos
= strchr (u_len_pos
, '*');
16359 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16361 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16365 char *o_len_pos
= strchr (u_buf_pos
, '*');
16367 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16369 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16371 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16375 char *o_buf_pos
= strchr (o_len_pos
, '*');
16377 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16379 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16383 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16385 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16387 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16389 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16393 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;
16395 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16399 const int V
= atoi (V_pos
);
16400 const int R
= atoi (R_pos
);
16401 const int P
= atoi (P_pos
);
16403 if (V
!= 1) return (PARSER_SALT_VALUE
);
16404 if (R
!= 2) return (PARSER_SALT_VALUE
);
16406 const int enc_md
= atoi (enc_md_pos
);
16408 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16410 const int id_len
= atoi (id_len_pos
);
16411 const int u_len
= atoi (u_len_pos
);
16412 const int o_len
= atoi (o_len_pos
);
16414 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16415 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16416 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16418 const int bits
= atoi (bits_pos
);
16420 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16422 // copy data to esalt
16428 pdf
->enc_md
= enc_md
;
16430 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16431 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16432 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16433 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16434 pdf
->id_len
= id_len
;
16436 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16437 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16438 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16439 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16440 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16441 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16442 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16443 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16444 pdf
->u_len
= u_len
;
16446 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16447 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16448 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16449 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16450 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16451 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16452 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16453 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16454 pdf
->o_len
= o_len
;
16456 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16457 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16458 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16459 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16461 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16462 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16463 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16464 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16465 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16466 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16467 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16468 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16470 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16471 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16472 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16473 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16474 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16475 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16476 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16477 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16479 pdf
->rc4key
[1] = 0;
16480 pdf
->rc4key
[0] = 0;
16482 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16483 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16484 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16485 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16486 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16487 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16488 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16489 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16490 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16491 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16493 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16494 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16496 // we use ID for salt, maybe needs to change, we will see...
16498 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16499 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16500 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16501 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16502 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16503 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16504 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16505 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16506 salt
->salt_len
= pdf
->id_len
+ 16;
16508 digest
[0] = pdf
->rc4key
[0];
16509 digest
[1] = pdf
->rc4key
[1];
16513 return (PARSER_OK
);
16516 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16518 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16520 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16522 u32
*digest
= (u32
*) hash_buf
->digest
;
16524 salt_t
*salt
= hash_buf
->salt
;
16526 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16532 char *V_pos
= input_buf
+ 5;
16534 char *R_pos
= strchr (V_pos
, '*');
16536 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16538 u32 V_len
= R_pos
- V_pos
;
16542 char *bits_pos
= strchr (R_pos
, '*');
16544 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16546 u32 R_len
= bits_pos
- R_pos
;
16550 char *P_pos
= strchr (bits_pos
, '*');
16552 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16554 u32 bits_len
= P_pos
- bits_pos
;
16558 char *enc_md_pos
= strchr (P_pos
, '*');
16560 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16562 u32 P_len
= enc_md_pos
- P_pos
;
16566 char *id_len_pos
= strchr (enc_md_pos
, '*');
16568 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16570 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16574 char *id_buf_pos
= strchr (id_len_pos
, '*');
16576 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16578 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16582 char *u_len_pos
= strchr (id_buf_pos
, '*');
16584 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16586 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16588 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16592 char *u_buf_pos
= strchr (u_len_pos
, '*');
16594 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16596 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16600 char *o_len_pos
= strchr (u_buf_pos
, '*');
16602 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16604 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16606 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16610 char *o_buf_pos
= strchr (o_len_pos
, '*');
16612 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16614 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16618 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;
16620 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16624 const int V
= atoi (V_pos
);
16625 const int R
= atoi (R_pos
);
16626 const int P
= atoi (P_pos
);
16630 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16631 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16633 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16635 const int id_len
= atoi (id_len_pos
);
16636 const int u_len
= atoi (u_len_pos
);
16637 const int o_len
= atoi (o_len_pos
);
16639 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16641 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16642 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16644 const int bits
= atoi (bits_pos
);
16646 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16652 enc_md
= atoi (enc_md_pos
);
16655 // copy data to esalt
16661 pdf
->enc_md
= enc_md
;
16663 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16664 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16665 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16666 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16670 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
16671 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
16672 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
16673 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
16676 pdf
->id_len
= id_len
;
16678 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16679 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16680 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16681 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16682 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16683 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16684 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16685 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16686 pdf
->u_len
= u_len
;
16688 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16689 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16690 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16691 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16692 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16693 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16694 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16695 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16696 pdf
->o_len
= o_len
;
16698 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16699 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16700 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16701 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16705 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16706 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16707 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16708 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16711 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16712 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16713 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16714 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16715 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16716 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16717 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16718 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16720 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16721 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16722 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16723 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16724 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16725 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16726 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16727 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16729 // precompute rc4 data for later use
16745 uint salt_pc_block
[32] = { 0 };
16747 char *salt_pc_ptr
= (char *) salt_pc_block
;
16749 memcpy (salt_pc_ptr
, padding
, 32);
16750 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16752 uint salt_pc_digest
[4] = { 0 };
16754 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16756 pdf
->rc4data
[0] = salt_pc_digest
[0];
16757 pdf
->rc4data
[1] = salt_pc_digest
[1];
16759 // we use ID for salt, maybe needs to change, we will see...
16761 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16762 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16763 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16764 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16765 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16766 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16767 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16768 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16769 salt
->salt_len
= pdf
->id_len
+ 16;
16771 salt
->salt_iter
= ROUNDS_PDF14
;
16773 digest
[0] = pdf
->u_buf
[0];
16774 digest
[1] = pdf
->u_buf
[1];
16778 return (PARSER_OK
);
16781 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16783 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16785 if (ret
!= PARSER_OK
)
16790 u32
*digest
= (u32
*) hash_buf
->digest
;
16792 salt_t
*salt
= hash_buf
->salt
;
16794 digest
[0] -= SHA256M_A
;
16795 digest
[1] -= SHA256M_B
;
16796 digest
[2] -= SHA256M_C
;
16797 digest
[3] -= SHA256M_D
;
16798 digest
[4] -= SHA256M_E
;
16799 digest
[5] -= SHA256M_F
;
16800 digest
[6] -= SHA256M_G
;
16801 digest
[7] -= SHA256M_H
;
16803 salt
->salt_buf
[2] = 0x80;
16805 return (PARSER_OK
);
16808 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16810 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16812 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16814 u32
*digest
= (u32
*) hash_buf
->digest
;
16816 salt_t
*salt
= hash_buf
->salt
;
16818 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16824 char *V_pos
= input_buf
+ 5;
16826 char *R_pos
= strchr (V_pos
, '*');
16828 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16830 u32 V_len
= R_pos
- V_pos
;
16834 char *bits_pos
= strchr (R_pos
, '*');
16836 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16838 u32 R_len
= bits_pos
- R_pos
;
16842 char *P_pos
= strchr (bits_pos
, '*');
16844 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16846 u32 bits_len
= P_pos
- bits_pos
;
16850 char *enc_md_pos
= strchr (P_pos
, '*');
16852 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16854 u32 P_len
= enc_md_pos
- P_pos
;
16858 char *id_len_pos
= strchr (enc_md_pos
, '*');
16860 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16862 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16866 char *id_buf_pos
= strchr (id_len_pos
, '*');
16868 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16870 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16874 char *u_len_pos
= strchr (id_buf_pos
, '*');
16876 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16878 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16882 char *u_buf_pos
= strchr (u_len_pos
, '*');
16884 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16886 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16890 char *o_len_pos
= strchr (u_buf_pos
, '*');
16892 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16894 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16898 char *o_buf_pos
= strchr (o_len_pos
, '*');
16900 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16902 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16906 char *last
= strchr (o_buf_pos
, '*');
16908 if (last
== NULL
) last
= input_buf
+ input_len
;
16910 u32 o_buf_len
= last
- o_buf_pos
;
16914 const int V
= atoi (V_pos
);
16915 const int R
= atoi (R_pos
);
16919 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
16920 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
16922 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16924 const int bits
= atoi (bits_pos
);
16926 if (bits
!= 256) return (PARSER_SALT_VALUE
);
16928 int enc_md
= atoi (enc_md_pos
);
16930 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
16932 const uint id_len
= atoi (id_len_pos
);
16933 const uint u_len
= atoi (u_len_pos
);
16934 const uint o_len
= atoi (o_len_pos
);
16936 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
16937 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
16938 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
16939 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
16940 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
16941 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
16942 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
16943 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
16945 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
16946 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
16947 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
16949 // copy data to esalt
16951 if (u_len
< 40) return (PARSER_SALT_VALUE
);
16953 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
16955 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
16958 salt
->salt_buf
[0] = pdf
->u_buf
[8];
16959 salt
->salt_buf
[1] = pdf
->u_buf
[9];
16961 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16962 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16964 salt
->salt_len
= 8;
16965 salt
->salt_iter
= ROUNDS_PDF17L8
;
16967 digest
[0] = pdf
->u_buf
[0];
16968 digest
[1] = pdf
->u_buf
[1];
16969 digest
[2] = pdf
->u_buf
[2];
16970 digest
[3] = pdf
->u_buf
[3];
16971 digest
[4] = pdf
->u_buf
[4];
16972 digest
[5] = pdf
->u_buf
[5];
16973 digest
[6] = pdf
->u_buf
[6];
16974 digest
[7] = pdf
->u_buf
[7];
16976 return (PARSER_OK
);
16979 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16981 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
16983 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
16985 u32
*digest
= (u32
*) hash_buf
->digest
;
16987 salt_t
*salt
= hash_buf
->salt
;
16989 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16997 char *iter_pos
= input_buf
+ 7;
16999 u32 iter
= atoi (iter_pos
);
17001 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17002 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17004 // first is *raw* salt
17006 char *salt_pos
= strchr (iter_pos
, ':');
17008 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17012 char *hash_pos
= strchr (salt_pos
, ':');
17014 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17016 u32 salt_len
= hash_pos
- salt_pos
;
17018 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17022 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17024 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17028 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17030 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17032 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17034 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17035 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17037 salt
->salt_len
= salt_len
;
17038 salt
->salt_iter
= iter
- 1;
17042 u8 tmp_buf
[100] = { 0 };
17044 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17046 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17048 memcpy (digest
, tmp_buf
, 16);
17050 digest
[0] = byte_swap_32 (digest
[0]);
17051 digest
[1] = byte_swap_32 (digest
[1]);
17052 digest
[2] = byte_swap_32 (digest
[2]);
17053 digest
[3] = byte_swap_32 (digest
[3]);
17055 // add some stuff to normal salt to make sorted happy
17057 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17058 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17059 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17060 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17061 salt
->salt_buf
[4] = salt
->salt_iter
;
17063 return (PARSER_OK
);
17066 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17068 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17070 u32
*digest
= (u32
*) hash_buf
->digest
;
17072 salt_t
*salt
= hash_buf
->salt
;
17074 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17075 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17076 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17077 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17079 digest
[0] = byte_swap_32 (digest
[0]);
17080 digest
[1] = byte_swap_32 (digest
[1]);
17081 digest
[2] = byte_swap_32 (digest
[2]);
17082 digest
[3] = byte_swap_32 (digest
[3]);
17084 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17086 uint salt_len
= input_len
- 32 - 1;
17088 char *salt_buf
= input_buf
+ 32 + 1;
17090 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17092 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17094 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17096 salt
->salt_len
= salt_len
;
17098 return (PARSER_OK
);
17101 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17103 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17105 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17107 u32
*digest
= (u32
*) hash_buf
->digest
;
17109 salt_t
*salt
= hash_buf
->salt
;
17111 char *user_pos
= input_buf
+ 10;
17113 char *salt_pos
= strchr (user_pos
, '*');
17115 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17119 char *hash_pos
= strchr (salt_pos
, '*');
17123 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17125 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17127 uint user_len
= salt_pos
- user_pos
- 1;
17129 uint salt_len
= hash_pos
- salt_pos
- 1;
17131 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17137 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17138 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17139 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17140 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17142 digest
[0] = byte_swap_32 (digest
[0]);
17143 digest
[1] = byte_swap_32 (digest
[1]);
17144 digest
[2] = byte_swap_32 (digest
[2]);
17145 digest
[3] = byte_swap_32 (digest
[3]);
17147 digest
[0] -= MD5M_A
;
17148 digest
[1] -= MD5M_B
;
17149 digest
[2] -= MD5M_C
;
17150 digest
[3] -= MD5M_D
;
17156 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17158 // first 4 bytes are the "challenge"
17160 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17161 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17162 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17163 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17165 // append the user name
17167 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17169 salt
->salt_len
= 4 + user_len
;
17171 return (PARSER_OK
);
17174 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17176 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17178 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17180 u32
*digest
= (u32
*) hash_buf
->digest
;
17182 salt_t
*salt
= hash_buf
->salt
;
17184 char *salt_pos
= input_buf
+ 9;
17186 char *hash_pos
= strchr (salt_pos
, '*');
17188 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17192 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17194 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17196 uint salt_len
= hash_pos
- salt_pos
- 1;
17198 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17204 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17205 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17206 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17207 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17208 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17214 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17216 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17218 salt
->salt_len
= salt_len
;
17220 return (PARSER_OK
);
17223 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17225 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17227 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17229 u32
*digest
= (u32
*) hash_buf
->digest
;
17231 salt_t
*salt
= hash_buf
->salt
;
17233 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17239 char *cry_master_len_pos
= input_buf
+ 9;
17241 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17243 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17245 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17247 cry_master_buf_pos
++;
17249 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17251 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17253 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17255 cry_salt_len_pos
++;
17257 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17259 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17261 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17263 cry_salt_buf_pos
++;
17265 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17267 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17269 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17273 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17275 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17277 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17281 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17283 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17285 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17289 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17291 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17293 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17295 public_key_len_pos
++;
17297 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17299 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17301 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17303 public_key_buf_pos
++;
17305 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;
17307 const uint cry_master_len
= atoi (cry_master_len_pos
);
17308 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17309 const uint ckey_len
= atoi (ckey_len_pos
);
17310 const uint public_key_len
= atoi (public_key_len_pos
);
17312 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17313 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17314 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17315 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17317 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17319 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17321 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17324 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17326 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17328 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17331 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17333 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17335 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17338 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17339 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17340 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17343 * store digest (should be unique enought, hopefully)
17346 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17347 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17348 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17349 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17355 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17357 const uint cry_rounds
= atoi (cry_rounds_pos
);
17359 salt
->salt_iter
= cry_rounds
- 1;
17361 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17363 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17365 salt
->salt_len
= salt_len
;
17367 return (PARSER_OK
);
17370 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17372 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17374 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17376 u32
*digest
= (u32
*) hash_buf
->digest
;
17378 salt_t
*salt
= hash_buf
->salt
;
17380 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17382 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17384 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17386 memcpy (temp_input_buf
, input_buf
, input_len
);
17390 char *URI_server_pos
= temp_input_buf
+ 6;
17392 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17394 if (URI_client_pos
== NULL
)
17396 myfree (temp_input_buf
);
17398 return (PARSER_SEPARATOR_UNMATCHED
);
17401 URI_client_pos
[0] = 0;
17404 uint URI_server_len
= strlen (URI_server_pos
);
17406 if (URI_server_len
> 512)
17408 myfree (temp_input_buf
);
17410 return (PARSER_SALT_LENGTH
);
17415 char *user_pos
= strchr (URI_client_pos
, '*');
17417 if (user_pos
== NULL
)
17419 myfree (temp_input_buf
);
17421 return (PARSER_SEPARATOR_UNMATCHED
);
17427 uint URI_client_len
= strlen (URI_client_pos
);
17429 if (URI_client_len
> 512)
17431 myfree (temp_input_buf
);
17433 return (PARSER_SALT_LENGTH
);
17438 char *realm_pos
= strchr (user_pos
, '*');
17440 if (realm_pos
== NULL
)
17442 myfree (temp_input_buf
);
17444 return (PARSER_SEPARATOR_UNMATCHED
);
17450 uint user_len
= strlen (user_pos
);
17452 if (user_len
> 116)
17454 myfree (temp_input_buf
);
17456 return (PARSER_SALT_LENGTH
);
17461 char *method_pos
= strchr (realm_pos
, '*');
17463 if (method_pos
== NULL
)
17465 myfree (temp_input_buf
);
17467 return (PARSER_SEPARATOR_UNMATCHED
);
17473 uint realm_len
= strlen (realm_pos
);
17475 if (realm_len
> 116)
17477 myfree (temp_input_buf
);
17479 return (PARSER_SALT_LENGTH
);
17484 char *URI_prefix_pos
= strchr (method_pos
, '*');
17486 if (URI_prefix_pos
== NULL
)
17488 myfree (temp_input_buf
);
17490 return (PARSER_SEPARATOR_UNMATCHED
);
17493 URI_prefix_pos
[0] = 0;
17496 uint method_len
= strlen (method_pos
);
17498 if (method_len
> 246)
17500 myfree (temp_input_buf
);
17502 return (PARSER_SALT_LENGTH
);
17507 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17509 if (URI_resource_pos
== NULL
)
17511 myfree (temp_input_buf
);
17513 return (PARSER_SEPARATOR_UNMATCHED
);
17516 URI_resource_pos
[0] = 0;
17517 URI_resource_pos
++;
17519 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17521 if (URI_prefix_len
> 245)
17523 myfree (temp_input_buf
);
17525 return (PARSER_SALT_LENGTH
);
17530 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17532 if (URI_suffix_pos
== NULL
)
17534 myfree (temp_input_buf
);
17536 return (PARSER_SEPARATOR_UNMATCHED
);
17539 URI_suffix_pos
[0] = 0;
17542 uint URI_resource_len
= strlen (URI_resource_pos
);
17544 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17546 myfree (temp_input_buf
);
17548 return (PARSER_SALT_LENGTH
);
17553 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17555 if (nonce_pos
== NULL
)
17557 myfree (temp_input_buf
);
17559 return (PARSER_SEPARATOR_UNMATCHED
);
17565 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17567 if (URI_suffix_len
> 245)
17569 myfree (temp_input_buf
);
17571 return (PARSER_SALT_LENGTH
);
17576 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17578 if (nonce_client_pos
== NULL
)
17580 myfree (temp_input_buf
);
17582 return (PARSER_SEPARATOR_UNMATCHED
);
17585 nonce_client_pos
[0] = 0;
17586 nonce_client_pos
++;
17588 uint nonce_len
= strlen (nonce_pos
);
17590 if (nonce_len
< 1 || nonce_len
> 50)
17592 myfree (temp_input_buf
);
17594 return (PARSER_SALT_LENGTH
);
17599 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17601 if (nonce_count_pos
== NULL
)
17603 myfree (temp_input_buf
);
17605 return (PARSER_SEPARATOR_UNMATCHED
);
17608 nonce_count_pos
[0] = 0;
17611 uint nonce_client_len
= strlen (nonce_client_pos
);
17613 if (nonce_client_len
> 50)
17615 myfree (temp_input_buf
);
17617 return (PARSER_SALT_LENGTH
);
17622 char *qop_pos
= strchr (nonce_count_pos
, '*');
17624 if (qop_pos
== NULL
)
17626 myfree (temp_input_buf
);
17628 return (PARSER_SEPARATOR_UNMATCHED
);
17634 uint nonce_count_len
= strlen (nonce_count_pos
);
17636 if (nonce_count_len
> 50)
17638 myfree (temp_input_buf
);
17640 return (PARSER_SALT_LENGTH
);
17645 char *directive_pos
= strchr (qop_pos
, '*');
17647 if (directive_pos
== NULL
)
17649 myfree (temp_input_buf
);
17651 return (PARSER_SEPARATOR_UNMATCHED
);
17654 directive_pos
[0] = 0;
17657 uint qop_len
= strlen (qop_pos
);
17661 myfree (temp_input_buf
);
17663 return (PARSER_SALT_LENGTH
);
17668 char *digest_pos
= strchr (directive_pos
, '*');
17670 if (digest_pos
== NULL
)
17672 myfree (temp_input_buf
);
17674 return (PARSER_SEPARATOR_UNMATCHED
);
17680 uint directive_len
= strlen (directive_pos
);
17682 if (directive_len
!= 3)
17684 myfree (temp_input_buf
);
17686 return (PARSER_SALT_LENGTH
);
17689 if (memcmp (directive_pos
, "MD5", 3))
17691 log_info ("ERROR: only the MD5 directive is currently supported\n");
17693 myfree (temp_input_buf
);
17695 return (PARSER_SIP_AUTH_DIRECTIVE
);
17699 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17704 uint md5_max_len
= 4 * 64;
17706 uint md5_remaining_len
= md5_max_len
;
17708 uint tmp_md5_buf
[64] = { 0 };
17710 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17712 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17714 md5_len
+= method_len
+ 1;
17715 tmp_md5_ptr
+= method_len
+ 1;
17717 if (URI_prefix_len
> 0)
17719 md5_remaining_len
= md5_max_len
- md5_len
;
17721 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17723 md5_len
+= URI_prefix_len
+ 1;
17724 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17727 md5_remaining_len
= md5_max_len
- md5_len
;
17729 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17731 md5_len
+= URI_resource_len
;
17732 tmp_md5_ptr
+= URI_resource_len
;
17734 if (URI_suffix_len
> 0)
17736 md5_remaining_len
= md5_max_len
- md5_len
;
17738 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17740 md5_len
+= 1 + URI_suffix_len
;
17743 uint tmp_digest
[4] = { 0 };
17745 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17747 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17748 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17749 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17750 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17756 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17758 uint esalt_len
= 0;
17760 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17762 // there are 2 possibilities for the esalt:
17764 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17766 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17768 if (esalt_len
> max_esalt_len
)
17770 myfree (temp_input_buf
);
17772 return (PARSER_SALT_LENGTH
);
17775 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17787 esalt_len
= 1 + nonce_len
+ 1 + 32;
17789 if (esalt_len
> max_esalt_len
)
17791 myfree (temp_input_buf
);
17793 return (PARSER_SALT_LENGTH
);
17796 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17804 // add 0x80 to esalt
17806 esalt_buf_ptr
[esalt_len
] = 0x80;
17808 sip
->esalt_len
= esalt_len
;
17814 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17816 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17818 uint max_salt_len
= 119;
17820 if (salt_len
> max_salt_len
)
17822 myfree (temp_input_buf
);
17824 return (PARSER_SALT_LENGTH
);
17827 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17829 sip
->salt_len
= salt_len
;
17832 * fake salt (for sorting)
17835 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17839 uint fake_salt_len
= salt_len
;
17841 if (fake_salt_len
> max_salt_len
)
17843 fake_salt_len
= max_salt_len
;
17846 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17848 salt
->salt_len
= fake_salt_len
;
17854 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
17855 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
17856 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
17857 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
17859 digest
[0] = byte_swap_32 (digest
[0]);
17860 digest
[1] = byte_swap_32 (digest
[1]);
17861 digest
[2] = byte_swap_32 (digest
[2]);
17862 digest
[3] = byte_swap_32 (digest
[3]);
17864 myfree (temp_input_buf
);
17866 return (PARSER_OK
);
17869 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17871 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17873 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17875 u32
*digest
= (u32
*) hash_buf
->digest
;
17877 salt_t
*salt
= hash_buf
->salt
;
17881 char *digest_pos
= input_buf
;
17883 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
17890 char *salt_buf
= input_buf
+ 8 + 1;
17894 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17896 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17898 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17900 salt
->salt_len
= salt_len
;
17902 return (PARSER_OK
);
17905 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17907 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
17909 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17911 u32
*digest
= (u32
*) hash_buf
->digest
;
17913 salt_t
*salt
= hash_buf
->salt
;
17915 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
17921 char *p_buf_pos
= input_buf
+ 4;
17923 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
17925 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17927 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
17929 NumCyclesPower_pos
++;
17931 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
17933 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17935 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
17939 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
17941 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17943 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
17947 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
17949 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17951 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
17955 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
17957 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17959 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
17963 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
17965 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17967 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
17971 char *data_len_pos
= strchr (crc_buf_pos
, '$');
17973 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17975 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
17979 char *unpack_size_pos
= strchr (data_len_pos
, '$');
17981 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17983 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
17987 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
17989 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17991 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
17995 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;
17997 const uint iter
= atoi (NumCyclesPower_pos
);
17998 const uint crc
= atoi (crc_buf_pos
);
17999 const uint p_buf
= atoi (p_buf_pos
);
18000 const uint salt_len
= atoi (salt_len_pos
);
18001 const uint iv_len
= atoi (iv_len_pos
);
18002 const uint unpack_size
= atoi (unpack_size_pos
);
18003 const uint data_len
= atoi (data_len_pos
);
18009 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18010 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18012 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18014 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18016 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18022 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18023 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18024 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18025 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18027 seven_zip
->iv_len
= iv_len
;
18029 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18031 seven_zip
->salt_len
= 0;
18033 seven_zip
->crc
= crc
;
18035 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18037 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18039 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18042 seven_zip
->data_len
= data_len
;
18044 seven_zip
->unpack_size
= unpack_size
;
18048 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18049 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18050 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18051 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18053 salt
->salt_len
= 16;
18055 salt
->salt_sign
[0] = iter
;
18057 salt
->salt_iter
= 1 << iter
;
18068 return (PARSER_OK
);
18071 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18073 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18075 u32
*digest
= (u32
*) hash_buf
->digest
;
18077 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18078 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18079 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18080 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18081 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18082 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18083 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18084 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18086 digest
[0] = byte_swap_32 (digest
[0]);
18087 digest
[1] = byte_swap_32 (digest
[1]);
18088 digest
[2] = byte_swap_32 (digest
[2]);
18089 digest
[3] = byte_swap_32 (digest
[3]);
18090 digest
[4] = byte_swap_32 (digest
[4]);
18091 digest
[5] = byte_swap_32 (digest
[5]);
18092 digest
[6] = byte_swap_32 (digest
[6]);
18093 digest
[7] = byte_swap_32 (digest
[7]);
18095 return (PARSER_OK
);
18098 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18100 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18102 u32
*digest
= (u32
*) hash_buf
->digest
;
18104 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18105 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18106 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18107 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18108 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18109 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18110 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18111 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18112 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18113 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18114 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18115 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18116 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18117 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18118 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18119 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18121 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18122 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18123 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18124 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18125 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18126 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18127 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18128 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18129 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18130 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18131 digest
[10] = byte_swap_32 (digest
[10]);
18132 digest
[11] = byte_swap_32 (digest
[11]);
18133 digest
[12] = byte_swap_32 (digest
[12]);
18134 digest
[13] = byte_swap_32 (digest
[13]);
18135 digest
[14] = byte_swap_32 (digest
[14]);
18136 digest
[15] = byte_swap_32 (digest
[15]);
18138 return (PARSER_OK
);
18141 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18143 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18145 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18147 u32
*digest
= (u32
*) hash_buf
->digest
;
18149 salt_t
*salt
= hash_buf
->salt
;
18151 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18159 char *iter_pos
= input_buf
+ 4;
18161 u32 iter
= atoi (iter_pos
);
18163 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18164 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18166 // first is *raw* salt
18168 char *salt_pos
= strchr (iter_pos
, ':');
18170 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18174 char *hash_pos
= strchr (salt_pos
, ':');
18176 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18178 u32 salt_len
= hash_pos
- salt_pos
;
18180 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18184 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18186 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18190 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18192 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18194 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18196 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18197 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18199 salt
->salt_len
= salt_len
;
18200 salt
->salt_iter
= iter
- 1;
18204 u8 tmp_buf
[100] = { 0 };
18206 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18208 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18210 memcpy (digest
, tmp_buf
, 16);
18212 // add some stuff to normal salt to make sorted happy
18214 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18215 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18216 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18217 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18218 salt
->salt_buf
[4] = salt
->salt_iter
;
18220 return (PARSER_OK
);
18223 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18225 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18227 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18229 u32
*digest
= (u32
*) hash_buf
->digest
;
18231 salt_t
*salt
= hash_buf
->salt
;
18233 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18241 char *iter_pos
= input_buf
+ 5;
18243 u32 iter
= atoi (iter_pos
);
18245 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18246 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18248 // first is *raw* salt
18250 char *salt_pos
= strchr (iter_pos
, ':');
18252 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18256 char *hash_pos
= strchr (salt_pos
, ':');
18258 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18260 u32 salt_len
= hash_pos
- salt_pos
;
18262 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18266 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18268 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18272 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18274 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18276 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18278 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18279 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18281 salt
->salt_len
= salt_len
;
18282 salt
->salt_iter
= iter
- 1;
18286 u8 tmp_buf
[100] = { 0 };
18288 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18290 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18292 memcpy (digest
, tmp_buf
, 16);
18294 digest
[0] = byte_swap_32 (digest
[0]);
18295 digest
[1] = byte_swap_32 (digest
[1]);
18296 digest
[2] = byte_swap_32 (digest
[2]);
18297 digest
[3] = byte_swap_32 (digest
[3]);
18299 // add some stuff to normal salt to make sorted happy
18301 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18302 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18303 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18304 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18305 salt
->salt_buf
[4] = salt
->salt_iter
;
18307 return (PARSER_OK
);
18310 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18312 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18314 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18316 u64
*digest
= (u64
*) hash_buf
->digest
;
18318 salt_t
*salt
= hash_buf
->salt
;
18320 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18328 char *iter_pos
= input_buf
+ 7;
18330 u32 iter
= atoi (iter_pos
);
18332 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18333 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18335 // first is *raw* salt
18337 char *salt_pos
= strchr (iter_pos
, ':');
18339 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18343 char *hash_pos
= strchr (salt_pos
, ':');
18345 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18347 u32 salt_len
= hash_pos
- salt_pos
;
18349 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18353 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18355 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18359 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18361 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18363 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18365 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18366 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18368 salt
->salt_len
= salt_len
;
18369 salt
->salt_iter
= iter
- 1;
18373 u8 tmp_buf
[100] = { 0 };
18375 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18377 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18379 memcpy (digest
, tmp_buf
, 64);
18381 digest
[0] = byte_swap_64 (digest
[0]);
18382 digest
[1] = byte_swap_64 (digest
[1]);
18383 digest
[2] = byte_swap_64 (digest
[2]);
18384 digest
[3] = byte_swap_64 (digest
[3]);
18385 digest
[4] = byte_swap_64 (digest
[4]);
18386 digest
[5] = byte_swap_64 (digest
[5]);
18387 digest
[6] = byte_swap_64 (digest
[6]);
18388 digest
[7] = byte_swap_64 (digest
[7]);
18390 // add some stuff to normal salt to make sorted happy
18392 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18393 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18394 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18395 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18396 salt
->salt_buf
[4] = salt
->salt_iter
;
18398 return (PARSER_OK
);
18401 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18403 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18405 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18407 uint
*digest
= (uint
*) hash_buf
->digest
;
18409 salt_t
*salt
= hash_buf
->salt
;
18415 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18417 char *hash_pos
= strchr (salt_pos
, '$');
18419 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18421 u32 salt_len
= hash_pos
- salt_pos
;
18423 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18427 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18429 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18433 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18434 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18452 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18453 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18455 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18456 salt
->salt_len
= 8;
18458 return (PARSER_OK
);
18461 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18463 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18465 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18467 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18469 if (c19
& 3) return (PARSER_HASH_VALUE
);
18471 salt_t
*salt
= hash_buf
->salt
;
18473 u32
*digest
= (u32
*) hash_buf
->digest
;
18477 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18478 | itoa64_to_int (input_buf
[2]) << 6
18479 | itoa64_to_int (input_buf
[3]) << 12
18480 | itoa64_to_int (input_buf
[4]) << 18;
18484 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18485 | itoa64_to_int (input_buf
[6]) << 6
18486 | itoa64_to_int (input_buf
[7]) << 12
18487 | itoa64_to_int (input_buf
[8]) << 18;
18489 salt
->salt_len
= 4;
18491 u8 tmp_buf
[100] = { 0 };
18493 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18495 memcpy (digest
, tmp_buf
, 8);
18499 IP (digest
[0], digest
[1], tt
);
18501 digest
[0] = rotr32 (digest
[0], 31);
18502 digest
[1] = rotr32 (digest
[1], 31);
18506 return (PARSER_OK
);
18509 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18511 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18513 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18515 u32
*digest
= (u32
*) hash_buf
->digest
;
18517 salt_t
*salt
= hash_buf
->salt
;
18523 char *type_pos
= input_buf
+ 6 + 1;
18525 char *salt_pos
= strchr (type_pos
, '*');
18527 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18529 u32 type_len
= salt_pos
- type_pos
;
18531 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18535 char *crypted_pos
= strchr (salt_pos
, '*');
18537 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18539 u32 salt_len
= crypted_pos
- salt_pos
;
18541 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18545 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18547 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18553 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18554 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18556 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18557 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18559 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18560 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18561 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18562 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18564 salt
->salt_len
= 24;
18565 salt
->salt_iter
= ROUNDS_RAR3
;
18567 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18568 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18570 digest
[0] = 0xc43d7b00;
18571 digest
[1] = 0x40070000;
18575 return (PARSER_OK
);
18578 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18580 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18582 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18584 u32
*digest
= (u32
*) hash_buf
->digest
;
18586 salt_t
*salt
= hash_buf
->salt
;
18588 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18594 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18596 char *param1_pos
= strchr (param0_pos
, '$');
18598 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18600 u32 param0_len
= param1_pos
- param0_pos
;
18604 char *param2_pos
= strchr (param1_pos
, '$');
18606 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18608 u32 param1_len
= param2_pos
- param1_pos
;
18612 char *param3_pos
= strchr (param2_pos
, '$');
18614 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18616 u32 param2_len
= param3_pos
- param2_pos
;
18620 char *param4_pos
= strchr (param3_pos
, '$');
18622 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18624 u32 param3_len
= param4_pos
- param3_pos
;
18628 char *param5_pos
= strchr (param4_pos
, '$');
18630 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18632 u32 param4_len
= param5_pos
- param4_pos
;
18636 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18638 char *salt_buf
= param1_pos
;
18639 char *iv
= param3_pos
;
18640 char *pswcheck
= param5_pos
;
18642 const uint salt_len
= atoi (param0_pos
);
18643 const uint iterations
= atoi (param2_pos
);
18644 const uint pswcheck_len
= atoi (param4_pos
);
18650 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18651 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18652 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18654 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18655 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18656 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18662 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18663 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18664 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18665 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
18667 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
18668 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
18669 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
18670 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
18672 salt
->salt_len
= 16;
18674 salt
->salt_sign
[0] = iterations
;
18676 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18682 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
18683 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
18687 return (PARSER_OK
);
18690 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18692 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18694 u32
*digest
= (u32
*) hash_buf
->digest
;
18696 salt_t
*salt
= hash_buf
->salt
;
18698 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18699 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18700 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18701 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18702 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18703 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18704 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18705 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18707 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18709 uint salt_len
= input_len
- 64 - 1;
18711 char *salt_buf
= input_buf
+ 64 + 1;
18713 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18715 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18717 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18719 salt
->salt_len
= salt_len
;
18722 * we can precompute the first sha256 transform
18725 uint w
[16] = { 0 };
18727 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18728 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18729 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18730 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18731 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18732 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18733 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18734 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18735 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18736 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18737 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18738 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18739 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18740 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18741 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18742 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18744 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
18746 sha256_64 (w
, pc256
);
18748 salt
->salt_buf_pc
[0] = pc256
[0];
18749 salt
->salt_buf_pc
[1] = pc256
[1];
18750 salt
->salt_buf_pc
[2] = pc256
[2];
18751 salt
->salt_buf_pc
[3] = pc256
[3];
18752 salt
->salt_buf_pc
[4] = pc256
[4];
18753 salt
->salt_buf_pc
[5] = pc256
[5];
18754 salt
->salt_buf_pc
[6] = pc256
[6];
18755 salt
->salt_buf_pc
[7] = pc256
[7];
18757 digest
[0] -= pc256
[0];
18758 digest
[1] -= pc256
[1];
18759 digest
[2] -= pc256
[2];
18760 digest
[3] -= pc256
[3];
18761 digest
[4] -= pc256
[4];
18762 digest
[5] -= pc256
[5];
18763 digest
[6] -= pc256
[6];
18764 digest
[7] -= pc256
[7];
18766 return (PARSER_OK
);
18769 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18771 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18773 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18775 u32
*digest
= (u32
*) hash_buf
->digest
;
18777 salt_t
*salt
= hash_buf
->salt
;
18783 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18785 char *data_buf_pos
= strchr (data_len_pos
, '$');
18787 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18789 u32 data_len_len
= data_buf_pos
- data_len_pos
;
18791 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18792 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18796 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18798 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
18800 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
18802 u32 data_len
= atoi (data_len_pos
);
18804 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
18810 char *salt_pos
= data_buf_pos
;
18812 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18813 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18814 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
18815 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
18817 // this is actually the CT, which is also the hash later (if matched)
18819 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
18820 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
18821 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
18822 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
18824 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
18826 salt
->salt_iter
= 10 - 1;
18832 digest
[0] = salt
->salt_buf
[4];
18833 digest
[1] = salt
->salt_buf
[5];
18834 digest
[2] = salt
->salt_buf
[6];
18835 digest
[3] = salt
->salt_buf
[7];
18837 return (PARSER_OK
);
18840 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18842 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
18844 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18846 u32
*digest
= (u32
*) hash_buf
->digest
;
18848 salt_t
*salt
= hash_buf
->salt
;
18854 char *salt_pos
= input_buf
+ 11 + 1;
18856 char *iter_pos
= strchr (salt_pos
, ',');
18858 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18860 u32 salt_len
= iter_pos
- salt_pos
;
18862 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
18866 char *hash_pos
= strchr (iter_pos
, ',');
18868 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18870 u32 iter_len
= hash_pos
- iter_pos
;
18872 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
18876 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
18878 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
18884 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18885 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18886 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
18887 salt
->salt_buf
[3] = 0x00018000;
18889 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18890 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18891 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
18892 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
18894 salt
->salt_len
= salt_len
/ 2;
18896 salt
->salt_iter
= atoi (iter_pos
) - 1;
18902 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18903 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18904 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18905 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18906 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18907 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
18908 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
18909 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
18911 return (PARSER_OK
);
18914 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18916 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
18918 u32
*digest
= (u32
*) hash_buf
->digest
;
18920 salt_t
*salt
= hash_buf
->salt
;
18926 char *hash_pos
= input_buf
+ 64;
18927 char *salt1_pos
= input_buf
+ 128;
18928 char *salt2_pos
= input_buf
;
18934 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
18935 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
18936 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
18937 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
18939 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
18940 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
18941 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
18942 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
18944 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
18945 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
18946 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
18947 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
18949 salt
->salt_len
= 48;
18951 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
18957 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18958 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18959 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18960 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18961 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18962 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
18963 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
18964 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
18966 return (PARSER_OK
);
18970 * parallel running threads
18975 BOOL WINAPI
sigHandler_default (DWORD sig
)
18979 case CTRL_CLOSE_EVENT
:
18982 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
18983 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
18984 * function otherwise it is too late (e.g. after returning from this function)
18989 SetConsoleCtrlHandler (NULL
, TRUE
);
18996 case CTRL_LOGOFF_EVENT
:
18997 case CTRL_SHUTDOWN_EVENT
:
19001 SetConsoleCtrlHandler (NULL
, TRUE
);
19009 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19013 case CTRL_CLOSE_EVENT
:
19017 SetConsoleCtrlHandler (NULL
, TRUE
);
19024 case CTRL_LOGOFF_EVENT
:
19025 case CTRL_SHUTDOWN_EVENT
:
19029 SetConsoleCtrlHandler (NULL
, TRUE
);
19037 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19039 if (callback
== NULL
)
19041 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19045 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19051 void sigHandler_default (int sig
)
19055 signal (sig
, NULL
);
19058 void sigHandler_benchmark (int sig
)
19062 signal (sig
, NULL
);
19065 void hc_signal (void (callback
) (int))
19067 if (callback
== NULL
) callback
= SIG_DFL
;
19069 signal (SIGINT
, callback
);
19070 signal (SIGTERM
, callback
);
19071 signal (SIGABRT
, callback
);
19076 void status_display ();
19078 void *thread_keypress (void *p
)
19080 int benchmark
= *((int *) p
);
19082 uint quiet
= data
.quiet
;
19086 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19088 int ch
= tty_getchar();
19090 if (ch
== -1) break;
19092 if (ch
== 0) continue;
19098 hc_thread_mutex_lock (mux_display
);
19113 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19114 if (quiet
== 0) fflush (stdout
);
19126 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19127 if (quiet
== 0) fflush (stdout
);
19139 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19140 if (quiet
== 0) fflush (stdout
);
19152 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19153 if (quiet
== 0) fflush (stdout
);
19161 if (benchmark
== 1) break;
19163 stop_at_checkpoint ();
19167 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19168 if (quiet
== 0) fflush (stdout
);
19176 if (benchmark
== 1)
19188 hc_thread_mutex_unlock (mux_display
);
19200 bool class_num (const u8 c
)
19202 return ((c
>= '0') && (c
<= '9'));
19205 bool class_lower (const u8 c
)
19207 return ((c
>= 'a') && (c
<= 'z'));
19210 bool class_upper (const u8 c
)
19212 return ((c
>= 'A') && (c
<= 'Z'));
19215 bool class_alpha (const u8 c
)
19217 return (class_lower (c
) || class_upper (c
));
19220 int conv_ctoi (const u8 c
)
19226 else if (class_upper (c
))
19228 return c
- 'A' + 10;
19234 int conv_itoc (const u8 c
)
19242 return c
+ 'A' - 10;
19252 #define INCR_POS if (++rule_pos == rule_len) return (-1)
19253 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
19254 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
19255 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
19256 #define MAX_KERNEL_RULES 255
19257 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
19258 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19259 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19261 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
19262 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
19263 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19264 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19266 int cpu_rule_to_kernel_rule (char rule_buf
[BUFSIZ
], uint rule_len
, kernel_rule_t
*rule
)
19271 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19273 switch (rule_buf
[rule_pos
])
19279 case RULE_OP_MANGLE_NOOP
:
19280 SET_NAME (rule
, rule_buf
[rule_pos
]);
19283 case RULE_OP_MANGLE_LREST
:
19284 SET_NAME (rule
, rule_buf
[rule_pos
]);
19287 case RULE_OP_MANGLE_UREST
:
19288 SET_NAME (rule
, rule_buf
[rule_pos
]);
19291 case RULE_OP_MANGLE_LREST_UFIRST
:
19292 SET_NAME (rule
, rule_buf
[rule_pos
]);
19295 case RULE_OP_MANGLE_UREST_LFIRST
:
19296 SET_NAME (rule
, rule_buf
[rule_pos
]);
19299 case RULE_OP_MANGLE_TREST
:
19300 SET_NAME (rule
, rule_buf
[rule_pos
]);
19303 case RULE_OP_MANGLE_TOGGLE_AT
:
19304 SET_NAME (rule
, rule_buf
[rule_pos
]);
19305 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19308 case RULE_OP_MANGLE_REVERSE
:
19309 SET_NAME (rule
, rule_buf
[rule_pos
]);
19312 case RULE_OP_MANGLE_DUPEWORD
:
19313 SET_NAME (rule
, rule_buf
[rule_pos
]);
19316 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19317 SET_NAME (rule
, rule_buf
[rule_pos
]);
19318 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19321 case RULE_OP_MANGLE_REFLECT
:
19322 SET_NAME (rule
, rule_buf
[rule_pos
]);
19325 case RULE_OP_MANGLE_ROTATE_LEFT
:
19326 SET_NAME (rule
, rule_buf
[rule_pos
]);
19329 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19330 SET_NAME (rule
, rule_buf
[rule_pos
]);
19333 case RULE_OP_MANGLE_APPEND
:
19334 SET_NAME (rule
, rule_buf
[rule_pos
]);
19335 SET_P0 (rule
, rule_buf
[rule_pos
]);
19338 case RULE_OP_MANGLE_PREPEND
:
19339 SET_NAME (rule
, rule_buf
[rule_pos
]);
19340 SET_P0 (rule
, rule_buf
[rule_pos
]);
19343 case RULE_OP_MANGLE_DELETE_FIRST
:
19344 SET_NAME (rule
, rule_buf
[rule_pos
]);
19347 case RULE_OP_MANGLE_DELETE_LAST
:
19348 SET_NAME (rule
, rule_buf
[rule_pos
]);
19351 case RULE_OP_MANGLE_DELETE_AT
:
19352 SET_NAME (rule
, rule_buf
[rule_pos
]);
19353 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19356 case RULE_OP_MANGLE_EXTRACT
:
19357 SET_NAME (rule
, rule_buf
[rule_pos
]);
19358 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19359 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19362 case RULE_OP_MANGLE_OMIT
:
19363 SET_NAME (rule
, rule_buf
[rule_pos
]);
19364 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19365 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19368 case RULE_OP_MANGLE_INSERT
:
19369 SET_NAME (rule
, rule_buf
[rule_pos
]);
19370 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19371 SET_P1 (rule
, rule_buf
[rule_pos
]);
19374 case RULE_OP_MANGLE_OVERSTRIKE
:
19375 SET_NAME (rule
, rule_buf
[rule_pos
]);
19376 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19377 SET_P1 (rule
, rule_buf
[rule_pos
]);
19380 case RULE_OP_MANGLE_TRUNCATE_AT
:
19381 SET_NAME (rule
, rule_buf
[rule_pos
]);
19382 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19385 case RULE_OP_MANGLE_REPLACE
:
19386 SET_NAME (rule
, rule_buf
[rule_pos
]);
19387 SET_P0 (rule
, rule_buf
[rule_pos
]);
19388 SET_P1 (rule
, rule_buf
[rule_pos
]);
19391 case RULE_OP_MANGLE_PURGECHAR
:
19395 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19399 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19400 SET_NAME (rule
, rule_buf
[rule_pos
]);
19401 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19404 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19405 SET_NAME (rule
, rule_buf
[rule_pos
]);
19406 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19409 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19410 SET_NAME (rule
, rule_buf
[rule_pos
]);
19413 case RULE_OP_MANGLE_SWITCH_FIRST
:
19414 SET_NAME (rule
, rule_buf
[rule_pos
]);
19417 case RULE_OP_MANGLE_SWITCH_LAST
:
19418 SET_NAME (rule
, rule_buf
[rule_pos
]);
19421 case RULE_OP_MANGLE_SWITCH_AT
:
19422 SET_NAME (rule
, rule_buf
[rule_pos
]);
19423 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19424 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19427 case RULE_OP_MANGLE_CHR_SHIFTL
:
19428 SET_NAME (rule
, rule_buf
[rule_pos
]);
19429 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19432 case RULE_OP_MANGLE_CHR_SHIFTR
:
19433 SET_NAME (rule
, rule_buf
[rule_pos
]);
19434 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19437 case RULE_OP_MANGLE_CHR_INCR
:
19438 SET_NAME (rule
, rule_buf
[rule_pos
]);
19439 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19442 case RULE_OP_MANGLE_CHR_DECR
:
19443 SET_NAME (rule
, rule_buf
[rule_pos
]);
19444 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19447 case RULE_OP_MANGLE_REPLACE_NP1
:
19448 SET_NAME (rule
, rule_buf
[rule_pos
]);
19449 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19452 case RULE_OP_MANGLE_REPLACE_NM1
:
19453 SET_NAME (rule
, rule_buf
[rule_pos
]);
19454 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19457 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19458 SET_NAME (rule
, rule_buf
[rule_pos
]);
19459 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19462 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19463 SET_NAME (rule
, rule_buf
[rule_pos
]);
19464 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19467 case RULE_OP_MANGLE_TITLE
:
19468 SET_NAME (rule
, rule_buf
[rule_pos
]);
19477 if (rule_pos
< rule_len
) return (-1);
19482 int kernel_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], kernel_rule_t
*rule
)
19486 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19490 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19494 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19498 case RULE_OP_MANGLE_NOOP
:
19499 rule_buf
[rule_pos
] = rule_cmd
;
19502 case RULE_OP_MANGLE_LREST
:
19503 rule_buf
[rule_pos
] = rule_cmd
;
19506 case RULE_OP_MANGLE_UREST
:
19507 rule_buf
[rule_pos
] = rule_cmd
;
19510 case RULE_OP_MANGLE_LREST_UFIRST
:
19511 rule_buf
[rule_pos
] = rule_cmd
;
19514 case RULE_OP_MANGLE_UREST_LFIRST
:
19515 rule_buf
[rule_pos
] = rule_cmd
;
19518 case RULE_OP_MANGLE_TREST
:
19519 rule_buf
[rule_pos
] = rule_cmd
;
19522 case RULE_OP_MANGLE_TOGGLE_AT
:
19523 rule_buf
[rule_pos
] = rule_cmd
;
19524 GET_P0_CONV (rule
);
19527 case RULE_OP_MANGLE_REVERSE
:
19528 rule_buf
[rule_pos
] = rule_cmd
;
19531 case RULE_OP_MANGLE_DUPEWORD
:
19532 rule_buf
[rule_pos
] = rule_cmd
;
19535 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19536 rule_buf
[rule_pos
] = rule_cmd
;
19537 GET_P0_CONV (rule
);
19540 case RULE_OP_MANGLE_REFLECT
:
19541 rule_buf
[rule_pos
] = rule_cmd
;
19544 case RULE_OP_MANGLE_ROTATE_LEFT
:
19545 rule_buf
[rule_pos
] = rule_cmd
;
19548 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19549 rule_buf
[rule_pos
] = rule_cmd
;
19552 case RULE_OP_MANGLE_APPEND
:
19553 rule_buf
[rule_pos
] = rule_cmd
;
19557 case RULE_OP_MANGLE_PREPEND
:
19558 rule_buf
[rule_pos
] = rule_cmd
;
19562 case RULE_OP_MANGLE_DELETE_FIRST
:
19563 rule_buf
[rule_pos
] = rule_cmd
;
19566 case RULE_OP_MANGLE_DELETE_LAST
:
19567 rule_buf
[rule_pos
] = rule_cmd
;
19570 case RULE_OP_MANGLE_DELETE_AT
:
19571 rule_buf
[rule_pos
] = rule_cmd
;
19572 GET_P0_CONV (rule
);
19575 case RULE_OP_MANGLE_EXTRACT
:
19576 rule_buf
[rule_pos
] = rule_cmd
;
19577 GET_P0_CONV (rule
);
19578 GET_P1_CONV (rule
);
19581 case RULE_OP_MANGLE_OMIT
:
19582 rule_buf
[rule_pos
] = rule_cmd
;
19583 GET_P0_CONV (rule
);
19584 GET_P1_CONV (rule
);
19587 case RULE_OP_MANGLE_INSERT
:
19588 rule_buf
[rule_pos
] = rule_cmd
;
19589 GET_P0_CONV (rule
);
19593 case RULE_OP_MANGLE_OVERSTRIKE
:
19594 rule_buf
[rule_pos
] = rule_cmd
;
19595 GET_P0_CONV (rule
);
19599 case RULE_OP_MANGLE_TRUNCATE_AT
:
19600 rule_buf
[rule_pos
] = rule_cmd
;
19601 GET_P0_CONV (rule
);
19604 case RULE_OP_MANGLE_REPLACE
:
19605 rule_buf
[rule_pos
] = rule_cmd
;
19610 case RULE_OP_MANGLE_PURGECHAR
:
19614 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19618 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19619 rule_buf
[rule_pos
] = rule_cmd
;
19620 GET_P0_CONV (rule
);
19623 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19624 rule_buf
[rule_pos
] = rule_cmd
;
19625 GET_P0_CONV (rule
);
19628 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19629 rule_buf
[rule_pos
] = rule_cmd
;
19632 case RULE_OP_MANGLE_SWITCH_FIRST
:
19633 rule_buf
[rule_pos
] = rule_cmd
;
19636 case RULE_OP_MANGLE_SWITCH_LAST
:
19637 rule_buf
[rule_pos
] = rule_cmd
;
19640 case RULE_OP_MANGLE_SWITCH_AT
:
19641 rule_buf
[rule_pos
] = rule_cmd
;
19642 GET_P0_CONV (rule
);
19643 GET_P1_CONV (rule
);
19646 case RULE_OP_MANGLE_CHR_SHIFTL
:
19647 rule_buf
[rule_pos
] = rule_cmd
;
19648 GET_P0_CONV (rule
);
19651 case RULE_OP_MANGLE_CHR_SHIFTR
:
19652 rule_buf
[rule_pos
] = rule_cmd
;
19653 GET_P0_CONV (rule
);
19656 case RULE_OP_MANGLE_CHR_INCR
:
19657 rule_buf
[rule_pos
] = rule_cmd
;
19658 GET_P0_CONV (rule
);
19661 case RULE_OP_MANGLE_CHR_DECR
:
19662 rule_buf
[rule_pos
] = rule_cmd
;
19663 GET_P0_CONV (rule
);
19666 case RULE_OP_MANGLE_REPLACE_NP1
:
19667 rule_buf
[rule_pos
] = rule_cmd
;
19668 GET_P0_CONV (rule
);
19671 case RULE_OP_MANGLE_REPLACE_NM1
:
19672 rule_buf
[rule_pos
] = rule_cmd
;
19673 GET_P0_CONV (rule
);
19676 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19677 rule_buf
[rule_pos
] = rule_cmd
;
19678 GET_P0_CONV (rule
);
19681 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19682 rule_buf
[rule_pos
] = rule_cmd
;
19683 GET_P0_CONV (rule
);
19686 case RULE_OP_MANGLE_TITLE
:
19687 rule_buf
[rule_pos
] = rule_cmd
;
19691 return rule_pos
- 1;
19709 * CPU rules : this is from hashcat sources, cpu based rules
19712 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19713 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19715 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19716 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19717 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19719 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19720 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19721 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19723 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19727 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19732 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19736 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19741 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19745 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19750 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19755 for (l
= 0; l
< arr_len
; l
++)
19757 r
= arr_len
- 1 - l
;
19761 MANGLE_SWITCH (arr
, l
, r
);
19767 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19769 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19771 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19773 return (arr_len
* 2);
19776 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19778 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19780 int orig_len
= arr_len
;
19784 for (i
= 0; i
< times
; i
++)
19786 memcpy (&arr
[arr_len
], arr
, orig_len
);
19788 arr_len
+= orig_len
;
19794 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19796 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19798 mangle_double (arr
, arr_len
);
19800 mangle_reverse (arr
+ arr_len
, arr_len
);
19802 return (arr_len
* 2);
19805 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
19810 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
19812 MANGLE_SWITCH (arr
, l
, r
);
19818 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
19823 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
19825 MANGLE_SWITCH (arr
, l
, r
);
19831 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19833 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19837 return (arr_len
+ 1);
19840 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19842 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19846 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19848 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19853 return (arr_len
+ 1);
19856 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19858 if (upos
>= arr_len
) return (arr_len
);
19862 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
19864 arr
[arr_pos
] = arr
[arr_pos
+ 1];
19867 return (arr_len
- 1);
19870 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19872 if (upos
>= arr_len
) return (arr_len
);
19874 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
19878 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
19880 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
19886 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19888 if (upos
>= arr_len
) return (arr_len
);
19890 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
19894 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
19896 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
19899 return (arr_len
- ulen
);
19902 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19904 if (upos
>= arr_len
) return (arr_len
);
19906 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19910 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
19912 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19917 return (arr_len
+ 1);
19920 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
)
19922 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
19924 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
19926 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
19928 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
19930 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
19932 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
19934 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
19936 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
19938 return (arr_len
+ arr2_cpy
);
19941 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19943 if (upos
>= arr_len
) return (arr_len
);
19950 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19952 if (upos
>= arr_len
) return (arr_len
);
19954 memset (arr
+ upos
, 0, arr_len
- upos
);
19959 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
19963 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19965 if (arr
[arr_pos
] != oldc
) continue;
19967 arr
[arr_pos
] = newc
;
19973 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19979 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19981 if (arr
[arr_pos
] == c
) continue;
19983 arr
[ret_len
] = arr
[arr_pos
];
19991 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19993 if (ulen
> arr_len
) return (arr_len
);
19995 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19997 char cs
[100] = { 0 };
19999 memcpy (cs
, arr
, ulen
);
20003 for (i
= 0; i
< ulen
; i
++)
20007 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20013 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20015 if (ulen
> arr_len
) return (arr_len
);
20017 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20019 int upos
= arr_len
- ulen
;
20023 for (i
= 0; i
< ulen
; i
++)
20025 char c
= arr
[upos
+ i
];
20027 arr_len
= mangle_append (arr
, arr_len
, c
);
20033 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20035 if ( arr_len
== 0) return (arr_len
);
20036 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20038 char c
= arr
[upos
];
20042 for (i
= 0; i
< ulen
; i
++)
20044 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20050 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20052 if ( arr_len
== 0) return (arr_len
);
20053 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20057 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20059 int new_pos
= arr_pos
* 2;
20061 arr
[new_pos
] = arr
[arr_pos
];
20063 arr
[new_pos
+ 1] = arr
[arr_pos
];
20066 return (arr_len
* 2);
20069 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20071 if (upos
>= arr_len
) return (arr_len
);
20072 if (upos2
>= arr_len
) return (arr_len
);
20074 MANGLE_SWITCH (arr
, upos
, upos2
);
20079 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20081 MANGLE_SWITCH (arr
, upos
, upos2
);
20086 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20088 if (upos
>= arr_len
) return (arr_len
);
20095 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20097 if (upos
>= arr_len
) return (arr_len
);
20104 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20106 if (upos
>= arr_len
) return (arr_len
);
20113 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20115 if (upos
>= arr_len
) return (arr_len
);
20122 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20124 int upper_next
= 1;
20128 for (pos
= 0; pos
< arr_len
; pos
++)
20130 if (arr
[pos
] == ' ')
20141 MANGLE_UPPER_AT (arr
, pos
);
20145 MANGLE_LOWER_AT (arr
, pos
);
20152 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20154 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20160 for (j
= 0; j
< rp_gen_num
; j
++)
20167 switch ((char) get_random_num (0, 9))
20170 r
= get_random_num (0, sizeof (grp_op_nop
));
20171 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20175 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20176 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20177 p1
= get_random_num (0, sizeof (grp_pos
));
20178 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20182 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20183 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20184 p1
= get_random_num (1, 6);
20185 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20189 r
= get_random_num (0, sizeof (grp_op_chr
));
20190 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20191 p1
= get_random_num (0x20, 0x7e);
20192 rule_buf
[rule_pos
++] = (char) p1
;
20196 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20197 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20198 p1
= get_random_num (0x20, 0x7e);
20199 rule_buf
[rule_pos
++] = (char) p1
;
20200 p2
= get_random_num (0x20, 0x7e);
20202 p2
= get_random_num (0x20, 0x7e);
20203 rule_buf
[rule_pos
++] = (char) p2
;
20207 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20208 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20209 p1
= get_random_num (0, sizeof (grp_pos
));
20210 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20211 p2
= get_random_num (0x20, 0x7e);
20212 rule_buf
[rule_pos
++] = (char) p2
;
20216 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20217 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20218 p1
= get_random_num (0, sizeof (grp_pos
));
20219 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20220 p2
= get_random_num (0, sizeof (grp_pos
));
20222 p2
= get_random_num (0, sizeof (grp_pos
));
20223 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20227 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20228 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
20229 p1
= get_random_num (0, sizeof (grp_pos
));
20230 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20231 p2
= get_random_num (1, sizeof (grp_pos
));
20233 p2
= get_random_num (1, sizeof (grp_pos
));
20234 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20238 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
20239 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
20240 p1
= get_random_num (0, sizeof (grp_pos
));
20241 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20242 p2
= get_random_num (1, sizeof (grp_pos
));
20243 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20244 p3
= get_random_num (0, sizeof (grp_pos
));
20245 rule_buf
[rule_pos
++] = grp_pos
[p3
];
20253 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
20255 char mem
[BLOCK_SIZE
] = { 0 };
20257 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
20259 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
20261 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20263 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
20265 int out_len
= in_len
;
20266 int mem_len
= in_len
;
20268 memcpy (out
, in
, out_len
);
20272 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
20277 switch (rule
[rule_pos
])
20282 case RULE_OP_MANGLE_NOOP
:
20285 case RULE_OP_MANGLE_LREST
:
20286 out_len
= mangle_lrest (out
, out_len
);
20289 case RULE_OP_MANGLE_UREST
:
20290 out_len
= mangle_urest (out
, out_len
);
20293 case RULE_OP_MANGLE_LREST_UFIRST
:
20294 out_len
= mangle_lrest (out
, out_len
);
20295 if (out_len
) MANGLE_UPPER_AT (out
, 0);
20298 case RULE_OP_MANGLE_UREST_LFIRST
:
20299 out_len
= mangle_urest (out
, out_len
);
20300 if (out_len
) MANGLE_LOWER_AT (out
, 0);
20303 case RULE_OP_MANGLE_TREST
:
20304 out_len
= mangle_trest (out
, out_len
);
20307 case RULE_OP_MANGLE_TOGGLE_AT
:
20308 NEXT_RULEPOS (rule_pos
);
20309 NEXT_RPTOI (rule
, rule_pos
, upos
);
20310 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
20313 case RULE_OP_MANGLE_REVERSE
:
20314 out_len
= mangle_reverse (out
, out_len
);
20317 case RULE_OP_MANGLE_DUPEWORD
:
20318 out_len
= mangle_double (out
, out_len
);
20321 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20322 NEXT_RULEPOS (rule_pos
);
20323 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20324 out_len
= mangle_double_times (out
, out_len
, ulen
);
20327 case RULE_OP_MANGLE_REFLECT
:
20328 out_len
= mangle_reflect (out
, out_len
);
20331 case RULE_OP_MANGLE_ROTATE_LEFT
:
20332 mangle_rotate_left (out
, out_len
);
20335 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20336 mangle_rotate_right (out
, out_len
);
20339 case RULE_OP_MANGLE_APPEND
:
20340 NEXT_RULEPOS (rule_pos
);
20341 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
20344 case RULE_OP_MANGLE_PREPEND
:
20345 NEXT_RULEPOS (rule_pos
);
20346 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
20349 case RULE_OP_MANGLE_DELETE_FIRST
:
20350 out_len
= mangle_delete_at (out
, out_len
, 0);
20353 case RULE_OP_MANGLE_DELETE_LAST
:
20354 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
20357 case RULE_OP_MANGLE_DELETE_AT
:
20358 NEXT_RULEPOS (rule_pos
);
20359 NEXT_RPTOI (rule
, rule_pos
, upos
);
20360 out_len
= mangle_delete_at (out
, out_len
, upos
);
20363 case RULE_OP_MANGLE_EXTRACT
:
20364 NEXT_RULEPOS (rule_pos
);
20365 NEXT_RPTOI (rule
, rule_pos
, upos
);
20366 NEXT_RULEPOS (rule_pos
);
20367 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20368 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
20371 case RULE_OP_MANGLE_OMIT
:
20372 NEXT_RULEPOS (rule_pos
);
20373 NEXT_RPTOI (rule
, rule_pos
, upos
);
20374 NEXT_RULEPOS (rule_pos
);
20375 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20376 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
20379 case RULE_OP_MANGLE_INSERT
:
20380 NEXT_RULEPOS (rule_pos
);
20381 NEXT_RPTOI (rule
, rule_pos
, upos
);
20382 NEXT_RULEPOS (rule_pos
);
20383 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
20386 case RULE_OP_MANGLE_OVERSTRIKE
:
20387 NEXT_RULEPOS (rule_pos
);
20388 NEXT_RPTOI (rule
, rule_pos
, upos
);
20389 NEXT_RULEPOS (rule_pos
);
20390 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20393 case RULE_OP_MANGLE_TRUNCATE_AT
:
20394 NEXT_RULEPOS (rule_pos
);
20395 NEXT_RPTOI (rule
, rule_pos
, upos
);
20396 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20399 case RULE_OP_MANGLE_REPLACE
:
20400 NEXT_RULEPOS (rule_pos
);
20401 NEXT_RULEPOS (rule_pos
);
20402 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20405 case RULE_OP_MANGLE_PURGECHAR
:
20406 NEXT_RULEPOS (rule_pos
);
20407 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20410 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20414 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20415 NEXT_RULEPOS (rule_pos
);
20416 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20417 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20420 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20421 NEXT_RULEPOS (rule_pos
);
20422 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20423 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20426 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20427 out_len
= mangle_dupechar (out
, out_len
);
20430 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20431 NEXT_RULEPOS (rule_pos
);
20432 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20433 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20436 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20437 NEXT_RULEPOS (rule_pos
);
20438 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20439 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20442 case RULE_OP_MANGLE_SWITCH_FIRST
:
20443 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20446 case RULE_OP_MANGLE_SWITCH_LAST
:
20447 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20450 case RULE_OP_MANGLE_SWITCH_AT
:
20451 NEXT_RULEPOS (rule_pos
);
20452 NEXT_RPTOI (rule
, rule_pos
, upos
);
20453 NEXT_RULEPOS (rule_pos
);
20454 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20455 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20458 case RULE_OP_MANGLE_CHR_SHIFTL
:
20459 NEXT_RULEPOS (rule_pos
);
20460 NEXT_RPTOI (rule
, rule_pos
, upos
);
20461 mangle_chr_shiftl (out
, out_len
, upos
);
20464 case RULE_OP_MANGLE_CHR_SHIFTR
:
20465 NEXT_RULEPOS (rule_pos
);
20466 NEXT_RPTOI (rule
, rule_pos
, upos
);
20467 mangle_chr_shiftr (out
, out_len
, upos
);
20470 case RULE_OP_MANGLE_CHR_INCR
:
20471 NEXT_RULEPOS (rule_pos
);
20472 NEXT_RPTOI (rule
, rule_pos
, upos
);
20473 mangle_chr_incr (out
, out_len
, upos
);
20476 case RULE_OP_MANGLE_CHR_DECR
:
20477 NEXT_RULEPOS (rule_pos
);
20478 NEXT_RPTOI (rule
, rule_pos
, upos
);
20479 mangle_chr_decr (out
, out_len
, upos
);
20482 case RULE_OP_MANGLE_REPLACE_NP1
:
20483 NEXT_RULEPOS (rule_pos
);
20484 NEXT_RPTOI (rule
, rule_pos
, upos
);
20485 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20488 case RULE_OP_MANGLE_REPLACE_NM1
:
20489 NEXT_RULEPOS (rule_pos
);
20490 NEXT_RPTOI (rule
, rule_pos
, upos
);
20491 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20494 case RULE_OP_MANGLE_TITLE
:
20495 out_len
= mangle_title (out
, out_len
);
20498 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20499 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20500 NEXT_RULEPOS (rule_pos
);
20501 NEXT_RPTOI (rule
, rule_pos
, upos
);
20502 NEXT_RULEPOS (rule_pos
);
20503 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20504 NEXT_RULEPOS (rule_pos
);
20505 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20506 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20509 case RULE_OP_MANGLE_APPEND_MEMORY
:
20510 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20511 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20512 memcpy (out
+ out_len
, mem
, mem_len
);
20513 out_len
+= mem_len
;
20516 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20517 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20518 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20519 memcpy (mem
+ mem_len
, out
, out_len
);
20520 out_len
+= mem_len
;
20521 memcpy (out
, mem
, out_len
);
20524 case RULE_OP_MEMORIZE_WORD
:
20525 memcpy (mem
, out
, out_len
);
20529 case RULE_OP_REJECT_LESS
:
20530 NEXT_RULEPOS (rule_pos
);
20531 NEXT_RPTOI (rule
, rule_pos
, upos
);
20532 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20535 case RULE_OP_REJECT_GREATER
:
20536 NEXT_RULEPOS (rule_pos
);
20537 NEXT_RPTOI (rule
, rule_pos
, upos
);
20538 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20541 case RULE_OP_REJECT_CONTAIN
:
20542 NEXT_RULEPOS (rule_pos
);
20543 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20546 case RULE_OP_REJECT_NOT_CONTAIN
:
20547 NEXT_RULEPOS (rule_pos
);
20548 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20551 case RULE_OP_REJECT_EQUAL_FIRST
:
20552 NEXT_RULEPOS (rule_pos
);
20553 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20556 case RULE_OP_REJECT_EQUAL_LAST
:
20557 NEXT_RULEPOS (rule_pos
);
20558 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20561 case RULE_OP_REJECT_EQUAL_AT
:
20562 NEXT_RULEPOS (rule_pos
);
20563 NEXT_RPTOI (rule
, rule_pos
, upos
);
20564 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20565 NEXT_RULEPOS (rule_pos
);
20566 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20569 case RULE_OP_REJECT_CONTAINS
:
20570 NEXT_RULEPOS (rule_pos
);
20571 NEXT_RPTOI (rule
, rule_pos
, upos
);
20572 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20573 NEXT_RULEPOS (rule_pos
);
20574 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20575 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20578 case RULE_OP_REJECT_MEMORY
:
20579 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20583 return (RULE_RC_SYNTAX_ERROR
);
20588 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);