2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
19 u32
rotl32 (const u32 a
, const u32 n
)
21 return ((a
<< n
) | (a
>> (32 - n
)));
24 u32
rotr32 (const u32 a
, const u32 n
)
26 return ((a
>> n
) | (a
<< (32 - n
)));
29 u64
rotl64 (const u64 a
, const u64 n
)
31 return ((a
<< n
) | (a
>> (64 - n
)));
34 u64
rotr64 (const u64 a
, const u64 n
)
36 return ((a
>> n
) | (a
<< (64 - n
)));
39 u32
byte_swap_32 (const u32 n
)
41 return (n
& 0xff000000) >> 24
42 | (n
& 0x00ff0000) >> 8
43 | (n
& 0x0000ff00) << 8
44 | (n
& 0x000000ff) << 24;
47 u64
byte_swap_64 (const u64 n
)
49 return (n
& 0xff00000000000000ULL
) >> 56
50 | (n
& 0x00ff000000000000ULL
) >> 40
51 | (n
& 0x0000ff0000000000ULL
) >> 24
52 | (n
& 0x000000ff00000000ULL
) >> 8
53 | (n
& 0x00000000ff000000ULL
) << 8
54 | (n
& 0x0000000000ff0000ULL
) << 24
55 | (n
& 0x000000000000ff00ULL
) << 40
56 | (n
& 0x00000000000000ffULL
) << 56;
60 * ciphers for use on cpu
67 * hashes for use on cpu
71 #include "cpu-sha256.c"
79 void log_final (FILE *fp
, const char *fmt
, va_list ap
)
85 for (int i
= 0; i
< last_len
; i
++)
95 int max_len
= (int) sizeof (s
);
97 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
99 if (len
> max_len
) len
= max_len
;
101 fwrite (s
, len
, 1, fp
);
108 void log_out_nn (FILE *fp
, const char *fmt
, ...)
110 if (SUPPRESS_OUTPUT
) return;
116 log_final (fp
, fmt
, ap
);
121 void log_info_nn (const char *fmt
, ...)
123 if (SUPPRESS_OUTPUT
) return;
129 log_final (stdout
, fmt
, ap
);
134 void log_error_nn (const char *fmt
, ...)
136 if (SUPPRESS_OUTPUT
) return;
142 log_final (stderr
, fmt
, ap
);
147 void log_out (FILE *fp
, const char *fmt
, ...)
149 if (SUPPRESS_OUTPUT
) return;
155 log_final (fp
, fmt
, ap
);
164 void log_info (const char *fmt
, ...)
166 if (SUPPRESS_OUTPUT
) return;
172 log_final (stdout
, fmt
, ap
);
176 fputc ('\n', stdout
);
181 void log_error (const char *fmt
, ...)
183 if (SUPPRESS_OUTPUT
) return;
185 fputc ('\n', stderr
);
186 fputc ('\n', stderr
);
192 log_final (stderr
, fmt
, ap
);
196 fputc ('\n', stderr
);
197 fputc ('\n', stderr
);
206 u8
int_to_base32 (const u8 c
)
208 static const u8 tbl
[0x20] =
210 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
211 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
217 u8
base32_to_int (const u8 c
)
219 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
220 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
225 u8
int_to_itoa32 (const u8 c
)
227 static const u8 tbl
[0x20] =
229 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
230 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
236 u8
itoa32_to_int (const u8 c
)
238 if ((c
>= '0') && (c
<= '9')) return c
- '0';
239 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
244 u8
int_to_itoa64 (const u8 c
)
246 static const u8 tbl
[0x40] =
248 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
249 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
250 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
251 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
257 u8
itoa64_to_int (const u8 c
)
259 static const u8 tbl
[0x100] =
261 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
262 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
263 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
264 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
265 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
266 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
267 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
268 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
269 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
270 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
271 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
272 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
273 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
274 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
275 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
276 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
282 u8
int_to_base64 (const u8 c
)
284 static const u8 tbl
[0x40] =
286 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
287 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
288 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
289 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
295 u8
base64_to_int (const u8 c
)
297 static const u8 tbl
[0x100] =
299 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
300 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
301 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
302 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
303 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
304 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
305 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
306 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
307 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
308 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
309 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
310 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
311 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
312 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
313 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
314 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
320 u8
int_to_bf64 (const u8 c
)
322 static const u8 tbl
[0x40] =
324 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
325 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
326 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
327 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
333 u8
bf64_to_int (const u8 c
)
335 static const u8 tbl
[0x100] =
337 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
338 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
339 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
340 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
341 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
342 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
343 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
344 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
345 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
346 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
347 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
348 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
349 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
350 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
351 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
352 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
358 u8
int_to_lotus64 (const u8 c
)
360 if (c
< 10) return '0' + c
;
361 else if (c
< 36) return 'A' + c
- 10;
362 else if (c
< 62) return 'a' + c
- 36;
363 else if (c
== 62) return '+';
364 else if (c
== 63) return '/';
369 u8
lotus64_to_int (const u8 c
)
371 if ((c
>= '0') && (c
<= '9')) return c
- '0';
372 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
373 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
374 else if (c
== '+') return 62;
375 else if (c
== '/') return 63;
381 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
383 const u8
*in_ptr
= in_buf
;
385 u8
*out_ptr
= out_buf
;
387 for (int i
= 0; i
< in_len
; i
+= 8)
389 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
390 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
391 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
392 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
393 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
394 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
395 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
396 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
398 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
399 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
400 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
401 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
402 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
408 for (int i
= 0; i
< in_len
; i
++)
410 if (in_buf
[i
] != '=') continue;
415 int out_len
= (in_len
* 5) / 8;
420 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
422 const u8
*in_ptr
= in_buf
;
424 u8
*out_ptr
= out_buf
;
426 for (int i
= 0; i
< in_len
; i
+= 5)
428 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
429 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
430 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
431 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
432 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
433 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
434 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
435 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
437 out_ptr
[0] = out_val0
& 0x7f;
438 out_ptr
[1] = out_val1
& 0x7f;
439 out_ptr
[2] = out_val2
& 0x7f;
440 out_ptr
[3] = out_val3
& 0x7f;
441 out_ptr
[4] = out_val4
& 0x7f;
442 out_ptr
[5] = out_val5
& 0x7f;
443 out_ptr
[6] = out_val6
& 0x7f;
444 out_ptr
[7] = out_val7
& 0x7f;
450 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
454 out_buf
[out_len
] = '=';
462 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
464 const u8
*in_ptr
= in_buf
;
466 u8
*out_ptr
= out_buf
;
468 for (int i
= 0; i
< in_len
; i
+= 4)
470 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
471 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
472 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
473 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
475 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
476 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
477 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
483 for (int i
= 0; i
< in_len
; i
++)
485 if (in_buf
[i
] != '=') continue;
490 int out_len
= (in_len
* 6) / 8;
495 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
497 const u8
*in_ptr
= in_buf
;
499 u8
*out_ptr
= out_buf
;
501 for (int i
= 0; i
< in_len
; i
+= 3)
503 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
504 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
505 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
506 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
508 out_ptr
[0] = out_val0
& 0x7f;
509 out_ptr
[1] = out_val1
& 0x7f;
510 out_ptr
[2] = out_val2
& 0x7f;
511 out_ptr
[3] = out_val3
& 0x7f;
517 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
521 out_buf
[out_len
] = '=';
529 int is_valid_hex_char (const u8 c
)
531 if ((c
>= '0') && (c
<= '9')) return 1;
532 if ((c
>= 'A') && (c
<= 'F')) return 1;
533 if ((c
>= 'a') && (c
<= 'f')) return 1;
538 u8
hex_convert (const u8 c
)
540 return (c
& 15) + (c
>> 6) * 9;
543 u8
hex_to_u8 (const u8 hex
[2])
547 v
|= (hex_convert (hex
[1]) << 0);
548 v
|= (hex_convert (hex
[0]) << 4);
553 u32
hex_to_u32 (const u8 hex
[8])
557 v
|= ((u32
) hex_convert (hex
[7])) << 0;
558 v
|= ((u32
) hex_convert (hex
[6])) << 4;
559 v
|= ((u32
) hex_convert (hex
[5])) << 8;
560 v
|= ((u32
) hex_convert (hex
[4])) << 12;
561 v
|= ((u32
) hex_convert (hex
[3])) << 16;
562 v
|= ((u32
) hex_convert (hex
[2])) << 20;
563 v
|= ((u32
) hex_convert (hex
[1])) << 24;
564 v
|= ((u32
) hex_convert (hex
[0])) << 28;
569 u64
hex_to_u64 (const u8 hex
[16])
573 v
|= ((u64
) hex_convert (hex
[15]) << 0);
574 v
|= ((u64
) hex_convert (hex
[14]) << 4);
575 v
|= ((u64
) hex_convert (hex
[13]) << 8);
576 v
|= ((u64
) hex_convert (hex
[12]) << 12);
577 v
|= ((u64
) hex_convert (hex
[11]) << 16);
578 v
|= ((u64
) hex_convert (hex
[10]) << 20);
579 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
580 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
581 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
582 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
583 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
584 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
585 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
586 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
587 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
588 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
593 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
595 hex
[0] = v
>> 28 & 15;
596 hex
[1] = v
>> 24 & 15;
597 hex
[2] = v
>> 20 & 15;
598 hex
[3] = v
>> 16 & 15;
599 hex
[4] = v
>> 12 & 15;
600 hex
[5] = v
>> 8 & 15;
601 hex
[6] = v
>> 4 & 15;
602 hex
[7] = v
>> 0 & 15;
606 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
607 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
608 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
609 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
610 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
611 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
612 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
613 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
620 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
624 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
633 for (int i
= 0; i
< 16; i
+= 4)
643 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
650 out
[i
+ 0] = _out
[0];
651 out
[i
+ 1] = _out
[1];
652 out
[i
+ 2] = _out
[2];
653 out
[i
+ 3] = _out
[3];
662 static void juniper_decrypt_hash (char *in
, char *out
)
666 u8 base64_buf
[100] = { 0 };
668 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
672 u32 juniper_iv
[4] = { 0 };
674 memcpy (juniper_iv
, base64_buf
, 12);
676 memcpy (out
, juniper_iv
, 12);
680 u32 juniper_key
[4] = { 0 };
682 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
683 juniper_key
[1] = byte_swap_32 (0x8df91059);
684 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
685 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
689 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
690 u32
*out_ptr
= (u32
*) (out
+ 12);
692 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
695 void phpass_decode (u8 digest
[16], u8 buf
[22])
699 l
= itoa64_to_int (buf
[ 0]) << 0;
700 l
|= itoa64_to_int (buf
[ 1]) << 6;
701 l
|= itoa64_to_int (buf
[ 2]) << 12;
702 l
|= itoa64_to_int (buf
[ 3]) << 18;
704 digest
[ 0] = (l
>> 0) & 0xff;
705 digest
[ 1] = (l
>> 8) & 0xff;
706 digest
[ 2] = (l
>> 16) & 0xff;
708 l
= itoa64_to_int (buf
[ 4]) << 0;
709 l
|= itoa64_to_int (buf
[ 5]) << 6;
710 l
|= itoa64_to_int (buf
[ 6]) << 12;
711 l
|= itoa64_to_int (buf
[ 7]) << 18;
713 digest
[ 3] = (l
>> 0) & 0xff;
714 digest
[ 4] = (l
>> 8) & 0xff;
715 digest
[ 5] = (l
>> 16) & 0xff;
717 l
= itoa64_to_int (buf
[ 8]) << 0;
718 l
|= itoa64_to_int (buf
[ 9]) << 6;
719 l
|= itoa64_to_int (buf
[10]) << 12;
720 l
|= itoa64_to_int (buf
[11]) << 18;
722 digest
[ 6] = (l
>> 0) & 0xff;
723 digest
[ 7] = (l
>> 8) & 0xff;
724 digest
[ 8] = (l
>> 16) & 0xff;
726 l
= itoa64_to_int (buf
[12]) << 0;
727 l
|= itoa64_to_int (buf
[13]) << 6;
728 l
|= itoa64_to_int (buf
[14]) << 12;
729 l
|= itoa64_to_int (buf
[15]) << 18;
731 digest
[ 9] = (l
>> 0) & 0xff;
732 digest
[10] = (l
>> 8) & 0xff;
733 digest
[11] = (l
>> 16) & 0xff;
735 l
= itoa64_to_int (buf
[16]) << 0;
736 l
|= itoa64_to_int (buf
[17]) << 6;
737 l
|= itoa64_to_int (buf
[18]) << 12;
738 l
|= itoa64_to_int (buf
[19]) << 18;
740 digest
[12] = (l
>> 0) & 0xff;
741 digest
[13] = (l
>> 8) & 0xff;
742 digest
[14] = (l
>> 16) & 0xff;
744 l
= itoa64_to_int (buf
[20]) << 0;
745 l
|= itoa64_to_int (buf
[21]) << 6;
747 digest
[15] = (l
>> 0) & 0xff;
750 void phpass_encode (u8 digest
[16], u8 buf
[22])
754 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
756 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
757 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
758 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
759 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
761 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
763 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
764 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
765 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
766 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
768 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
770 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
771 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
772 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
773 buf
[11] = int_to_itoa64 (l
& 0x3f);
775 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
777 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
778 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
779 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
780 buf
[15] = int_to_itoa64 (l
& 0x3f);
782 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
784 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
785 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
786 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
787 buf
[19] = int_to_itoa64 (l
& 0x3f);
789 l
= (digest
[15] << 0);
791 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
792 buf
[21] = int_to_itoa64 (l
& 0x3f);
795 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
799 l
= itoa64_to_int (buf
[ 0]) << 0;
800 l
|= itoa64_to_int (buf
[ 1]) << 6;
801 l
|= itoa64_to_int (buf
[ 2]) << 12;
802 l
|= itoa64_to_int (buf
[ 3]) << 18;
804 digest
[ 0] = (l
>> 16) & 0xff;
805 digest
[ 6] = (l
>> 8) & 0xff;
806 digest
[12] = (l
>> 0) & 0xff;
808 l
= itoa64_to_int (buf
[ 4]) << 0;
809 l
|= itoa64_to_int (buf
[ 5]) << 6;
810 l
|= itoa64_to_int (buf
[ 6]) << 12;
811 l
|= itoa64_to_int (buf
[ 7]) << 18;
813 digest
[ 1] = (l
>> 16) & 0xff;
814 digest
[ 7] = (l
>> 8) & 0xff;
815 digest
[13] = (l
>> 0) & 0xff;
817 l
= itoa64_to_int (buf
[ 8]) << 0;
818 l
|= itoa64_to_int (buf
[ 9]) << 6;
819 l
|= itoa64_to_int (buf
[10]) << 12;
820 l
|= itoa64_to_int (buf
[11]) << 18;
822 digest
[ 2] = (l
>> 16) & 0xff;
823 digest
[ 8] = (l
>> 8) & 0xff;
824 digest
[14] = (l
>> 0) & 0xff;
826 l
= itoa64_to_int (buf
[12]) << 0;
827 l
|= itoa64_to_int (buf
[13]) << 6;
828 l
|= itoa64_to_int (buf
[14]) << 12;
829 l
|= itoa64_to_int (buf
[15]) << 18;
831 digest
[ 3] = (l
>> 16) & 0xff;
832 digest
[ 9] = (l
>> 8) & 0xff;
833 digest
[15] = (l
>> 0) & 0xff;
835 l
= itoa64_to_int (buf
[16]) << 0;
836 l
|= itoa64_to_int (buf
[17]) << 6;
837 l
|= itoa64_to_int (buf
[18]) << 12;
838 l
|= itoa64_to_int (buf
[19]) << 18;
840 digest
[ 4] = (l
>> 16) & 0xff;
841 digest
[10] = (l
>> 8) & 0xff;
842 digest
[ 5] = (l
>> 0) & 0xff;
844 l
= itoa64_to_int (buf
[20]) << 0;
845 l
|= itoa64_to_int (buf
[21]) << 6;
847 digest
[11] = (l
>> 0) & 0xff;
850 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
854 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
856 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
857 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
858 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
859 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
861 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
863 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
864 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
865 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
866 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
868 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
870 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
871 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
872 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
873 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
875 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
877 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
879 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
880 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
882 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
884 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
886 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
887 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
889 l
= (digest
[11] << 0);
891 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
895 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
899 l
= itoa64_to_int (buf
[ 0]) << 0;
900 l
|= itoa64_to_int (buf
[ 1]) << 6;
901 l
|= itoa64_to_int (buf
[ 2]) << 12;
902 l
|= itoa64_to_int (buf
[ 3]) << 18;
904 digest
[ 0] = (l
>> 16) & 0xff;
905 digest
[21] = (l
>> 8) & 0xff;
906 digest
[42] = (l
>> 0) & 0xff;
908 l
= itoa64_to_int (buf
[ 4]) << 0;
909 l
|= itoa64_to_int (buf
[ 5]) << 6;
910 l
|= itoa64_to_int (buf
[ 6]) << 12;
911 l
|= itoa64_to_int (buf
[ 7]) << 18;
913 digest
[22] = (l
>> 16) & 0xff;
914 digest
[43] = (l
>> 8) & 0xff;
915 digest
[ 1] = (l
>> 0) & 0xff;
917 l
= itoa64_to_int (buf
[ 8]) << 0;
918 l
|= itoa64_to_int (buf
[ 9]) << 6;
919 l
|= itoa64_to_int (buf
[10]) << 12;
920 l
|= itoa64_to_int (buf
[11]) << 18;
922 digest
[44] = (l
>> 16) & 0xff;
923 digest
[ 2] = (l
>> 8) & 0xff;
924 digest
[23] = (l
>> 0) & 0xff;
926 l
= itoa64_to_int (buf
[12]) << 0;
927 l
|= itoa64_to_int (buf
[13]) << 6;
928 l
|= itoa64_to_int (buf
[14]) << 12;
929 l
|= itoa64_to_int (buf
[15]) << 18;
931 digest
[ 3] = (l
>> 16) & 0xff;
932 digest
[24] = (l
>> 8) & 0xff;
933 digest
[45] = (l
>> 0) & 0xff;
935 l
= itoa64_to_int (buf
[16]) << 0;
936 l
|= itoa64_to_int (buf
[17]) << 6;
937 l
|= itoa64_to_int (buf
[18]) << 12;
938 l
|= itoa64_to_int (buf
[19]) << 18;
940 digest
[25] = (l
>> 16) & 0xff;
941 digest
[46] = (l
>> 8) & 0xff;
942 digest
[ 4] = (l
>> 0) & 0xff;
944 l
= itoa64_to_int (buf
[20]) << 0;
945 l
|= itoa64_to_int (buf
[21]) << 6;
946 l
|= itoa64_to_int (buf
[22]) << 12;
947 l
|= itoa64_to_int (buf
[23]) << 18;
949 digest
[47] = (l
>> 16) & 0xff;
950 digest
[ 5] = (l
>> 8) & 0xff;
951 digest
[26] = (l
>> 0) & 0xff;
953 l
= itoa64_to_int (buf
[24]) << 0;
954 l
|= itoa64_to_int (buf
[25]) << 6;
955 l
|= itoa64_to_int (buf
[26]) << 12;
956 l
|= itoa64_to_int (buf
[27]) << 18;
958 digest
[ 6] = (l
>> 16) & 0xff;
959 digest
[27] = (l
>> 8) & 0xff;
960 digest
[48] = (l
>> 0) & 0xff;
962 l
= itoa64_to_int (buf
[28]) << 0;
963 l
|= itoa64_to_int (buf
[29]) << 6;
964 l
|= itoa64_to_int (buf
[30]) << 12;
965 l
|= itoa64_to_int (buf
[31]) << 18;
967 digest
[28] = (l
>> 16) & 0xff;
968 digest
[49] = (l
>> 8) & 0xff;
969 digest
[ 7] = (l
>> 0) & 0xff;
971 l
= itoa64_to_int (buf
[32]) << 0;
972 l
|= itoa64_to_int (buf
[33]) << 6;
973 l
|= itoa64_to_int (buf
[34]) << 12;
974 l
|= itoa64_to_int (buf
[35]) << 18;
976 digest
[50] = (l
>> 16) & 0xff;
977 digest
[ 8] = (l
>> 8) & 0xff;
978 digest
[29] = (l
>> 0) & 0xff;
980 l
= itoa64_to_int (buf
[36]) << 0;
981 l
|= itoa64_to_int (buf
[37]) << 6;
982 l
|= itoa64_to_int (buf
[38]) << 12;
983 l
|= itoa64_to_int (buf
[39]) << 18;
985 digest
[ 9] = (l
>> 16) & 0xff;
986 digest
[30] = (l
>> 8) & 0xff;
987 digest
[51] = (l
>> 0) & 0xff;
989 l
= itoa64_to_int (buf
[40]) << 0;
990 l
|= itoa64_to_int (buf
[41]) << 6;
991 l
|= itoa64_to_int (buf
[42]) << 12;
992 l
|= itoa64_to_int (buf
[43]) << 18;
994 digest
[31] = (l
>> 16) & 0xff;
995 digest
[52] = (l
>> 8) & 0xff;
996 digest
[10] = (l
>> 0) & 0xff;
998 l
= itoa64_to_int (buf
[44]) << 0;
999 l
|= itoa64_to_int (buf
[45]) << 6;
1000 l
|= itoa64_to_int (buf
[46]) << 12;
1001 l
|= itoa64_to_int (buf
[47]) << 18;
1003 digest
[53] = (l
>> 16) & 0xff;
1004 digest
[11] = (l
>> 8) & 0xff;
1005 digest
[32] = (l
>> 0) & 0xff;
1007 l
= itoa64_to_int (buf
[48]) << 0;
1008 l
|= itoa64_to_int (buf
[49]) << 6;
1009 l
|= itoa64_to_int (buf
[50]) << 12;
1010 l
|= itoa64_to_int (buf
[51]) << 18;
1012 digest
[12] = (l
>> 16) & 0xff;
1013 digest
[33] = (l
>> 8) & 0xff;
1014 digest
[54] = (l
>> 0) & 0xff;
1016 l
= itoa64_to_int (buf
[52]) << 0;
1017 l
|= itoa64_to_int (buf
[53]) << 6;
1018 l
|= itoa64_to_int (buf
[54]) << 12;
1019 l
|= itoa64_to_int (buf
[55]) << 18;
1021 digest
[34] = (l
>> 16) & 0xff;
1022 digest
[55] = (l
>> 8) & 0xff;
1023 digest
[13] = (l
>> 0) & 0xff;
1025 l
= itoa64_to_int (buf
[56]) << 0;
1026 l
|= itoa64_to_int (buf
[57]) << 6;
1027 l
|= itoa64_to_int (buf
[58]) << 12;
1028 l
|= itoa64_to_int (buf
[59]) << 18;
1030 digest
[56] = (l
>> 16) & 0xff;
1031 digest
[14] = (l
>> 8) & 0xff;
1032 digest
[35] = (l
>> 0) & 0xff;
1034 l
= itoa64_to_int (buf
[60]) << 0;
1035 l
|= itoa64_to_int (buf
[61]) << 6;
1036 l
|= itoa64_to_int (buf
[62]) << 12;
1037 l
|= itoa64_to_int (buf
[63]) << 18;
1039 digest
[15] = (l
>> 16) & 0xff;
1040 digest
[36] = (l
>> 8) & 0xff;
1041 digest
[57] = (l
>> 0) & 0xff;
1043 l
= itoa64_to_int (buf
[64]) << 0;
1044 l
|= itoa64_to_int (buf
[65]) << 6;
1045 l
|= itoa64_to_int (buf
[66]) << 12;
1046 l
|= itoa64_to_int (buf
[67]) << 18;
1048 digest
[37] = (l
>> 16) & 0xff;
1049 digest
[58] = (l
>> 8) & 0xff;
1050 digest
[16] = (l
>> 0) & 0xff;
1052 l
= itoa64_to_int (buf
[68]) << 0;
1053 l
|= itoa64_to_int (buf
[69]) << 6;
1054 l
|= itoa64_to_int (buf
[70]) << 12;
1055 l
|= itoa64_to_int (buf
[71]) << 18;
1057 digest
[59] = (l
>> 16) & 0xff;
1058 digest
[17] = (l
>> 8) & 0xff;
1059 digest
[38] = (l
>> 0) & 0xff;
1061 l
= itoa64_to_int (buf
[72]) << 0;
1062 l
|= itoa64_to_int (buf
[73]) << 6;
1063 l
|= itoa64_to_int (buf
[74]) << 12;
1064 l
|= itoa64_to_int (buf
[75]) << 18;
1066 digest
[18] = (l
>> 16) & 0xff;
1067 digest
[39] = (l
>> 8) & 0xff;
1068 digest
[60] = (l
>> 0) & 0xff;
1070 l
= itoa64_to_int (buf
[76]) << 0;
1071 l
|= itoa64_to_int (buf
[77]) << 6;
1072 l
|= itoa64_to_int (buf
[78]) << 12;
1073 l
|= itoa64_to_int (buf
[79]) << 18;
1075 digest
[40] = (l
>> 16) & 0xff;
1076 digest
[61] = (l
>> 8) & 0xff;
1077 digest
[19] = (l
>> 0) & 0xff;
1079 l
= itoa64_to_int (buf
[80]) << 0;
1080 l
|= itoa64_to_int (buf
[81]) << 6;
1081 l
|= itoa64_to_int (buf
[82]) << 12;
1082 l
|= itoa64_to_int (buf
[83]) << 18;
1084 digest
[62] = (l
>> 16) & 0xff;
1085 digest
[20] = (l
>> 8) & 0xff;
1086 digest
[41] = (l
>> 0) & 0xff;
1088 l
= itoa64_to_int (buf
[84]) << 0;
1089 l
|= itoa64_to_int (buf
[85]) << 6;
1091 digest
[63] = (l
>> 0) & 0xff;
1094 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1098 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1100 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1101 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1102 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1103 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1105 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1107 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1108 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1109 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1110 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1112 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1114 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1115 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1116 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1117 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1119 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1121 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1123 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1124 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1126 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1128 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1130 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1131 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1133 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1135 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1137 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1138 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1140 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1142 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1144 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1145 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1147 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1149 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1151 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1152 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1154 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1156 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1158 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1159 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1161 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1163 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1165 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1166 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1168 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1170 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1172 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1173 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1175 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1177 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1179 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1180 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1182 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1184 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1186 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1187 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1189 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1191 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1193 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1194 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1196 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1198 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1200 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1201 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1203 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1205 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1207 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1208 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1210 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1212 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1214 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1215 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1217 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1219 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1221 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1222 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1224 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1226 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1228 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1229 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1231 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1233 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1235 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1236 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1238 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1240 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1242 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1243 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1245 l
= 0 | 0 | (digest
[63] << 0);
1247 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1251 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1255 l
= itoa64_to_int (buf
[ 0]) << 0;
1256 l
|= itoa64_to_int (buf
[ 1]) << 6;
1257 l
|= itoa64_to_int (buf
[ 2]) << 12;
1258 l
|= itoa64_to_int (buf
[ 3]) << 18;
1260 digest
[ 2] = (l
>> 0) & 0xff;
1261 digest
[ 1] = (l
>> 8) & 0xff;
1262 digest
[ 0] = (l
>> 16) & 0xff;
1264 l
= itoa64_to_int (buf
[ 4]) << 0;
1265 l
|= itoa64_to_int (buf
[ 5]) << 6;
1266 l
|= itoa64_to_int (buf
[ 6]) << 12;
1267 l
|= itoa64_to_int (buf
[ 7]) << 18;
1269 digest
[ 5] = (l
>> 0) & 0xff;
1270 digest
[ 4] = (l
>> 8) & 0xff;
1271 digest
[ 3] = (l
>> 16) & 0xff;
1273 l
= itoa64_to_int (buf
[ 8]) << 0;
1274 l
|= itoa64_to_int (buf
[ 9]) << 6;
1275 l
|= itoa64_to_int (buf
[10]) << 12;
1276 l
|= itoa64_to_int (buf
[11]) << 18;
1278 digest
[ 8] = (l
>> 0) & 0xff;
1279 digest
[ 7] = (l
>> 8) & 0xff;
1280 digest
[ 6] = (l
>> 16) & 0xff;
1282 l
= itoa64_to_int (buf
[12]) << 0;
1283 l
|= itoa64_to_int (buf
[13]) << 6;
1284 l
|= itoa64_to_int (buf
[14]) << 12;
1285 l
|= itoa64_to_int (buf
[15]) << 18;
1287 digest
[11] = (l
>> 0) & 0xff;
1288 digest
[10] = (l
>> 8) & 0xff;
1289 digest
[ 9] = (l
>> 16) & 0xff;
1291 l
= itoa64_to_int (buf
[16]) << 0;
1292 l
|= itoa64_to_int (buf
[17]) << 6;
1293 l
|= itoa64_to_int (buf
[18]) << 12;
1294 l
|= itoa64_to_int (buf
[19]) << 18;
1296 digest
[14] = (l
>> 0) & 0xff;
1297 digest
[13] = (l
>> 8) & 0xff;
1298 digest
[12] = (l
>> 16) & 0xff;
1300 l
= itoa64_to_int (buf
[20]) << 0;
1301 l
|= itoa64_to_int (buf
[21]) << 6;
1302 l
|= itoa64_to_int (buf
[22]) << 12;
1303 l
|= itoa64_to_int (buf
[23]) << 18;
1305 digest
[17] = (l
>> 0) & 0xff;
1306 digest
[16] = (l
>> 8) & 0xff;
1307 digest
[15] = (l
>> 16) & 0xff;
1309 l
= itoa64_to_int (buf
[24]) << 0;
1310 l
|= itoa64_to_int (buf
[25]) << 6;
1311 l
|= itoa64_to_int (buf
[26]) << 12;
1313 digest
[19] = (l
>> 8) & 0xff;
1314 digest
[18] = (l
>> 16) & 0xff;
1317 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1321 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1323 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1324 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1325 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1326 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1328 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1330 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1331 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1332 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1333 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1335 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1337 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1338 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1339 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1340 buf
[11] = int_to_itoa64 (l
& 0x3f);
1342 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1344 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1345 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1346 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1347 buf
[15] = int_to_itoa64 (l
& 0x3f);
1349 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1351 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1352 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1353 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1354 buf
[19] = int_to_itoa64 (l
& 0x3f);
1356 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1358 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1359 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1360 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1361 buf
[23] = int_to_itoa64 (l
& 0x3f);
1363 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1365 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1366 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1367 buf
[26] = int_to_itoa64 (l
& 0x3f);
1370 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1374 l
= itoa64_to_int (buf
[ 0]) << 0;
1375 l
|= itoa64_to_int (buf
[ 1]) << 6;
1376 l
|= itoa64_to_int (buf
[ 2]) << 12;
1377 l
|= itoa64_to_int (buf
[ 3]) << 18;
1379 digest
[ 2] = (l
>> 0) & 0xff;
1380 digest
[ 1] = (l
>> 8) & 0xff;
1381 digest
[ 0] = (l
>> 16) & 0xff;
1383 l
= itoa64_to_int (buf
[ 4]) << 0;
1384 l
|= itoa64_to_int (buf
[ 5]) << 6;
1385 l
|= itoa64_to_int (buf
[ 6]) << 12;
1386 l
|= itoa64_to_int (buf
[ 7]) << 18;
1388 digest
[ 5] = (l
>> 0) & 0xff;
1389 digest
[ 4] = (l
>> 8) & 0xff;
1390 digest
[ 3] = (l
>> 16) & 0xff;
1392 l
= itoa64_to_int (buf
[ 8]) << 0;
1393 l
|= itoa64_to_int (buf
[ 9]) << 6;
1394 l
|= itoa64_to_int (buf
[10]) << 12;
1395 l
|= itoa64_to_int (buf
[11]) << 18;
1397 digest
[ 8] = (l
>> 0) & 0xff;
1398 digest
[ 7] = (l
>> 8) & 0xff;
1399 digest
[ 6] = (l
>> 16) & 0xff;
1401 l
= itoa64_to_int (buf
[12]) << 0;
1402 l
|= itoa64_to_int (buf
[13]) << 6;
1403 l
|= itoa64_to_int (buf
[14]) << 12;
1404 l
|= itoa64_to_int (buf
[15]) << 18;
1406 digest
[11] = (l
>> 0) & 0xff;
1407 digest
[10] = (l
>> 8) & 0xff;
1408 digest
[ 9] = (l
>> 16) & 0xff;
1410 l
= itoa64_to_int (buf
[16]) << 0;
1411 l
|= itoa64_to_int (buf
[17]) << 6;
1412 l
|= itoa64_to_int (buf
[18]) << 12;
1413 l
|= itoa64_to_int (buf
[19]) << 18;
1415 digest
[14] = (l
>> 0) & 0xff;
1416 digest
[13] = (l
>> 8) & 0xff;
1417 digest
[12] = (l
>> 16) & 0xff;
1419 l
= itoa64_to_int (buf
[20]) << 0;
1420 l
|= itoa64_to_int (buf
[21]) << 6;
1421 l
|= itoa64_to_int (buf
[22]) << 12;
1422 l
|= itoa64_to_int (buf
[23]) << 18;
1424 digest
[17] = (l
>> 0) & 0xff;
1425 digest
[16] = (l
>> 8) & 0xff;
1426 digest
[15] = (l
>> 16) & 0xff;
1428 l
= itoa64_to_int (buf
[24]) << 0;
1429 l
|= itoa64_to_int (buf
[25]) << 6;
1430 l
|= itoa64_to_int (buf
[26]) << 12;
1431 l
|= itoa64_to_int (buf
[27]) << 18;
1433 digest
[20] = (l
>> 0) & 0xff;
1434 digest
[19] = (l
>> 8) & 0xff;
1435 digest
[18] = (l
>> 16) & 0xff;
1437 l
= itoa64_to_int (buf
[28]) << 0;
1438 l
|= itoa64_to_int (buf
[29]) << 6;
1439 l
|= itoa64_to_int (buf
[30]) << 12;
1440 l
|= itoa64_to_int (buf
[31]) << 18;
1442 digest
[23] = (l
>> 0) & 0xff;
1443 digest
[22] = (l
>> 8) & 0xff;
1444 digest
[21] = (l
>> 16) & 0xff;
1446 l
= itoa64_to_int (buf
[32]) << 0;
1447 l
|= itoa64_to_int (buf
[33]) << 6;
1448 l
|= itoa64_to_int (buf
[34]) << 12;
1449 l
|= itoa64_to_int (buf
[35]) << 18;
1451 digest
[26] = (l
>> 0) & 0xff;
1452 digest
[25] = (l
>> 8) & 0xff;
1453 digest
[24] = (l
>> 16) & 0xff;
1455 l
= itoa64_to_int (buf
[36]) << 0;
1456 l
|= itoa64_to_int (buf
[37]) << 6;
1457 l
|= itoa64_to_int (buf
[38]) << 12;
1458 l
|= itoa64_to_int (buf
[39]) << 18;
1460 digest
[29] = (l
>> 0) & 0xff;
1461 digest
[28] = (l
>> 8) & 0xff;
1462 digest
[27] = (l
>> 16) & 0xff;
1464 l
= itoa64_to_int (buf
[40]) << 0;
1465 l
|= itoa64_to_int (buf
[41]) << 6;
1466 l
|= itoa64_to_int (buf
[42]) << 12;
1468 //digest[32] = (l >> 0) & 0xff;
1469 digest
[31] = (l
>> 8) & 0xff;
1470 digest
[30] = (l
>> 16) & 0xff;
1473 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1477 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1479 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1480 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1481 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1482 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1484 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1486 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1487 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1488 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1489 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1491 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1493 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1494 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1495 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1496 buf
[11] = int_to_itoa64 (l
& 0x3f);
1498 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1500 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1501 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1502 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1503 buf
[15] = int_to_itoa64 (l
& 0x3f);
1505 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1507 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1508 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1509 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1510 buf
[19] = int_to_itoa64 (l
& 0x3f);
1512 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1514 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1515 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1516 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1517 buf
[23] = int_to_itoa64 (l
& 0x3f);
1519 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1521 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1522 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1523 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1524 buf
[27] = int_to_itoa64 (l
& 0x3f);
1526 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1528 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1529 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1530 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1531 buf
[31] = int_to_itoa64 (l
& 0x3f);
1533 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1535 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1536 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1537 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1538 buf
[35] = int_to_itoa64 (l
& 0x3f);
1540 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1542 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1543 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1544 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1545 buf
[39] = int_to_itoa64 (l
& 0x3f);
1547 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1549 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1550 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1551 buf
[42] = int_to_itoa64 (l
& 0x3f);
1554 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1558 l
= itoa64_to_int (buf
[ 0]) << 0;
1559 l
|= itoa64_to_int (buf
[ 1]) << 6;
1560 l
|= itoa64_to_int (buf
[ 2]) << 12;
1561 l
|= itoa64_to_int (buf
[ 3]) << 18;
1563 digest
[ 2] = (l
>> 0) & 0xff;
1564 digest
[ 1] = (l
>> 8) & 0xff;
1565 digest
[ 0] = (l
>> 16) & 0xff;
1567 l
= itoa64_to_int (buf
[ 4]) << 0;
1568 l
|= itoa64_to_int (buf
[ 5]) << 6;
1569 l
|= itoa64_to_int (buf
[ 6]) << 12;
1570 l
|= itoa64_to_int (buf
[ 7]) << 18;
1572 digest
[ 5] = (l
>> 0) & 0xff;
1573 digest
[ 4] = (l
>> 8) & 0xff;
1574 digest
[ 3] = (l
>> 16) & 0xff;
1576 l
= itoa64_to_int (buf
[ 8]) << 0;
1577 l
|= itoa64_to_int (buf
[ 9]) << 6;
1578 l
|= itoa64_to_int (buf
[10]) << 12;
1579 l
|= itoa64_to_int (buf
[11]) << 18;
1581 digest
[ 8] = (l
>> 0) & 0xff;
1582 digest
[ 7] = (l
>> 8) & 0xff;
1583 digest
[ 6] = (l
>> 16) & 0xff;
1585 l
= itoa64_to_int (buf
[12]) << 0;
1586 l
|= itoa64_to_int (buf
[13]) << 6;
1587 l
|= itoa64_to_int (buf
[14]) << 12;
1588 l
|= itoa64_to_int (buf
[15]) << 18;
1590 digest
[11] = (l
>> 0) & 0xff;
1591 digest
[10] = (l
>> 8) & 0xff;
1592 digest
[ 9] = (l
>> 16) & 0xff;
1594 l
= itoa64_to_int (buf
[16]) << 0;
1595 l
|= itoa64_to_int (buf
[17]) << 6;
1596 l
|= itoa64_to_int (buf
[18]) << 12;
1597 l
|= itoa64_to_int (buf
[19]) << 18;
1599 digest
[14] = (l
>> 0) & 0xff;
1600 digest
[13] = (l
>> 8) & 0xff;
1601 digest
[12] = (l
>> 16) & 0xff;
1603 l
= itoa64_to_int (buf
[20]) << 0;
1604 l
|= itoa64_to_int (buf
[21]) << 6;
1605 l
|= itoa64_to_int (buf
[22]) << 12;
1606 l
|= itoa64_to_int (buf
[23]) << 18;
1608 digest
[17] = (l
>> 0) & 0xff;
1609 digest
[16] = (l
>> 8) & 0xff;
1610 digest
[15] = (l
>> 16) & 0xff;
1612 l
= itoa64_to_int (buf
[24]) << 0;
1613 l
|= itoa64_to_int (buf
[25]) << 6;
1614 l
|= itoa64_to_int (buf
[26]) << 12;
1615 l
|= itoa64_to_int (buf
[27]) << 18;
1617 digest
[20] = (l
>> 0) & 0xff;
1618 digest
[19] = (l
>> 8) & 0xff;
1619 digest
[18] = (l
>> 16) & 0xff;
1621 l
= itoa64_to_int (buf
[28]) << 0;
1622 l
|= itoa64_to_int (buf
[29]) << 6;
1623 l
|= itoa64_to_int (buf
[30]) << 12;
1624 l
|= itoa64_to_int (buf
[31]) << 18;
1626 digest
[23] = (l
>> 0) & 0xff;
1627 digest
[22] = (l
>> 8) & 0xff;
1628 digest
[21] = (l
>> 16) & 0xff;
1630 l
= itoa64_to_int (buf
[32]) << 0;
1631 l
|= itoa64_to_int (buf
[33]) << 6;
1632 l
|= itoa64_to_int (buf
[34]) << 12;
1633 l
|= itoa64_to_int (buf
[35]) << 18;
1635 digest
[26] = (l
>> 0) & 0xff;
1636 digest
[25] = (l
>> 8) & 0xff;
1637 digest
[24] = (l
>> 16) & 0xff;
1639 l
= itoa64_to_int (buf
[36]) << 0;
1640 l
|= itoa64_to_int (buf
[37]) << 6;
1641 l
|= itoa64_to_int (buf
[38]) << 12;
1642 l
|= itoa64_to_int (buf
[39]) << 18;
1644 digest
[29] = (l
>> 0) & 0xff;
1645 digest
[28] = (l
>> 8) & 0xff;
1646 digest
[27] = (l
>> 16) & 0xff;
1648 l
= itoa64_to_int (buf
[40]) << 0;
1649 l
|= itoa64_to_int (buf
[41]) << 6;
1650 l
|= itoa64_to_int (buf
[42]) << 12;
1651 l
|= itoa64_to_int (buf
[43]) << 18;
1653 digest
[32] = (l
>> 0) & 0xff;
1654 digest
[31] = (l
>> 8) & 0xff;
1655 digest
[30] = (l
>> 16) & 0xff;
1657 l
= itoa64_to_int (buf
[44]) << 0;
1658 l
|= itoa64_to_int (buf
[45]) << 6;
1659 l
|= itoa64_to_int (buf
[46]) << 12;
1660 l
|= itoa64_to_int (buf
[47]) << 18;
1662 digest
[35] = (l
>> 0) & 0xff;
1663 digest
[34] = (l
>> 8) & 0xff;
1664 digest
[33] = (l
>> 16) & 0xff;
1666 l
= itoa64_to_int (buf
[48]) << 0;
1667 l
|= itoa64_to_int (buf
[49]) << 6;
1668 l
|= itoa64_to_int (buf
[50]) << 12;
1669 l
|= itoa64_to_int (buf
[51]) << 18;
1671 digest
[38] = (l
>> 0) & 0xff;
1672 digest
[37] = (l
>> 8) & 0xff;
1673 digest
[36] = (l
>> 16) & 0xff;
1675 l
= itoa64_to_int (buf
[52]) << 0;
1676 l
|= itoa64_to_int (buf
[53]) << 6;
1677 l
|= itoa64_to_int (buf
[54]) << 12;
1678 l
|= itoa64_to_int (buf
[55]) << 18;
1680 digest
[41] = (l
>> 0) & 0xff;
1681 digest
[40] = (l
>> 8) & 0xff;
1682 digest
[39] = (l
>> 16) & 0xff;
1684 l
= itoa64_to_int (buf
[56]) << 0;
1685 l
|= itoa64_to_int (buf
[57]) << 6;
1686 l
|= itoa64_to_int (buf
[58]) << 12;
1687 l
|= itoa64_to_int (buf
[59]) << 18;
1689 digest
[44] = (l
>> 0) & 0xff;
1690 digest
[43] = (l
>> 8) & 0xff;
1691 digest
[42] = (l
>> 16) & 0xff;
1693 l
= itoa64_to_int (buf
[60]) << 0;
1694 l
|= itoa64_to_int (buf
[61]) << 6;
1695 l
|= itoa64_to_int (buf
[62]) << 12;
1696 l
|= itoa64_to_int (buf
[63]) << 18;
1698 digest
[47] = (l
>> 0) & 0xff;
1699 digest
[46] = (l
>> 8) & 0xff;
1700 digest
[45] = (l
>> 16) & 0xff;
1702 l
= itoa64_to_int (buf
[64]) << 0;
1703 l
|= itoa64_to_int (buf
[65]) << 6;
1704 l
|= itoa64_to_int (buf
[66]) << 12;
1705 l
|= itoa64_to_int (buf
[67]) << 18;
1707 digest
[50] = (l
>> 0) & 0xff;
1708 digest
[49] = (l
>> 8) & 0xff;
1709 digest
[48] = (l
>> 16) & 0xff;
1711 l
= itoa64_to_int (buf
[68]) << 0;
1712 l
|= itoa64_to_int (buf
[69]) << 6;
1713 l
|= itoa64_to_int (buf
[70]) << 12;
1714 l
|= itoa64_to_int (buf
[71]) << 18;
1716 digest
[53] = (l
>> 0) & 0xff;
1717 digest
[52] = (l
>> 8) & 0xff;
1718 digest
[51] = (l
>> 16) & 0xff;
1720 l
= itoa64_to_int (buf
[72]) << 0;
1721 l
|= itoa64_to_int (buf
[73]) << 6;
1722 l
|= itoa64_to_int (buf
[74]) << 12;
1723 l
|= itoa64_to_int (buf
[75]) << 18;
1725 digest
[56] = (l
>> 0) & 0xff;
1726 digest
[55] = (l
>> 8) & 0xff;
1727 digest
[54] = (l
>> 16) & 0xff;
1729 l
= itoa64_to_int (buf
[76]) << 0;
1730 l
|= itoa64_to_int (buf
[77]) << 6;
1731 l
|= itoa64_to_int (buf
[78]) << 12;
1732 l
|= itoa64_to_int (buf
[79]) << 18;
1734 digest
[59] = (l
>> 0) & 0xff;
1735 digest
[58] = (l
>> 8) & 0xff;
1736 digest
[57] = (l
>> 16) & 0xff;
1738 l
= itoa64_to_int (buf
[80]) << 0;
1739 l
|= itoa64_to_int (buf
[81]) << 6;
1740 l
|= itoa64_to_int (buf
[82]) << 12;
1741 l
|= itoa64_to_int (buf
[83]) << 18;
1743 digest
[62] = (l
>> 0) & 0xff;
1744 digest
[61] = (l
>> 8) & 0xff;
1745 digest
[60] = (l
>> 16) & 0xff;
1747 l
= itoa64_to_int (buf
[84]) << 0;
1748 l
|= itoa64_to_int (buf
[85]) << 6;
1750 digest
[63] = (l
>> 16) & 0xff;
1753 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1757 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1759 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1760 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1761 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1762 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1764 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1766 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1767 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1768 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1769 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1771 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1773 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1774 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1775 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1776 buf
[11] = int_to_itoa64 (l
& 0x3f);
1778 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1780 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1781 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1782 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1783 buf
[15] = int_to_itoa64 (l
& 0x3f);
1785 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1787 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1788 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1789 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1790 buf
[19] = int_to_itoa64 (l
& 0x3f);
1792 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1794 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1795 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1796 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1797 buf
[23] = int_to_itoa64 (l
& 0x3f);
1799 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1801 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1802 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1803 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1804 buf
[27] = int_to_itoa64 (l
& 0x3f);
1806 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1808 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1809 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1810 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1811 buf
[31] = int_to_itoa64 (l
& 0x3f);
1813 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1815 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1816 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1817 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1818 buf
[35] = int_to_itoa64 (l
& 0x3f);
1820 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1822 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1823 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1824 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1825 buf
[39] = int_to_itoa64 (l
& 0x3f);
1827 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1829 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1830 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1831 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1832 buf
[43] = int_to_itoa64 (l
& 0x3f);
1834 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1836 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1837 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1838 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1839 buf
[47] = int_to_itoa64 (l
& 0x3f);
1841 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1843 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1844 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1845 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1846 buf
[51] = int_to_itoa64 (l
& 0x3f);
1848 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1850 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1851 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1852 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1853 buf
[55] = int_to_itoa64 (l
& 0x3f);
1855 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1857 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1858 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1859 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1860 buf
[59] = int_to_itoa64 (l
& 0x3f);
1862 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1864 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1865 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1866 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1867 buf
[63] = int_to_itoa64 (l
& 0x3f);
1869 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1871 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1872 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1873 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1874 buf
[67] = int_to_itoa64 (l
& 0x3f);
1876 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1878 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1879 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1880 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1881 buf
[71] = int_to_itoa64 (l
& 0x3f);
1883 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1885 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1886 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1887 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1888 buf
[75] = int_to_itoa64 (l
& 0x3f);
1890 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1892 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1893 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1894 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1895 buf
[79] = int_to_itoa64 (l
& 0x3f);
1897 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1899 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1900 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1901 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1902 buf
[83] = int_to_itoa64 (l
& 0x3f);
1904 l
= 0 | 0 | (digest
[63] << 16);
1906 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1907 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1910 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1914 l
= itoa64_to_int (buf
[ 0]) << 0;
1915 l
|= itoa64_to_int (buf
[ 1]) << 6;
1916 l
|= itoa64_to_int (buf
[ 2]) << 12;
1917 l
|= itoa64_to_int (buf
[ 3]) << 18;
1919 digest
[ 0] = (l
>> 16) & 0xff;
1920 digest
[10] = (l
>> 8) & 0xff;
1921 digest
[20] = (l
>> 0) & 0xff;
1923 l
= itoa64_to_int (buf
[ 4]) << 0;
1924 l
|= itoa64_to_int (buf
[ 5]) << 6;
1925 l
|= itoa64_to_int (buf
[ 6]) << 12;
1926 l
|= itoa64_to_int (buf
[ 7]) << 18;
1928 digest
[21] = (l
>> 16) & 0xff;
1929 digest
[ 1] = (l
>> 8) & 0xff;
1930 digest
[11] = (l
>> 0) & 0xff;
1932 l
= itoa64_to_int (buf
[ 8]) << 0;
1933 l
|= itoa64_to_int (buf
[ 9]) << 6;
1934 l
|= itoa64_to_int (buf
[10]) << 12;
1935 l
|= itoa64_to_int (buf
[11]) << 18;
1937 digest
[12] = (l
>> 16) & 0xff;
1938 digest
[22] = (l
>> 8) & 0xff;
1939 digest
[ 2] = (l
>> 0) & 0xff;
1941 l
= itoa64_to_int (buf
[12]) << 0;
1942 l
|= itoa64_to_int (buf
[13]) << 6;
1943 l
|= itoa64_to_int (buf
[14]) << 12;
1944 l
|= itoa64_to_int (buf
[15]) << 18;
1946 digest
[ 3] = (l
>> 16) & 0xff;
1947 digest
[13] = (l
>> 8) & 0xff;
1948 digest
[23] = (l
>> 0) & 0xff;
1950 l
= itoa64_to_int (buf
[16]) << 0;
1951 l
|= itoa64_to_int (buf
[17]) << 6;
1952 l
|= itoa64_to_int (buf
[18]) << 12;
1953 l
|= itoa64_to_int (buf
[19]) << 18;
1955 digest
[24] = (l
>> 16) & 0xff;
1956 digest
[ 4] = (l
>> 8) & 0xff;
1957 digest
[14] = (l
>> 0) & 0xff;
1959 l
= itoa64_to_int (buf
[20]) << 0;
1960 l
|= itoa64_to_int (buf
[21]) << 6;
1961 l
|= itoa64_to_int (buf
[22]) << 12;
1962 l
|= itoa64_to_int (buf
[23]) << 18;
1964 digest
[15] = (l
>> 16) & 0xff;
1965 digest
[25] = (l
>> 8) & 0xff;
1966 digest
[ 5] = (l
>> 0) & 0xff;
1968 l
= itoa64_to_int (buf
[24]) << 0;
1969 l
|= itoa64_to_int (buf
[25]) << 6;
1970 l
|= itoa64_to_int (buf
[26]) << 12;
1971 l
|= itoa64_to_int (buf
[27]) << 18;
1973 digest
[ 6] = (l
>> 16) & 0xff;
1974 digest
[16] = (l
>> 8) & 0xff;
1975 digest
[26] = (l
>> 0) & 0xff;
1977 l
= itoa64_to_int (buf
[28]) << 0;
1978 l
|= itoa64_to_int (buf
[29]) << 6;
1979 l
|= itoa64_to_int (buf
[30]) << 12;
1980 l
|= itoa64_to_int (buf
[31]) << 18;
1982 digest
[27] = (l
>> 16) & 0xff;
1983 digest
[ 7] = (l
>> 8) & 0xff;
1984 digest
[17] = (l
>> 0) & 0xff;
1986 l
= itoa64_to_int (buf
[32]) << 0;
1987 l
|= itoa64_to_int (buf
[33]) << 6;
1988 l
|= itoa64_to_int (buf
[34]) << 12;
1989 l
|= itoa64_to_int (buf
[35]) << 18;
1991 digest
[18] = (l
>> 16) & 0xff;
1992 digest
[28] = (l
>> 8) & 0xff;
1993 digest
[ 8] = (l
>> 0) & 0xff;
1995 l
= itoa64_to_int (buf
[36]) << 0;
1996 l
|= itoa64_to_int (buf
[37]) << 6;
1997 l
|= itoa64_to_int (buf
[38]) << 12;
1998 l
|= itoa64_to_int (buf
[39]) << 18;
2000 digest
[ 9] = (l
>> 16) & 0xff;
2001 digest
[19] = (l
>> 8) & 0xff;
2002 digest
[29] = (l
>> 0) & 0xff;
2004 l
= itoa64_to_int (buf
[40]) << 0;
2005 l
|= itoa64_to_int (buf
[41]) << 6;
2006 l
|= itoa64_to_int (buf
[42]) << 12;
2008 digest
[31] = (l
>> 8) & 0xff;
2009 digest
[30] = (l
>> 0) & 0xff;
2012 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2016 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2018 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2019 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2020 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2021 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2023 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2025 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2026 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2027 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2028 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2030 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2032 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2033 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2034 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2035 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2037 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2039 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2041 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2042 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2044 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2046 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2048 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2049 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2051 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2053 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2055 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2056 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2058 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2060 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2062 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2063 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2065 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2067 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2069 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2070 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2072 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2074 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2076 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2077 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2079 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2081 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2083 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2084 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2086 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2088 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2090 buf
[42] = int_to_itoa64 (l
& 0x3f);
2093 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2097 l
= itoa64_to_int (buf
[ 0]) << 0;
2098 l
|= itoa64_to_int (buf
[ 1]) << 6;
2099 l
|= itoa64_to_int (buf
[ 2]) << 12;
2100 l
|= itoa64_to_int (buf
[ 3]) << 18;
2102 digest
[ 0] = (l
>> 0) & 0xff;
2103 digest
[ 1] = (l
>> 8) & 0xff;
2104 digest
[ 2] = (l
>> 16) & 0xff;
2106 l
= itoa64_to_int (buf
[ 4]) << 0;
2107 l
|= itoa64_to_int (buf
[ 5]) << 6;
2108 l
|= itoa64_to_int (buf
[ 6]) << 12;
2109 l
|= itoa64_to_int (buf
[ 7]) << 18;
2111 digest
[ 3] = (l
>> 0) & 0xff;
2112 digest
[ 4] = (l
>> 8) & 0xff;
2113 digest
[ 5] = (l
>> 16) & 0xff;
2115 l
= itoa64_to_int (buf
[ 8]) << 0;
2116 l
|= itoa64_to_int (buf
[ 9]) << 6;
2117 l
|= itoa64_to_int (buf
[10]) << 12;
2118 l
|= itoa64_to_int (buf
[11]) << 18;
2120 digest
[ 6] = (l
>> 0) & 0xff;
2121 digest
[ 7] = (l
>> 8) & 0xff;
2122 digest
[ 8] = (l
>> 16) & 0xff;
2124 l
= itoa64_to_int (buf
[12]) << 0;
2125 l
|= itoa64_to_int (buf
[13]) << 6;
2126 l
|= itoa64_to_int (buf
[14]) << 12;
2127 l
|= itoa64_to_int (buf
[15]) << 18;
2129 digest
[ 9] = (l
>> 0) & 0xff;
2130 digest
[10] = (l
>> 8) & 0xff;
2131 digest
[11] = (l
>> 16) & 0xff;
2133 l
= itoa64_to_int (buf
[16]) << 0;
2134 l
|= itoa64_to_int (buf
[17]) << 6;
2135 l
|= itoa64_to_int (buf
[18]) << 12;
2136 l
|= itoa64_to_int (buf
[19]) << 18;
2138 digest
[12] = (l
>> 0) & 0xff;
2139 digest
[13] = (l
>> 8) & 0xff;
2140 digest
[14] = (l
>> 16) & 0xff;
2142 l
= itoa64_to_int (buf
[20]) << 0;
2143 l
|= itoa64_to_int (buf
[21]) << 6;
2144 l
|= itoa64_to_int (buf
[22]) << 12;
2145 l
|= itoa64_to_int (buf
[23]) << 18;
2147 digest
[15] = (l
>> 0) & 0xff;
2148 digest
[16] = (l
>> 8) & 0xff;
2149 digest
[17] = (l
>> 16) & 0xff;
2151 l
= itoa64_to_int (buf
[24]) << 0;
2152 l
|= itoa64_to_int (buf
[25]) << 6;
2153 l
|= itoa64_to_int (buf
[26]) << 12;
2154 l
|= itoa64_to_int (buf
[27]) << 18;
2156 digest
[18] = (l
>> 0) & 0xff;
2157 digest
[19] = (l
>> 8) & 0xff;
2158 digest
[20] = (l
>> 16) & 0xff;
2160 l
= itoa64_to_int (buf
[28]) << 0;
2161 l
|= itoa64_to_int (buf
[29]) << 6;
2162 l
|= itoa64_to_int (buf
[30]) << 12;
2163 l
|= itoa64_to_int (buf
[31]) << 18;
2165 digest
[21] = (l
>> 0) & 0xff;
2166 digest
[22] = (l
>> 8) & 0xff;
2167 digest
[23] = (l
>> 16) & 0xff;
2169 l
= itoa64_to_int (buf
[32]) << 0;
2170 l
|= itoa64_to_int (buf
[33]) << 6;
2171 l
|= itoa64_to_int (buf
[34]) << 12;
2172 l
|= itoa64_to_int (buf
[35]) << 18;
2174 digest
[24] = (l
>> 0) & 0xff;
2175 digest
[25] = (l
>> 8) & 0xff;
2176 digest
[26] = (l
>> 16) & 0xff;
2178 l
= itoa64_to_int (buf
[36]) << 0;
2179 l
|= itoa64_to_int (buf
[37]) << 6;
2180 l
|= itoa64_to_int (buf
[38]) << 12;
2181 l
|= itoa64_to_int (buf
[39]) << 18;
2183 digest
[27] = (l
>> 0) & 0xff;
2184 digest
[28] = (l
>> 8) & 0xff;
2185 digest
[29] = (l
>> 16) & 0xff;
2187 l
= itoa64_to_int (buf
[40]) << 0;
2188 l
|= itoa64_to_int (buf
[41]) << 6;
2189 l
|= itoa64_to_int (buf
[42]) << 12;
2190 l
|= itoa64_to_int (buf
[43]) << 18;
2192 digest
[30] = (l
>> 0) & 0xff;
2193 digest
[31] = (l
>> 8) & 0xff;
2194 digest
[32] = (l
>> 16) & 0xff;
2229 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2233 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2235 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2236 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2237 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2238 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2240 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2242 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2243 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2244 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2245 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2247 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2249 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2250 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2251 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2252 buf
[11] = int_to_itoa64 (l
& 0x3f);
2254 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2256 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2257 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2258 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2259 buf
[15] = int_to_itoa64 (l
& 0x3f);
2261 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2263 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2264 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2265 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2266 buf
[19] = int_to_itoa64 (l
& 0x3f);
2268 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2270 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2271 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2272 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2273 buf
[23] = int_to_itoa64 (l
& 0x3f);
2275 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2277 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2278 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2279 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2280 buf
[27] = int_to_itoa64 (l
& 0x3f);
2282 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2284 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2285 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2286 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2287 buf
[31] = int_to_itoa64 (l
& 0x3f);
2289 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2291 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2292 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2293 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2294 buf
[35] = int_to_itoa64 (l
& 0x3f);
2296 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2298 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2299 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2300 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2301 buf
[39] = int_to_itoa64 (l
& 0x3f);
2303 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2305 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2306 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2307 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2308 //buf[43] = int_to_itoa64 (l & 0x3f);
2316 static struct termio savemodes
;
2317 static int havemodes
= 0;
2321 struct termio modmodes
;
2323 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2327 modmodes
= savemodes
;
2328 modmodes
.c_lflag
&= ~ICANON
;
2329 modmodes
.c_cc
[VMIN
] = 1;
2330 modmodes
.c_cc
[VTIME
] = 0;
2332 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2341 FD_SET (fileno (stdin
), &rfds
);
2348 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2350 if (retval
== 0) return 0;
2351 if (retval
== -1) return -1;
2358 if (!havemodes
) return 0;
2360 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2365 static struct termios savemodes
;
2366 static int havemodes
= 0;
2370 struct termios modmodes
;
2372 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2376 modmodes
= savemodes
;
2377 modmodes
.c_lflag
&= ~ICANON
;
2378 modmodes
.c_cc
[VMIN
] = 1;
2379 modmodes
.c_cc
[VTIME
] = 0;
2381 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2390 FD_SET (fileno (stdin
), &rfds
);
2397 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2399 if (retval
== 0) return 0;
2400 if (retval
== -1) return -1;
2407 if (!havemodes
) return 0;
2409 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2414 static DWORD saveMode
= 0;
2418 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2420 GetConsoleMode (stdinHandle
, &saveMode
);
2421 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2428 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2430 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2432 if (rc
== WAIT_TIMEOUT
) return 0;
2433 if (rc
== WAIT_ABANDONED
) return -1;
2434 if (rc
== WAIT_FAILED
) return -1;
2436 // The whole ReadConsoleInput () part is a workaround.
2437 // For some unknown reason, maybe a mingw bug, a random signal
2438 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2439 // Then it wants to read with getche () a keyboard input
2440 // which has never been made.
2442 INPUT_RECORD buf
[100];
2446 memset (buf
, 0, sizeof (buf
));
2448 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2450 FlushConsoleInputBuffer (stdinHandle
);
2452 for (uint i
= 0; i
< num
; i
++)
2454 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2456 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2458 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2460 return KeyEvent
.uChar
.AsciiChar
;
2468 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2470 SetConsoleMode (stdinHandle
, saveMode
);
2480 #define MSG_ENOMEM "Insufficient memory available"
2482 void *mycalloc (size_t nmemb
, size_t size
)
2484 void *p
= calloc (nmemb
, size
);
2488 log_error ("ERROR: %s", MSG_ENOMEM
);
2496 void *mymalloc (size_t size
)
2498 void *p
= malloc (size
);
2502 log_error ("ERROR: %s", MSG_ENOMEM
);
2507 memset (p
, 0, size
);
2512 void myfree (void *ptr
)
2514 if (ptr
== NULL
) return;
2519 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2521 void *p
= realloc (ptr
, oldsz
+ add
);
2525 log_error ("ERROR: %s", MSG_ENOMEM
);
2530 memset ((char *) p
+ oldsz
, 0, add
);
2535 char *mystrdup (const char *s
)
2537 const size_t len
= strlen (s
);
2539 char *b
= (char *) mymalloc (len
+ 1);
2546 FILE *logfile_open (char *logfile
)
2548 FILE *fp
= fopen (logfile
, "ab");
2558 void logfile_close (FILE *fp
)
2560 if (fp
== stdout
) return;
2565 void logfile_append (const char *fmt
, ...)
2567 if (data
.logfile_disable
== 1) return;
2569 FILE *fp
= logfile_open (data
.logfile
);
2575 vfprintf (fp
, fmt
, ap
);
2586 int logfile_generate_id ()
2588 const int n
= rand ();
2597 char *logfile_generate_topid ()
2599 const int id
= logfile_generate_id ();
2601 char *topid
= (char *) mymalloc (1 + 16 + 1);
2603 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2608 char *logfile_generate_subid ()
2610 const int id
= logfile_generate_id ();
2612 char *subid
= (char *) mymalloc (1 + 16 + 1);
2614 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2624 void lock_file (FILE *fp
)
2628 memset (&lock
, 0, sizeof (struct flock
));
2630 lock
.l_type
= F_WRLCK
;
2631 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2635 log_error ("ERROR: failed acquiring write lock: %s", strerror (errno
));
2642 void unlock_file (FILE *fp
)
2646 memset (&lock
, 0, sizeof (struct flock
));
2648 lock
.l_type
= F_UNLCK
;
2649 fcntl(fileno(fp
), F_SETLK
, &lock
);
2656 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2658 FlushFileBuffers (h
);
2667 #if defined(_WIN) && defined(HAVE_NVAPI)
2668 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2672 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nv
, nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2676 log_info ("WARN: No NvAPI adapters found");
2683 #endif // _WIN && HAVE_NVAPI
2685 #if defined(LINUX) && defined(HAVE_NVML)
2686 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2690 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2692 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nv
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2694 // can be used to determine if the device by index matches the cuda device by index
2695 // char name[100]; memset (name, 0, sizeof (name));
2696 // hm_NVML_nvmlDeviceGetName (data.hm_nv, nvGPUHandle[i], name, sizeof (name) - 1);
2703 log_info ("WARN: No NVML adapters found");
2710 #endif // LINUX && HAVE_NVML
2713 int get_adapters_num_amd (void *adl
, int *iNumberAdapters
)
2715 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2717 if (iNumberAdapters
== 0)
2719 log_info ("WARN: No ADL adapters found.");
2728 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2730 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2731 ADLODParameters lpOdParameters;
2733 lpOdParameters.iSize = sizeof (ADLODParameters);
2734 size_t plevels_size = 0;
2736 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2738 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2739 __func__, iAdapterIndex,
2740 lpOdParameters.iNumberOfPerformanceLevels,
2741 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2742 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2744 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2746 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2748 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2750 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2752 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2753 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2754 __func__, iAdapterIndex, j,
2755 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2757 myfree (lpOdPerformanceLevels);
2763 LPAdapterInfo
hm_get_adapter_info_amd (void *adl
, int iNumberAdapters
)
2765 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2767 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2769 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2771 return lpAdapterInfo
;
2776 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2779 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2783 for (uint i = 0; i < num_adl_adapters; i++)
2785 int opencl_bus_num = hm_device[i].busid;
2786 int opencl_dev_num = hm_device[i].devid;
2788 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2796 if (idx >= DEVICES_MAX) return -1;
2801 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2803 for (uint i = 0; i < opencl_num_devices; i++)
2805 cl_device_topology_amd device_topology;
2807 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2809 hm_device[i].busid = device_topology.pcie.bus;
2810 hm_device[i].devid = device_topology.pcie.device;
2815 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2817 // basically bubble sort
2819 for (int i
= 0; i
< num_adl_adapters
; i
++)
2821 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2823 // get info of adapter [x]
2825 u32 adapter_index_x
= valid_adl_device_list
[j
];
2826 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2828 u32 bus_num_x
= info_x
.iBusNumber
;
2829 u32 dev_num_x
= info_x
.iDeviceNumber
;
2831 // get info of adapter [y]
2833 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2834 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2836 u32 bus_num_y
= info_y
.iBusNumber
;
2837 u32 dev_num_y
= info_y
.iDeviceNumber
;
2841 if (bus_num_y
< bus_num_x
)
2845 else if (bus_num_y
== bus_num_x
)
2847 if (dev_num_y
< dev_num_x
)
2855 u32 temp
= valid_adl_device_list
[j
+ 1];
2857 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2858 valid_adl_device_list
[j
+ 0] = temp
;
2864 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2866 *num_adl_adapters
= 0;
2868 u32
*adl_adapters
= NULL
;
2870 int *bus_numbers
= NULL
;
2871 int *device_numbers
= NULL
;
2873 for (int i
= 0; i
< iNumberAdapters
; i
++)
2875 AdapterInfo info
= lpAdapterInfo
[i
];
2877 if (strlen (info
.strUDID
) < 1) continue;
2880 if (info
.iVendorID
!= 1002) continue;
2882 if (info
.iVendorID
!= 0x1002) continue;
2885 if (info
.iBusNumber
< 0) continue;
2886 if (info
.iDeviceNumber
< 0) continue;
2890 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2892 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2899 if (found
) continue;
2901 // add it to the list
2903 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2905 adl_adapters
[*num_adl_adapters
] = i
;
2907 // rest is just bookkeeping
2909 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2910 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2912 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2913 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2915 (*num_adl_adapters
)++;
2918 myfree (bus_numbers
);
2919 myfree (device_numbers
);
2921 // sort the list by increasing bus id, device id number
2923 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2925 return adl_adapters
;
2928 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2930 // loop through all valid devices
2932 for (int i
= 0; i
< num_adl_adapters
; i
++)
2934 u32 adapter_index
= valid_adl_device_list
[i
];
2938 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2940 // unfortunately this doesn't work since bus id and dev id are not unique
2941 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2942 // if (opencl_device_index == -1) continue;
2944 int opencl_device_index
= i
;
2946 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2948 // get fanspeed info
2950 if (hm_device
[opencl_device_index
].od_version
== 5)
2952 ADLFanSpeedInfo FanSpeedInfo
;
2954 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2956 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2958 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2960 // check read and write capability in fanspeedinfo
2962 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2963 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2965 hm_device
[opencl_device_index
].fan_supported
= 1;
2969 hm_device
[opencl_device_index
].fan_supported
= 0;
2972 else // od_version == 6
2974 ADLOD6FanSpeedInfo faninfo
;
2976 memset (&faninfo
, 0, sizeof (faninfo
));
2978 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2980 // check read capability in fanspeedinfo
2982 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2984 hm_device
[opencl_device_index
].fan_supported
= 1;
2988 hm_device
[opencl_device_index
].fan_supported
= 0;
2996 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2998 for (int i
= 0; i
< num_adl_adapters
; i
++)
3000 u32 adapter_index
= valid_adl_device_list
[i
];
3004 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3006 // get overdrive version
3008 int od_supported
= 0;
3012 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3014 // store the overdrive version in hm_device
3016 // unfortunately this doesn't work since bus id and dev id are not unique
3017 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3018 // if (opencl_device_index == -1) continue;
3020 int opencl_device_index
= i
;
3022 hm_device
[opencl_device_index
].od_version
= od_version
;
3028 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3030 for (int i
= 0; i
< num_adl_adapters
; i
++)
3032 u32 adapter_index
= valid_adl_device_list
[i
];
3036 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3038 // store the iAdapterIndex in hm_device
3040 // unfortunately this doesn't work since bus id and dev id are not unique
3041 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3042 // if (opencl_device_index == -1) continue;
3044 int opencl_device_index
= i
;
3046 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3049 return num_adl_adapters
;
3053 int hm_get_temperature_with_device_id (const uint device_id
)
3055 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3058 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3062 if (data
.hm_device
[device_id
].od_version
== 5)
3064 ADLTemperature Temperature
;
3066 Temperature
.iSize
= sizeof (ADLTemperature
);
3068 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3070 return Temperature
.iTemperature
/ 1000;
3072 else if (data
.hm_device
[device_id
].od_version
== 6)
3074 int Temperature
= 0;
3076 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3078 return Temperature
/ 1000;
3084 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3085 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3087 #if defined(LINUX) && defined(HAVE_NVML)
3088 int temperature
= 0;
3090 hm_NVML_nvmlDeviceGetTemperature (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (unsigned int *) &temperature
);
3095 #if defined(WIN) && defined(HAVE_NVAPI)
3096 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3098 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3099 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3100 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3101 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3103 if (hm_NvAPI_GPU_GetThermalSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3105 return pThermalSettings
.sensor
[0].currentTemp
;
3106 #endif // WIN && HAVE_NVAPI
3108 #endif // HAVE_NVML || HAVE_NVAPI
3113 int hm_get_fanspeed_with_device_id (const uint device_id
)
3115 // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
3116 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3118 if (data
.hm_device
[device_id
].fan_supported
== 1)
3121 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3125 if (data
.hm_device
[device_id
].od_version
== 5)
3127 ADLFanSpeedValue lpFanSpeedValue
;
3129 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3131 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3132 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3133 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3135 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3137 return lpFanSpeedValue
.iFanSpeed
;
3139 else // od_version == 6
3141 ADLOD6FanSpeedInfo faninfo
;
3143 memset (&faninfo
, 0, sizeof (faninfo
));
3145 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3147 return faninfo
.iFanSpeedPercent
;
3153 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3154 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3156 #if defined(LINUX) && defined(HAVE_NVML)
3159 hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (unsigned int *) &speed
);
3164 #if defined(WIN) && defined(HAVE_NVAPI)
3166 NV_GPU_COOLER_SETTINGS pCoolerSettings
;
3168 pCoolerSettings
.Version
= GPU_COOLER_SETTINGS_VER
| sizeof (NV_GPU_COOLER_SETTINGS
);
3170 hm_NvAPI_GPU_GetCoolerSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pCoolerSettings
);
3172 return pCoolerSettings
.Cooler
[0].CurrentLevel
;
3175 #endif // HAVE_NVML || HAVE_NVAPI
3181 int hm_get_utilization_with_device_id (const uint device_id
)
3183 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3186 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3190 ADLPMActivity PMActivity
;
3192 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3194 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3196 return PMActivity
.iActivityPercent
;
3201 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3202 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3204 #if defined(LINUX) && defined(HAVE_NVML)
3205 nvmlUtilization_t utilization
;
3207 hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3209 return utilization
.gpu
;
3212 #if defined(WIN) && defined(HAVE_NVAPI)
3213 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3215 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3217 if (hm_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3219 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3222 #endif // HAVE_NVML || HAVE_NVAPI
3228 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3230 if (data
.hm_device
[device_id
].fan_supported
== 1)
3234 if (data
.hm_device
[device_id
].od_version
== 5)
3236 ADLFanSpeedValue lpFanSpeedValue
;
3238 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3240 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3241 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3242 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3243 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3245 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3249 else // od_version == 6
3251 ADLOD6FanSpeedValue fan_speed_value
;
3253 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3255 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3256 fan_speed_value
.iFanSpeed
= fanspeed
;
3258 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3269 // helper function for status display
3271 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3273 #define VALUE_NOT_AVAILABLE "N/A"
3277 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3281 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3284 #endif // HAVE_HWMON
3290 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3292 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3294 if (css_cnt
> SP_PW_MAX
)
3296 log_error ("ERROR: mask length is too long");
3301 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3303 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3305 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3306 uint cs_len
= css
[css_pos
].cs_len
;
3308 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3310 uint c
= cs_buf
[cs_pos
] & 0xff;
3317 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3319 cs_t
*cs
= &css
[css_cnt
];
3321 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3323 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3327 for (i
= 0; i
< cs
->cs_len
; i
++)
3329 const uint u
= cs
->cs_buf
[i
];
3334 for (i
= 0; i
< in_len
; i
++)
3336 uint u
= in_buf
[i
] & 0xff;
3338 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3340 if (css_uniq
[u
] == 1) continue;
3344 cs
->cs_buf
[cs
->cs_len
] = u
;
3352 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3356 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3358 uint p0
= in_buf
[in_pos
] & 0xff;
3360 if (interpret
== 1 && p0
== '?')
3364 if (in_pos
== in_len
) break;
3366 uint p1
= in_buf
[in_pos
] & 0xff;
3370 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3372 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3374 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3376 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3378 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3380 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3382 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3383 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3385 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3386 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3388 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3389 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3391 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3392 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3394 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3396 default: log_error ("Syntax error: %s", in_buf
);
3402 if (data
.hex_charset
)
3406 if (in_pos
== in_len
)
3408 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3413 uint p1
= in_buf
[in_pos
] & 0xff;
3415 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3417 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3424 chr
= hex_convert (p1
) << 0;
3425 chr
|= hex_convert (p0
) << 4;
3427 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3433 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3439 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3443 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3445 sum
*= css
[css_pos
].cs_len
;
3451 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3453 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3458 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3460 char p0
= mask_buf
[mask_pos
];
3466 if (mask_pos
== mask_len
) break;
3468 char p1
= mask_buf
[mask_pos
];
3474 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3476 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3478 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3480 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3482 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3484 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3486 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3487 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3489 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3490 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3492 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3493 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3495 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3496 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3498 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3500 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3506 if (data
.hex_charset
)
3510 // if there is no 2nd hex character, show an error:
3512 if (mask_pos
== mask_len
)
3514 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3519 char p1
= mask_buf
[mask_pos
];
3521 // if they are not valid hex character, show an error:
3523 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3525 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3532 chr
|= hex_convert (p1
) << 0;
3533 chr
|= hex_convert (p0
) << 4;
3535 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3541 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3548 log_error ("ERROR: invalid mask length (0)");
3558 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3560 for (int i
= 0; i
< css_cnt
; i
++)
3562 uint len
= css
[i
].cs_len
;
3563 u64 next
= val
/ len
;
3564 uint pos
= val
% len
;
3565 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3570 void mp_cut_at (char *mask
, uint max
)
3574 uint mask_len
= strlen (mask
);
3576 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3578 if (mask
[i
] == '?') i
++;
3584 void mp_setup_sys (cs_t
*mp_sys
)
3588 uint donec
[CHARSIZ
] = { 0 };
3590 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3591 mp_sys
[0].cs_buf
[pos
++] = chr
;
3592 mp_sys
[0].cs_len
= pos
; }
3594 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3595 mp_sys
[1].cs_buf
[pos
++] = chr
;
3596 mp_sys
[1].cs_len
= pos
; }
3598 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3599 mp_sys
[2].cs_buf
[pos
++] = chr
;
3600 mp_sys
[2].cs_len
= pos
; }
3602 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3603 mp_sys
[3].cs_buf
[pos
++] = chr
;
3604 mp_sys
[3].cs_len
= pos
; }
3606 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3607 mp_sys
[4].cs_len
= pos
; }
3609 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3610 mp_sys
[5].cs_len
= pos
; }
3613 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3615 FILE *fp
= fopen (buf
, "rb");
3617 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3619 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3623 char mp_file
[1024] = { 0 };
3625 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3629 len
= in_superchop (mp_file
);
3633 log_info ("WARNING: charset file corrupted");
3635 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3639 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3644 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3646 mp_usr
[index
].cs_len
= 0;
3648 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3651 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3653 char *new_mask_buf
= (char *) mymalloc (256);
3659 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3661 if (css_pos
== len
) break;
3663 char p0
= mask_buf
[mask_pos
];
3665 new_mask_buf
[mask_pos
] = p0
;
3671 if (mask_pos
== mask_len
) break;
3673 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3677 if (data
.hex_charset
)
3681 if (mask_pos
== mask_len
)
3683 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3688 char p1
= mask_buf
[mask_pos
];
3690 // if they are not valid hex character, show an error:
3692 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3694 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3699 new_mask_buf
[mask_pos
] = p1
;
3704 if (css_pos
== len
) return (new_mask_buf
);
3706 myfree (new_mask_buf
);
3715 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3721 for (i
= start
; i
< stop
; i
++)
3723 sum
*= root_css_buf
[i
].cs_len
;
3729 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3733 cs_t
*cs
= &root_css_buf
[start
];
3737 for (i
= start
; i
< stop
; i
++)
3739 const u64 m
= v
% cs
->cs_len
;
3740 const u64 d
= v
/ cs
->cs_len
;
3744 const uint k
= cs
->cs_buf
[m
];
3746 pw_buf
[i
- start
] = (char) k
;
3748 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3752 int sp_comp_val (const void *p1
, const void *p2
)
3754 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3755 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3757 return b2
->val
- b1
->val
;
3760 void sp_setup_tbl (const char *shared_dir
, char *hcstat
, uint disable
, uint classic
, hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
)
3767 * Initialize hcstats
3770 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3772 u64
*root_stats_ptr
= root_stats_buf
;
3774 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3776 for (i
= 0; i
< SP_PW_MAX
; i
++)
3778 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3780 root_stats_ptr
+= CHARSIZ
;
3783 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3785 u64
*markov_stats_ptr
= markov_stats_buf
;
3787 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3789 for (i
= 0; i
< SP_PW_MAX
; i
++)
3791 for (j
= 0; j
< CHARSIZ
; j
++)
3793 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3795 markov_stats_ptr
+= CHARSIZ
;
3805 char hcstat_tmp
[256] = { 0 };
3807 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3809 hcstat
= hcstat_tmp
;
3812 FILE *fd
= fopen (hcstat
, "rb");
3816 log_error ("%s: %s", hcstat
, strerror (errno
));
3821 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3823 log_error ("%s: Could not load data", hcstat
);
3830 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3832 log_error ("%s: Could not load data", hcstat
);
3842 * Markov modifier of hcstat_table on user request
3847 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
3848 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
3853 /* Add all stats to first position */
3855 for (i
= 1; i
< SP_PW_MAX
; i
++)
3857 u64
*out
= root_stats_buf_by_pos
[0];
3858 u64
*in
= root_stats_buf_by_pos
[i
];
3860 for (j
= 0; j
< CHARSIZ
; j
++)
3866 for (i
= 1; i
< SP_PW_MAX
; i
++)
3868 u64
*out
= markov_stats_buf_by_key
[0][0];
3869 u64
*in
= markov_stats_buf_by_key
[i
][0];
3871 for (j
= 0; j
< CHARSIZ
; j
++)
3873 for (k
= 0; k
< CHARSIZ
; k
++)
3880 /* copy them to all pw_positions */
3882 for (i
= 1; i
< SP_PW_MAX
; i
++)
3884 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
3887 for (i
= 1; i
< SP_PW_MAX
; i
++)
3889 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
3897 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3899 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3901 for (i
= 0; i
< SP_PW_MAX
; i
++)
3903 root_table_buf_by_pos
[i
] = root_table_ptr
;
3905 root_table_ptr
+= CHARSIZ
;
3908 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3910 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3912 for (i
= 0; i
< SP_PW_MAX
; i
++)
3914 for (j
= 0; j
< CHARSIZ
; j
++)
3916 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3918 markov_table_ptr
+= CHARSIZ
;
3923 * Convert hcstat to tables
3926 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3928 uint key
= i
% CHARSIZ
;
3930 root_table_buf
[i
].key
= key
;
3931 root_table_buf
[i
].val
= root_stats_buf
[i
];
3934 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3936 uint key
= i
% CHARSIZ
;
3938 markov_table_buf
[i
].key
= key
;
3939 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3942 myfree (root_stats_buf
);
3943 myfree (markov_stats_buf
);
3949 for (i
= 0; i
< SP_PW_MAX
; i
++)
3951 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3954 for (i
= 0; i
< SP_PW_MAX
; i
++)
3956 for (j
= 0; j
< CHARSIZ
; j
++)
3958 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3963 void sp_tbl_to_css (hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint threshold
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3966 * Convert tables to css
3969 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
3971 uint pw_pos
= i
/ CHARSIZ
;
3973 cs_t
*cs
= &root_css_buf
[pw_pos
];
3975 if (cs
->cs_len
== threshold
) continue;
3977 uint key
= root_table_buf
[i
].key
;
3979 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
3981 cs
->cs_buf
[cs
->cs_len
] = key
;
3987 * Convert table to css
3990 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
3992 uint c
= i
/ CHARSIZ
;
3994 cs_t
*cs
= &markov_css_buf
[c
];
3996 if (cs
->cs_len
== threshold
) continue;
3998 uint pw_pos
= c
/ CHARSIZ
;
4000 uint key
= markov_table_buf
[i
].key
;
4002 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4004 cs
->cs_buf
[cs
->cs_len
] = key
;
4010 for (uint i = 0; i < 8; i++)
4012 for (uint j = 0x20; j < 0x80; j++)
4014 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4016 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4018 for (uint k = 0; k < 10; k++)
4020 printf (" %u\n", ptr->cs_buf[k]);
4027 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4029 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4031 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4041 for (uint j
= 1; j
< CHARSIZ
; j
++)
4051 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4053 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4055 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4057 out
+= CHARSIZ
* CHARSIZ
;
4058 in
+= CHARSIZ
* CHARSIZ
;
4060 for (uint j
= 0; j
< CHARSIZ
; j
++)
4067 for (uint k
= 1; k
< CHARSIZ
; k
++)
4079 * mixed shared functions
4082 void dump_hex (const u8
*s
, const int sz
)
4084 for (int i
= 0; i
< sz
; i
++)
4086 log_info_nn ("%02x ", s
[i
]);
4092 void usage_mini_print (const char *progname
)
4094 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4097 void usage_big_print (const char *progname
)
4099 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4102 char *get_exec_path ()
4104 int exec_path_len
= 1024;
4106 char *exec_path
= (char *) mymalloc (exec_path_len
);
4110 char tmp
[32] = { 0 };
4112 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4114 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4118 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4122 uint size
= exec_path_len
;
4124 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4126 log_error("! executable path buffer too small\n");
4131 const int len
= strlen (exec_path
);
4134 #error Your Operating System is not supported or detected
4142 char *get_install_dir (const char *progname
)
4144 char *install_dir
= mystrdup (progname
);
4145 char *last_slash
= NULL
;
4147 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4151 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4157 install_dir
[0] = '.';
4161 return (install_dir
);
4164 char *get_profile_dir (const char *homedir
)
4166 #define DOT_HASHCAT ".hashcat"
4168 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4170 char *profile_dir
= (char *) mymalloc (len
+ 1);
4172 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4177 char *get_session_dir (const char *profile_dir
)
4179 #define SESSIONS_FOLDER "sessions"
4181 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4183 char *session_dir
= (char *) mymalloc (len
+ 1);
4185 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4190 uint
count_lines (FILE *fd
)
4194 char *buf
= (char *) mymalloc (BUFSIZ
+ 1);
4200 size_t nread
= fread (buf
, sizeof (char), BUFSIZ
, fd
);
4202 if (nread
< 1) continue;
4206 for (i
= 0; i
< nread
; i
++)
4208 if (prev
== '\n') cnt
++;
4219 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4223 FILE *fd
= fopen (filename
, "rb");
4227 log_error ("%s: %s", filename
, strerror (errno
));
4232 #define MAX_KEY_SIZE (1024 * 1024)
4234 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4236 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4242 for (int fpos
= 0; fpos
< nread
; fpos
++)
4244 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4246 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4247 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4248 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4249 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4251 if (kpos
>= 64) kpos
= 0;
4258 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4262 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4263 if (CPU_ISSET(core
, cpu_set
)) break;
4265 thread_affinity_policy_data_t policy
= { core
};
4267 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4269 if (data
.quiet
== 0)
4271 if (rc
!= KERN_SUCCESS
)
4273 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4281 void set_cpu_affinity (char *cpu_affinity
)
4284 DWORD_PTR aff_mask
= 0;
4292 char *devices
= strdup (cpu_affinity
);
4294 char *next
= strtok (devices
, ",");
4298 uint cpu_id
= atoi (next
);
4313 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4319 aff_mask
|= 1 << (cpu_id
- 1);
4321 CPU_SET ((cpu_id
- 1), &cpuset
);
4324 } while ((next
= strtok (NULL
, ",")) != NULL
);
4330 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4331 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4333 pthread_t thread
= pthread_self ();
4334 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4338 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4340 char *element
, *end
;
4342 end
= (char *) base
+ nmemb
* size
;
4344 for (element
= (char *) base
; element
< end
; element
+= size
)
4345 if (!compar (element
, key
))
4351 int sort_by_salt (const void *v1
, const void *v2
)
4353 const salt_t
*s1
= (const salt_t
*) v1
;
4354 const salt_t
*s2
= (const salt_t
*) v2
;
4356 const int res1
= s1
->salt_len
- s2
->salt_len
;
4358 if (res1
!= 0) return (res1
);
4360 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4362 if (res2
!= 0) return (res2
);
4370 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4371 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4378 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4379 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4385 int sort_by_salt_buf (const void *v1
, const void *v2
)
4387 const pot_t
*p1
= (const pot_t
*) v1
;
4388 const pot_t
*p2
= (const pot_t
*) v2
;
4390 const hash_t
*h1
= &p1
->hash
;
4391 const hash_t
*h2
= &p2
->hash
;
4393 const salt_t
*s1
= h1
->salt
;
4394 const salt_t
*s2
= h2
->salt
;
4400 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4401 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4407 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4409 const hash_t
*h1
= (const hash_t
*) v1
;
4410 const hash_t
*h2
= (const hash_t
*) v2
;
4412 const salt_t
*s1
= h1
->salt
;
4413 const salt_t
*s2
= h2
->salt
;
4415 // testphase: this should work
4420 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4421 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4424 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4425 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4426 if (s1->salt_len > s2->salt_len) return ( 1);
4427 if (s1->salt_len < s2->salt_len) return (-1);
4429 uint n = s1->salt_len;
4433 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4434 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4441 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4443 const hash_t
*h1
= (const hash_t
*) v1
;
4444 const hash_t
*h2
= (const hash_t
*) v2
;
4446 const salt_t
*s1
= h1
->salt
;
4447 const salt_t
*s2
= h2
->salt
;
4449 // 16 - 2 (since last 2 uints contain the digest)
4454 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4455 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4461 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4463 const hash_t
*h1
= (const hash_t
*) v1
;
4464 const hash_t
*h2
= (const hash_t
*) v2
;
4466 const void *d1
= h1
->digest
;
4467 const void *d2
= h2
->digest
;
4469 return data
.sort_by_digest (d1
, d2
);
4472 int sort_by_hash (const void *v1
, const void *v2
)
4474 const hash_t
*h1
= (const hash_t
*) v1
;
4475 const hash_t
*h2
= (const hash_t
*) v2
;
4479 const salt_t
*s1
= h1
->salt
;
4480 const salt_t
*s2
= h2
->salt
;
4482 int res
= sort_by_salt (s1
, s2
);
4484 if (res
!= 0) return (res
);
4487 const void *d1
= h1
->digest
;
4488 const void *d2
= h2
->digest
;
4490 return data
.sort_by_digest (d1
, d2
);
4493 int sort_by_pot (const void *v1
, const void *v2
)
4495 const pot_t
*p1
= (const pot_t
*) v1
;
4496 const pot_t
*p2
= (const pot_t
*) v2
;
4498 const hash_t
*h1
= &p1
->hash
;
4499 const hash_t
*h2
= &p2
->hash
;
4501 return sort_by_hash (h1
, h2
);
4504 int sort_by_mtime (const void *p1
, const void *p2
)
4506 const char **f1
= (const char **) p1
;
4507 const char **f2
= (const char **) p2
;
4509 struct stat s1
; stat (*f1
, &s1
);
4510 struct stat s2
; stat (*f2
, &s2
);
4512 return s2
.st_mtime
- s1
.st_mtime
;
4515 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4517 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4518 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4520 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4523 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4525 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4526 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4528 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4531 int sort_by_stringptr (const void *p1
, const void *p2
)
4533 const char **s1
= (const char **) p1
;
4534 const char **s2
= (const char **) p2
;
4536 return strcmp (*s1
, *s2
);
4539 int sort_by_dictstat (const void *s1
, const void *s2
)
4541 dictstat_t
*d1
= (dictstat_t
*) s1
;
4542 dictstat_t
*d2
= (dictstat_t
*) s2
;
4545 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4547 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4550 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4553 int sort_by_bitmap (const void *p1
, const void *p2
)
4555 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4556 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4558 return b1
->collisions
- b2
->collisions
;
4561 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4563 const u32
*d1
= (const u32
*) v1
;
4564 const u32
*d2
= (const u32
*) v2
;
4570 if (d1
[n
] > d2
[n
]) return ( 1);
4571 if (d1
[n
] < d2
[n
]) return (-1);
4577 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4579 const u32
*d1
= (const u32
*) v1
;
4580 const u32
*d2
= (const u32
*) v2
;
4586 if (d1
[n
] > d2
[n
]) return ( 1);
4587 if (d1
[n
] < d2
[n
]) return (-1);
4593 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4595 const u32
*d1
= (const u32
*) v1
;
4596 const u32
*d2
= (const u32
*) v2
;
4602 if (d1
[n
] > d2
[n
]) return ( 1);
4603 if (d1
[n
] < d2
[n
]) return (-1);
4609 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4611 const u32
*d1
= (const u32
*) v1
;
4612 const u32
*d2
= (const u32
*) v2
;
4618 if (d1
[n
] > d2
[n
]) return ( 1);
4619 if (d1
[n
] < d2
[n
]) return (-1);
4625 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4627 const u32
*d1
= (const u32
*) v1
;
4628 const u32
*d2
= (const u32
*) v2
;
4634 if (d1
[n
] > d2
[n
]) return ( 1);
4635 if (d1
[n
] < d2
[n
]) return (-1);
4641 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4643 const u32
*d1
= (const u32
*) v1
;
4644 const u32
*d2
= (const u32
*) v2
;
4650 if (d1
[n
] > d2
[n
]) return ( 1);
4651 if (d1
[n
] < d2
[n
]) return (-1);
4657 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4659 const u32
*d1
= (const u32
*) v1
;
4660 const u32
*d2
= (const u32
*) v2
;
4666 if (d1
[n
] > d2
[n
]) return ( 1);
4667 if (d1
[n
] < d2
[n
]) return (-1);
4673 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4675 const u32
*d1
= (const u32
*) v1
;
4676 const u32
*d2
= (const u32
*) v2
;
4682 if (d1
[n
] > d2
[n
]) return ( 1);
4683 if (d1
[n
] < d2
[n
]) return (-1);
4689 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4691 const u64
*d1
= (const u64
*) v1
;
4692 const u64
*d2
= (const u64
*) v2
;
4698 if (d1
[n
] > d2
[n
]) return ( 1);
4699 if (d1
[n
] < d2
[n
]) return (-1);
4705 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4707 const u64
*d1
= (const u64
*) v1
;
4708 const u64
*d2
= (const u64
*) v2
;
4714 if (d1
[n
] > d2
[n
]) return ( 1);
4715 if (d1
[n
] < d2
[n
]) return (-1);
4721 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4723 const u64
*d1
= (const u64
*) v1
;
4724 const u64
*d2
= (const u64
*) v2
;
4730 if (d1
[n
] > d2
[n
]) return ( 1);
4731 if (d1
[n
] < d2
[n
]) return (-1);
4737 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4739 const u32
*d1
= (const u32
*) v1
;
4740 const u32
*d2
= (const u32
*) v2
;
4742 const uint dgst_pos0
= data
.dgst_pos0
;
4743 const uint dgst_pos1
= data
.dgst_pos1
;
4744 const uint dgst_pos2
= data
.dgst_pos2
;
4745 const uint dgst_pos3
= data
.dgst_pos3
;
4747 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4748 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4749 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4750 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4751 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4752 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4753 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4754 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4759 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4761 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4762 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4764 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4766 if (res1
!= 0) return (res1
);
4771 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4773 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4774 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4776 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4778 if (res1
!= 0) return (res1
);
4780 const int res2
= t1
->attack_mode
4783 if (res2
!= 0) return (res2
);
4785 const int res3
= t1
->hash_type
4788 if (res3
!= 0) return (res3
);
4793 void format_debug (char *debug_file
, uint debug_mode
, unsigned char *orig_plain_ptr
, uint orig_plain_len
, unsigned char *mod_plain_ptr
, uint mod_plain_len
, char *rule_buf
, int rule_len
)
4795 uint outfile_autohex
= data
.outfile_autohex
;
4797 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4799 FILE *debug_fp
= NULL
;
4801 if (debug_file
!= NULL
)
4803 debug_fp
= fopen (debug_file
, "ab");
4805 lock_file (debug_fp
);
4812 if (debug_fp
== NULL
)
4814 log_info ("WARNING: Could not open debug-file for writing");
4818 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4820 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4822 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4825 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4827 if (debug_mode
== 4)
4829 fputc (':', debug_fp
);
4831 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4834 fputc ('\n', debug_fp
);
4836 if (debug_file
!= NULL
) fclose (debug_fp
);
4840 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4842 int needs_hexify
= 0;
4844 if (outfile_autohex
== 1)
4846 for (uint i
= 0; i
< plain_len
; i
++)
4848 if (plain_ptr
[i
] < 0x20)
4855 if (plain_ptr
[i
] > 0x7f)
4864 if (needs_hexify
== 1)
4866 fprintf (fp
, "$HEX[");
4868 for (uint i
= 0; i
< plain_len
; i
++)
4870 fprintf (fp
, "%02x", plain_ptr
[i
]);
4877 fwrite (plain_ptr
, plain_len
, 1, fp
);
4881 void format_output (FILE *out_fp
, char *out_buf
, unsigned char *plain_ptr
, const uint plain_len
, const u64 crackpos
, unsigned char *username
, const uint user_len
)
4883 uint outfile_format
= data
.outfile_format
;
4885 char separator
= data
.separator
;
4887 if (outfile_format
& OUTFILE_FMT_HASH
)
4889 fprintf (out_fp
, "%s", out_buf
);
4891 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4893 fputc (separator
, out_fp
);
4896 else if (data
.username
)
4898 if (username
!= NULL
)
4900 for (uint i
= 0; i
< user_len
; i
++)
4902 fprintf (out_fp
, "%c", username
[i
]);
4905 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4907 fputc (separator
, out_fp
);
4912 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4914 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4916 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4918 fputc (separator
, out_fp
);
4922 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4924 for (uint i
= 0; i
< plain_len
; i
++)
4926 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4929 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4931 fputc (separator
, out_fp
);
4935 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4938 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4943 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
4945 fprintf (out_fp
, "%llu", crackpos
);
4950 fputc ('\n', out_fp
);
4953 void handle_show_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
4957 pot_key
.hash
.salt
= hashes_buf
->salt
;
4958 pot_key
.hash
.digest
= hashes_buf
->digest
;
4960 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4966 input_buf
[input_len
] = 0;
4969 unsigned char *username
= NULL
;
4974 user_t
*user
= hashes_buf
->hash_info
->user
;
4978 username
= (unsigned char *) (user
->user_name
);
4980 user_len
= user
->user_len
;
4984 // do output the line
4985 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
4989 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
4990 #define LM_MASKED_PLAIN "[notfound]"
4992 void handle_show_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
4998 pot_left_key
.hash
.salt
= hash_left
->salt
;
4999 pot_left_key
.hash
.digest
= hash_left
->digest
;
5001 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5005 uint weak_hash_found
= 0;
5007 pot_t pot_right_key
;
5009 pot_right_key
.hash
.salt
= hash_right
->salt
;
5010 pot_right_key
.hash
.digest
= hash_right
->digest
;
5012 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5014 if (pot_right_ptr
== NULL
)
5016 // special case, if "weak hash"
5018 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5020 weak_hash_found
= 1;
5022 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5024 // in theory this is not needed, but we are paranoia:
5026 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5027 pot_right_ptr
->plain_len
= 0;
5031 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5033 if (weak_hash_found
== 1) myfree (pot_right_ptr
); // this shouldn't happen at all: if weak_hash_found == 1, than pot_right_ptr is not NULL for sure
5038 // at least one half was found:
5042 input_buf
[input_len
] = 0;
5046 unsigned char *username
= NULL
;
5051 user_t
*user
= hash_left
->hash_info
->user
;
5055 username
= (unsigned char *) (user
->user_name
);
5057 user_len
= user
->user_len
;
5061 // mask the part which was not found
5063 uint left_part_masked
= 0;
5064 uint right_part_masked
= 0;
5066 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5068 if (pot_left_ptr
== NULL
)
5070 left_part_masked
= 1;
5072 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5074 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5076 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5077 pot_left_ptr
->plain_len
= mask_plain_len
;
5080 if (pot_right_ptr
== NULL
)
5082 right_part_masked
= 1;
5084 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5086 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5088 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5089 pot_right_ptr
->plain_len
= mask_plain_len
;
5092 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5096 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5098 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5100 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5102 // do output the line
5104 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5106 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5108 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5109 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5112 void handle_left_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5116 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5118 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5120 if (pot_ptr
== NULL
)
5124 input_buf
[input_len
] = 0;
5126 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5130 void handle_left_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5136 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5138 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5142 pot_t pot_right_key
;
5144 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5146 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5148 uint weak_hash_found
= 0;
5150 if (pot_right_ptr
== NULL
)
5152 // special case, if "weak hash"
5154 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5156 weak_hash_found
= 1;
5158 // we just need that pot_right_ptr is not a NULL pointer
5160 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5164 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5166 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5171 // ... at least one part was not cracked
5175 input_buf
[input_len
] = 0;
5177 // only show the hash part which is still not cracked
5179 uint user_len
= input_len
- 32;
5181 char *hash_output
= (char *) mymalloc (33);
5183 memcpy (hash_output
, input_buf
, input_len
);
5185 if (pot_left_ptr
!= NULL
)
5187 // only show right part (because left part was already found)
5189 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5191 hash_output
[user_len
+ 16] = 0;
5194 if (pot_right_ptr
!= NULL
)
5196 // only show left part (because right part was already found)
5198 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5200 hash_output
[user_len
+ 16] = 0;
5203 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5205 myfree (hash_output
);
5207 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5210 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5212 uint opencl_platforms_filter
= 0;
5214 if (opencl_platforms
)
5216 char *platforms
= strdup (opencl_platforms
);
5218 char *next
= strtok (platforms
, ",");
5222 int platform
= atoi (next
);
5224 if (platform
< 1 || platform
> 32)
5226 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5231 opencl_platforms_filter
|= 1 << (platform
- 1);
5233 } while ((next
= strtok (NULL
, ",")) != NULL
);
5239 opencl_platforms_filter
= -1;
5242 return opencl_platforms_filter
;
5245 u32
setup_devices_filter (char *opencl_devices
)
5247 u32 devices_filter
= 0;
5251 char *devices
= strdup (opencl_devices
);
5253 char *next
= strtok (devices
, ",");
5257 int device_id
= atoi (next
);
5259 if (device_id
< 1 || device_id
> 32)
5261 log_error ("ERROR: invalid device_id %u specified", device_id
);
5266 devices_filter
|= 1 << (device_id
- 1);
5268 } while ((next
= strtok (NULL
, ",")) != NULL
);
5274 devices_filter
= -1;
5277 return devices_filter
;
5280 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5282 cl_device_type device_types_filter
= 0;
5284 if (opencl_device_types
)
5286 char *device_types
= strdup (opencl_device_types
);
5288 char *next
= strtok (device_types
, ",");
5292 int device_type
= atoi (next
);
5294 if (device_type
< 1 || device_type
> 3)
5296 log_error ("ERROR: invalid device_type %u specified", device_type
);
5301 device_types_filter
|= 1 << device_type
;
5303 } while ((next
= strtok (NULL
, ",")) != NULL
);
5305 free (device_types
);
5309 // Do not use CPU by default, this often reduces GPU performance because
5310 // the CPU is too busy to handle GPU synchronization
5312 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5315 return device_types_filter
;
5318 u32
get_random_num (const u32 min
, const u32 max
)
5320 if (min
== max
) return (min
);
5322 return ((rand () % (max
- min
)) + min
);
5325 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5327 u32 quotient
= dividend
/ divisor
;
5329 if (dividend
% divisor
) quotient
++;
5334 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5336 u64 quotient
= dividend
/ divisor
;
5338 if (dividend
% divisor
) quotient
++;
5343 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5345 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5346 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5348 if (tm
->tm_year
- 70)
5350 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5351 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5353 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5355 else if (tm
->tm_yday
)
5357 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5358 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5360 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5362 else if (tm
->tm_hour
)
5364 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5365 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5367 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5369 else if (tm
->tm_min
)
5371 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5372 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5374 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5378 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5380 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5384 void format_speed_display (float val
, char *buf
, size_t len
)
5395 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5406 /* generate output */
5410 snprintf (buf
, len
- 1, "%.0f ", val
);
5414 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5418 void lowercase (u8
*buf
, int len
)
5420 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5423 void uppercase (u8
*buf
, int len
)
5425 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5428 int fgetl (FILE *fp
, char *line_buf
)
5434 const int c
= fgetc (fp
);
5436 if (c
== EOF
) break;
5438 line_buf
[line_len
] = (char) c
;
5442 if (line_len
== BUFSIZ
) line_len
--;
5444 if (c
== '\n') break;
5447 if (line_len
== 0) return 0;
5449 if (line_buf
[line_len
- 1] == '\n')
5453 line_buf
[line_len
] = 0;
5456 if (line_len
== 0) return 0;
5458 if (line_buf
[line_len
- 1] == '\r')
5462 line_buf
[line_len
] = 0;
5468 int in_superchop (char *buf
)
5470 int len
= strlen (buf
);
5474 if (buf
[len
- 1] == '\n')
5481 if (buf
[len
- 1] == '\r')
5496 char **scan_directory (const char *path
)
5498 char *tmp_path
= mystrdup (path
);
5500 size_t tmp_path_len
= strlen (tmp_path
);
5502 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5504 tmp_path
[tmp_path_len
- 1] = 0;
5506 tmp_path_len
= strlen (tmp_path
);
5509 char **files
= NULL
;
5515 if ((d
= opendir (tmp_path
)) != NULL
)
5521 memset (&e
, 0, sizeof (e
));
5522 struct dirent
*de
= NULL
;
5524 if (readdir_r (d
, &e
, &de
) != 0)
5526 log_error ("ERROR: readdir_r() failed");
5531 if (de
== NULL
) break;
5535 while ((de
= readdir (d
)) != NULL
)
5538 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5540 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5542 char *path_file
= (char *) mymalloc (path_size
+ 1);
5544 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5546 path_file
[path_size
] = 0;
5550 if ((d_test
= opendir (path_file
)) != NULL
)
5558 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5562 files
[num_files
- 1] = path_file
;
5568 else if (errno
== ENOTDIR
)
5570 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5574 files
[num_files
- 1] = mystrdup (path
);
5577 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5581 files
[num_files
- 1] = NULL
;
5588 int count_dictionaries (char **dictionary_files
)
5590 if (dictionary_files
== NULL
) return 0;
5594 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5602 char *stroptitype (const uint opti_type
)
5606 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5607 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5608 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5609 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5610 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5611 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5612 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5613 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5614 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5615 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5616 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5617 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5618 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5619 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5620 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5621 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5622 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5623 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5629 char *strparser (const uint parser_status
)
5631 switch (parser_status
)
5633 case PARSER_OK
: return ((char *) PA_000
); break;
5634 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5635 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5636 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5637 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5638 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5639 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5640 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5641 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5642 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5643 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5644 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5645 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5646 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5647 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5648 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5649 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5652 return ((char *) PA_255
);
5655 char *strhashtype (const uint hash_mode
)
5659 case 0: return ((char *) HT_00000
); break;
5660 case 10: return ((char *) HT_00010
); break;
5661 case 11: return ((char *) HT_00011
); break;
5662 case 12: return ((char *) HT_00012
); break;
5663 case 20: return ((char *) HT_00020
); break;
5664 case 21: return ((char *) HT_00021
); break;
5665 case 22: return ((char *) HT_00022
); break;
5666 case 23: return ((char *) HT_00023
); break;
5667 case 30: return ((char *) HT_00030
); break;
5668 case 40: return ((char *) HT_00040
); break;
5669 case 50: return ((char *) HT_00050
); break;
5670 case 60: return ((char *) HT_00060
); break;
5671 case 100: return ((char *) HT_00100
); break;
5672 case 101: return ((char *) HT_00101
); break;
5673 case 110: return ((char *) HT_00110
); break;
5674 case 111: return ((char *) HT_00111
); break;
5675 case 112: return ((char *) HT_00112
); break;
5676 case 120: return ((char *) HT_00120
); break;
5677 case 121: return ((char *) HT_00121
); break;
5678 case 122: return ((char *) HT_00122
); break;
5679 case 124: return ((char *) HT_00124
); break;
5680 case 130: return ((char *) HT_00130
); break;
5681 case 131: return ((char *) HT_00131
); break;
5682 case 132: return ((char *) HT_00132
); break;
5683 case 133: return ((char *) HT_00133
); break;
5684 case 140: return ((char *) HT_00140
); break;
5685 case 141: return ((char *) HT_00141
); break;
5686 case 150: return ((char *) HT_00150
); break;
5687 case 160: return ((char *) HT_00160
); break;
5688 case 190: return ((char *) HT_00190
); break;
5689 case 200: return ((char *) HT_00200
); break;
5690 case 300: return ((char *) HT_00300
); break;
5691 case 400: return ((char *) HT_00400
); break;
5692 case 500: return ((char *) HT_00500
); break;
5693 case 501: return ((char *) HT_00501
); break;
5694 case 900: return ((char *) HT_00900
); break;
5695 case 910: return ((char *) HT_00910
); break;
5696 case 1000: return ((char *) HT_01000
); break;
5697 case 1100: return ((char *) HT_01100
); break;
5698 case 1400: return ((char *) HT_01400
); break;
5699 case 1410: return ((char *) HT_01410
); break;
5700 case 1420: return ((char *) HT_01420
); break;
5701 case 1421: return ((char *) HT_01421
); break;
5702 case 1430: return ((char *) HT_01430
); break;
5703 case 1440: return ((char *) HT_01440
); break;
5704 case 1441: return ((char *) HT_01441
); break;
5705 case 1450: return ((char *) HT_01450
); break;
5706 case 1460: return ((char *) HT_01460
); break;
5707 case 1500: return ((char *) HT_01500
); break;
5708 case 1600: return ((char *) HT_01600
); break;
5709 case 1700: return ((char *) HT_01700
); break;
5710 case 1710: return ((char *) HT_01710
); break;
5711 case 1711: return ((char *) HT_01711
); break;
5712 case 1720: return ((char *) HT_01720
); break;
5713 case 1722: return ((char *) HT_01722
); break;
5714 case 1730: return ((char *) HT_01730
); break;
5715 case 1731: return ((char *) HT_01731
); break;
5716 case 1740: return ((char *) HT_01740
); break;
5717 case 1750: return ((char *) HT_01750
); break;
5718 case 1760: return ((char *) HT_01760
); break;
5719 case 1800: return ((char *) HT_01800
); break;
5720 case 2100: return ((char *) HT_02100
); break;
5721 case 2400: return ((char *) HT_02400
); break;
5722 case 2410: return ((char *) HT_02410
); break;
5723 case 2500: return ((char *) HT_02500
); break;
5724 case 2600: return ((char *) HT_02600
); break;
5725 case 2611: return ((char *) HT_02611
); break;
5726 case 2612: return ((char *) HT_02612
); break;
5727 case 2711: return ((char *) HT_02711
); break;
5728 case 2811: return ((char *) HT_02811
); break;
5729 case 3000: return ((char *) HT_03000
); break;
5730 case 3100: return ((char *) HT_03100
); break;
5731 case 3200: return ((char *) HT_03200
); break;
5732 case 3710: return ((char *) HT_03710
); break;
5733 case 3711: return ((char *) HT_03711
); break;
5734 case 3800: return ((char *) HT_03800
); break;
5735 case 4300: return ((char *) HT_04300
); break;
5736 case 4400: return ((char *) HT_04400
); break;
5737 case 4500: return ((char *) HT_04500
); break;
5738 case 4700: return ((char *) HT_04700
); break;
5739 case 4800: return ((char *) HT_04800
); break;
5740 case 4900: return ((char *) HT_04900
); break;
5741 case 5000: return ((char *) HT_05000
); break;
5742 case 5100: return ((char *) HT_05100
); break;
5743 case 5200: return ((char *) HT_05200
); break;
5744 case 5300: return ((char *) HT_05300
); break;
5745 case 5400: return ((char *) HT_05400
); break;
5746 case 5500: return ((char *) HT_05500
); break;
5747 case 5600: return ((char *) HT_05600
); break;
5748 case 5700: return ((char *) HT_05700
); break;
5749 case 5800: return ((char *) HT_05800
); break;
5750 case 6000: return ((char *) HT_06000
); break;
5751 case 6100: return ((char *) HT_06100
); break;
5752 case 6211: return ((char *) HT_06211
); break;
5753 case 6212: return ((char *) HT_06212
); break;
5754 case 6213: return ((char *) HT_06213
); break;
5755 case 6221: return ((char *) HT_06221
); break;
5756 case 6222: return ((char *) HT_06222
); break;
5757 case 6223: return ((char *) HT_06223
); break;
5758 case 6231: return ((char *) HT_06231
); break;
5759 case 6232: return ((char *) HT_06232
); break;
5760 case 6233: return ((char *) HT_06233
); break;
5761 case 6241: return ((char *) HT_06241
); break;
5762 case 6242: return ((char *) HT_06242
); break;
5763 case 6243: return ((char *) HT_06243
); break;
5764 case 6300: return ((char *) HT_06300
); break;
5765 case 6400: return ((char *) HT_06400
); break;
5766 case 6500: return ((char *) HT_06500
); break;
5767 case 6600: return ((char *) HT_06600
); break;
5768 case 6700: return ((char *) HT_06700
); break;
5769 case 6800: return ((char *) HT_06800
); break;
5770 case 6900: return ((char *) HT_06900
); break;
5771 case 7100: return ((char *) HT_07100
); break;
5772 case 7200: return ((char *) HT_07200
); break;
5773 case 7300: return ((char *) HT_07300
); break;
5774 case 7400: return ((char *) HT_07400
); break;
5775 case 7500: return ((char *) HT_07500
); break;
5776 case 7600: return ((char *) HT_07600
); break;
5777 case 7700: return ((char *) HT_07700
); break;
5778 case 7800: return ((char *) HT_07800
); break;
5779 case 7900: return ((char *) HT_07900
); break;
5780 case 8000: return ((char *) HT_08000
); break;
5781 case 8100: return ((char *) HT_08100
); break;
5782 case 8200: return ((char *) HT_08200
); break;
5783 case 8300: return ((char *) HT_08300
); break;
5784 case 8400: return ((char *) HT_08400
); break;
5785 case 8500: return ((char *) HT_08500
); break;
5786 case 8600: return ((char *) HT_08600
); break;
5787 case 8700: return ((char *) HT_08700
); break;
5788 case 8800: return ((char *) HT_08800
); break;
5789 case 8900: return ((char *) HT_08900
); break;
5790 case 9000: return ((char *) HT_09000
); break;
5791 case 9100: return ((char *) HT_09100
); break;
5792 case 9200: return ((char *) HT_09200
); break;
5793 case 9300: return ((char *) HT_09300
); break;
5794 case 9400: return ((char *) HT_09400
); break;
5795 case 9500: return ((char *) HT_09500
); break;
5796 case 9600: return ((char *) HT_09600
); break;
5797 case 9700: return ((char *) HT_09700
); break;
5798 case 9710: return ((char *) HT_09710
); break;
5799 case 9720: return ((char *) HT_09720
); break;
5800 case 9800: return ((char *) HT_09800
); break;
5801 case 9810: return ((char *) HT_09810
); break;
5802 case 9820: return ((char *) HT_09820
); break;
5803 case 9900: return ((char *) HT_09900
); break;
5804 case 10000: return ((char *) HT_10000
); break;
5805 case 10100: return ((char *) HT_10100
); break;
5806 case 10200: return ((char *) HT_10200
); break;
5807 case 10300: return ((char *) HT_10300
); break;
5808 case 10400: return ((char *) HT_10400
); break;
5809 case 10410: return ((char *) HT_10410
); break;
5810 case 10420: return ((char *) HT_10420
); break;
5811 case 10500: return ((char *) HT_10500
); break;
5812 case 10600: return ((char *) HT_10600
); break;
5813 case 10700: return ((char *) HT_10700
); break;
5814 case 10800: return ((char *) HT_10800
); break;
5815 case 10900: return ((char *) HT_10900
); break;
5816 case 11000: return ((char *) HT_11000
); break;
5817 case 11100: return ((char *) HT_11100
); break;
5818 case 11200: return ((char *) HT_11200
); break;
5819 case 11300: return ((char *) HT_11300
); break;
5820 case 11400: return ((char *) HT_11400
); break;
5821 case 11500: return ((char *) HT_11500
); break;
5822 case 11600: return ((char *) HT_11600
); break;
5823 case 11700: return ((char *) HT_11700
); break;
5824 case 11800: return ((char *) HT_11800
); break;
5825 case 11900: return ((char *) HT_11900
); break;
5826 case 12000: return ((char *) HT_12000
); break;
5827 case 12100: return ((char *) HT_12100
); break;
5828 case 12200: return ((char *) HT_12200
); break;
5829 case 12300: return ((char *) HT_12300
); break;
5830 case 12400: return ((char *) HT_12400
); break;
5831 case 12500: return ((char *) HT_12500
); break;
5832 case 12600: return ((char *) HT_12600
); break;
5833 case 12700: return ((char *) HT_12700
); break;
5834 case 12800: return ((char *) HT_12800
); break;
5835 case 12900: return ((char *) HT_12900
); break;
5836 case 13000: return ((char *) HT_13000
); break;
5839 return ((char *) "Unknown");
5842 char *strstatus (const uint devices_status
)
5844 switch (devices_status
)
5846 case STATUS_INIT
: return ((char *) ST_0000
); break;
5847 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5848 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5849 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5850 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5851 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5852 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5853 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5854 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5855 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5858 return ((char *) "Unknown");
5861 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5863 uint hash_type
= data
.hash_type
;
5864 uint hash_mode
= data
.hash_mode
;
5865 uint salt_type
= data
.salt_type
;
5866 uint opts_type
= data
.opts_type
;
5867 uint opti_type
= data
.opti_type
;
5868 uint dgst_size
= data
.dgst_size
;
5870 char *hashfile
= data
.hashfile
;
5874 uint digest_buf
[64] = { 0 };
5876 u64
*digest_buf64
= (u64
*) digest_buf
;
5878 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5880 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5882 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5888 case HASH_TYPE_DESCRYPT
:
5889 FP (digest_buf
[1], digest_buf
[0], tt
);
5892 case HASH_TYPE_DESRACF
:
5893 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5894 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5896 FP (digest_buf
[1], digest_buf
[0], tt
);
5900 FP (digest_buf
[1], digest_buf
[0], tt
);
5903 case HASH_TYPE_NETNTLM
:
5904 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5905 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5906 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5907 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5909 FP (digest_buf
[1], digest_buf
[0], tt
);
5910 FP (digest_buf
[3], digest_buf
[2], tt
);
5913 case HASH_TYPE_BSDICRYPT
:
5914 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5915 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5917 FP (digest_buf
[1], digest_buf
[0], tt
);
5922 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5927 digest_buf
[0] += MD4M_A
;
5928 digest_buf
[1] += MD4M_B
;
5929 digest_buf
[2] += MD4M_C
;
5930 digest_buf
[3] += MD4M_D
;
5934 digest_buf
[0] += MD5M_A
;
5935 digest_buf
[1] += MD5M_B
;
5936 digest_buf
[2] += MD5M_C
;
5937 digest_buf
[3] += MD5M_D
;
5940 case HASH_TYPE_SHA1
:
5941 digest_buf
[0] += SHA1M_A
;
5942 digest_buf
[1] += SHA1M_B
;
5943 digest_buf
[2] += SHA1M_C
;
5944 digest_buf
[3] += SHA1M_D
;
5945 digest_buf
[4] += SHA1M_E
;
5948 case HASH_TYPE_SHA256
:
5949 digest_buf
[0] += SHA256M_A
;
5950 digest_buf
[1] += SHA256M_B
;
5951 digest_buf
[2] += SHA256M_C
;
5952 digest_buf
[3] += SHA256M_D
;
5953 digest_buf
[4] += SHA256M_E
;
5954 digest_buf
[5] += SHA256M_F
;
5955 digest_buf
[6] += SHA256M_G
;
5956 digest_buf
[7] += SHA256M_H
;
5959 case HASH_TYPE_SHA384
:
5960 digest_buf64
[0] += SHA384M_A
;
5961 digest_buf64
[1] += SHA384M_B
;
5962 digest_buf64
[2] += SHA384M_C
;
5963 digest_buf64
[3] += SHA384M_D
;
5964 digest_buf64
[4] += SHA384M_E
;
5965 digest_buf64
[5] += SHA384M_F
;
5966 digest_buf64
[6] += 0;
5967 digest_buf64
[7] += 0;
5970 case HASH_TYPE_SHA512
:
5971 digest_buf64
[0] += SHA512M_A
;
5972 digest_buf64
[1] += SHA512M_B
;
5973 digest_buf64
[2] += SHA512M_C
;
5974 digest_buf64
[3] += SHA512M_D
;
5975 digest_buf64
[4] += SHA512M_E
;
5976 digest_buf64
[5] += SHA512M_F
;
5977 digest_buf64
[6] += SHA512M_G
;
5978 digest_buf64
[7] += SHA512M_H
;
5983 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
5985 if (dgst_size
== DGST_SIZE_4_2
)
5987 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5989 else if (dgst_size
== DGST_SIZE_4_4
)
5991 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5993 else if (dgst_size
== DGST_SIZE_4_5
)
5995 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5997 else if (dgst_size
== DGST_SIZE_4_6
)
5999 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6001 else if (dgst_size
== DGST_SIZE_4_8
)
6003 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6005 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6007 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6009 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6011 else if (hash_type
== HASH_TYPE_SHA384
)
6013 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6015 else if (hash_type
== HASH_TYPE_SHA512
)
6017 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6019 else if (hash_type
== HASH_TYPE_GOST
)
6021 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6024 else if (dgst_size
== DGST_SIZE_4_64
)
6026 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6028 else if (dgst_size
== DGST_SIZE_8_25
)
6030 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6034 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6035 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6036 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6042 memset (&salt
, 0, sizeof (salt_t
));
6044 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6046 char *ptr
= (char *) salt
.salt_buf
;
6048 uint len
= salt
.salt_len
;
6050 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6056 case HASH_TYPE_NETNTLM
:
6058 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6059 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6061 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6067 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6069 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6077 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6079 uint max
= salt
.salt_len
/ 4;
6083 for (uint i
= 0; i
< max
; i
++)
6085 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6089 if (opts_type
& OPTS_TYPE_ST_HEX
)
6091 char tmp
[64] = { 0 };
6093 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6095 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6100 memcpy (ptr
, tmp
, len
);
6103 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6105 memset (ptr
+ len
, 0, memset_size
);
6107 salt
.salt_len
= len
;
6111 // some modes require special encoding
6114 uint out_buf_plain
[256] = { 0 };
6115 uint out_buf_salt
[256] = { 0 };
6117 char tmp_buf
[1024] = { 0 };
6119 char *ptr_plain
= (char *) out_buf_plain
;
6120 char *ptr_salt
= (char *) out_buf_salt
;
6122 if (hash_mode
== 22)
6124 char username
[30] = { 0 };
6126 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6128 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6130 u16
*ptr
= (u16
*) digest_buf
;
6132 tmp_buf
[ 0] = sig
[0];
6133 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6134 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6135 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6136 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6137 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6138 tmp_buf
[ 6] = sig
[1];
6139 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6140 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6141 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6142 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6143 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6144 tmp_buf
[12] = sig
[2];
6145 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6146 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6147 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6148 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6149 tmp_buf
[17] = sig
[3];
6150 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6151 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6152 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6153 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6154 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6155 tmp_buf
[23] = sig
[4];
6156 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6157 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6158 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6159 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6160 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6161 tmp_buf
[29] = sig
[5];
6163 snprintf (out_buf
, len
-1, "%s:%s",
6167 else if (hash_mode
== 23)
6169 // do not show the \nskyper\n part in output
6171 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6173 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6175 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6182 else if (hash_mode
== 101)
6184 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6186 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6187 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6188 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6189 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6190 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6192 memcpy (tmp_buf
, digest_buf
, 20);
6194 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6196 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6198 else if (hash_mode
== 111)
6200 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6202 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6203 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6204 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6205 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6206 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6208 memcpy (tmp_buf
, digest_buf
, 20);
6209 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6211 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6213 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6215 else if (hash_mode
== 122)
6217 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6218 (char *) salt
.salt_buf
,
6225 else if (hash_mode
== 124)
6227 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6228 (char *) salt
.salt_buf
,
6235 else if (hash_mode
== 131)
6237 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6238 (char *) salt
.salt_buf
,
6246 else if (hash_mode
== 132)
6248 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6249 (char *) salt
.salt_buf
,
6256 else if (hash_mode
== 133)
6258 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6260 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6261 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6262 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6263 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6264 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6266 memcpy (tmp_buf
, digest_buf
, 20);
6268 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6270 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6272 else if (hash_mode
== 141)
6274 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6276 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6278 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6280 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6282 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6283 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6284 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6285 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6286 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6288 memcpy (tmp_buf
, digest_buf
, 20);
6290 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6294 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6296 else if (hash_mode
== 400)
6298 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6300 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6301 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6302 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6303 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6305 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6307 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6309 else if (hash_mode
== 500)
6311 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6313 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6314 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6315 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6316 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6318 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6320 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6322 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6326 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6329 else if (hash_mode
== 501)
6331 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6333 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6334 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6336 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6338 else if (hash_mode
== 1421)
6340 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6342 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6358 else if (hash_mode
== 1441)
6360 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6362 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6364 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6366 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6368 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6369 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6370 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6371 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6372 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6373 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6374 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6375 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6377 memcpy (tmp_buf
, digest_buf
, 32);
6379 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6383 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6385 else if (hash_mode
== 1500)
6387 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6388 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6389 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6390 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6391 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6393 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6395 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6397 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6398 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6400 memcpy (tmp_buf
, digest_buf
, 8);
6402 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6404 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6408 else if (hash_mode
== 1600)
6410 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6412 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6413 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6414 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6415 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6417 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6419 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6421 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6425 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6428 else if (hash_mode
== 1711)
6430 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6432 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6433 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6434 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6435 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6436 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6437 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6438 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6439 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6441 memcpy (tmp_buf
, digest_buf
, 64);
6442 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6444 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6446 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6448 else if (hash_mode
== 1722)
6450 uint
*ptr
= digest_buf
;
6452 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6453 (unsigned char *) salt
.salt_buf
,
6463 else if (hash_mode
== 1731)
6465 uint
*ptr
= digest_buf
;
6467 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6468 (unsigned char *) salt
.salt_buf
,
6478 else if (hash_mode
== 1800)
6482 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6483 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6484 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6485 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6486 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6487 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6488 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6489 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6491 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6493 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6495 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6499 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6502 else if (hash_mode
== 2100)
6506 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6508 salt
.salt_iter
+ 1);
6510 uint signature_len
= strlen (out_buf
);
6512 pos
+= signature_len
;
6513 len
-= signature_len
;
6515 char *salt_ptr
= (char *) salt
.salt_buf
;
6517 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6519 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6520 byte_swap_32 (digest_buf
[0]),
6521 byte_swap_32 (digest_buf
[1]),
6522 byte_swap_32 (digest_buf
[2]),
6523 byte_swap_32 (digest_buf
[3]));
6525 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6527 memcpy (tmp_buf
, digest_buf
, 16);
6529 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6531 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6532 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6533 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6534 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6536 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6537 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6538 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6539 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6541 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6542 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6543 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6544 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6546 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6547 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6548 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6549 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6551 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6552 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6553 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6554 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6558 else if (hash_mode
== 2500)
6560 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6562 wpa_t
*wpa
= &wpas
[salt_pos
];
6564 uint pke
[25] = { 0 };
6566 char *pke_ptr
= (char *) pke
;
6568 for (uint i
= 0; i
< 25; i
++)
6570 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6573 unsigned char mac1
[6] = { 0 };
6574 unsigned char mac2
[6] = { 0 };
6576 memcpy (mac1
, pke_ptr
+ 23, 6);
6577 memcpy (mac2
, pke_ptr
+ 29, 6);
6579 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6580 (char *) salt
.salt_buf
,
6594 else if (hash_mode
== 4400)
6596 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6597 byte_swap_32 (digest_buf
[0]),
6598 byte_swap_32 (digest_buf
[1]),
6599 byte_swap_32 (digest_buf
[2]),
6600 byte_swap_32 (digest_buf
[3]));
6602 else if (hash_mode
== 4700)
6604 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6605 byte_swap_32 (digest_buf
[0]),
6606 byte_swap_32 (digest_buf
[1]),
6607 byte_swap_32 (digest_buf
[2]),
6608 byte_swap_32 (digest_buf
[3]),
6609 byte_swap_32 (digest_buf
[4]));
6611 else if (hash_mode
== 4800)
6613 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6615 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6620 byte_swap_32 (salt
.salt_buf
[0]),
6621 byte_swap_32 (salt
.salt_buf
[1]),
6622 byte_swap_32 (salt
.salt_buf
[2]),
6623 byte_swap_32 (salt
.salt_buf
[3]),
6626 else if (hash_mode
== 4900)
6628 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6629 byte_swap_32 (digest_buf
[0]),
6630 byte_swap_32 (digest_buf
[1]),
6631 byte_swap_32 (digest_buf
[2]),
6632 byte_swap_32 (digest_buf
[3]),
6633 byte_swap_32 (digest_buf
[4]));
6635 else if (hash_mode
== 5100)
6637 snprintf (out_buf
, len
-1, "%08x%08x",
6641 else if (hash_mode
== 5200)
6643 snprintf (out_buf
, len
-1, "%s", hashfile
);
6645 else if (hash_mode
== 5300)
6647 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6649 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6651 int buf_len
= len
-1;
6655 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6657 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6659 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6661 snprintf (out_buf
, buf_len
, ":");
6667 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6675 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6677 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6679 if ((i
== 0) || (i
== 5))
6681 snprintf (out_buf
, buf_len
, ":");
6687 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6695 for (uint i
= 0; i
< 4; i
++)
6699 snprintf (out_buf
, buf_len
, ":");
6705 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6711 else if (hash_mode
== 5400)
6713 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6715 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6717 int buf_len
= len
-1;
6721 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6723 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6725 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6727 snprintf (out_buf
, buf_len
, ":");
6733 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6741 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6743 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6745 if ((i
== 0) || (i
== 5))
6747 snprintf (out_buf
, buf_len
, ":");
6753 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6761 for (uint i
= 0; i
< 5; i
++)
6765 snprintf (out_buf
, buf_len
, ":");
6771 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6777 else if (hash_mode
== 5500)
6779 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6781 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6783 char user_buf
[64] = { 0 };
6784 char domain_buf
[64] = { 0 };
6785 char srvchall_buf
[1024] = { 0 };
6786 char clichall_buf
[1024] = { 0 };
6788 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6790 char *ptr
= (char *) netntlm
->userdomain_buf
;
6792 user_buf
[i
] = ptr
[j
];
6795 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6797 char *ptr
= (char *) netntlm
->userdomain_buf
;
6799 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6802 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6804 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6806 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6809 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6811 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6813 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6816 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6824 byte_swap_32 (salt
.salt_buf_pc
[0]),
6825 byte_swap_32 (salt
.salt_buf_pc
[1]),
6828 else if (hash_mode
== 5600)
6830 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6832 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6834 char user_buf
[64] = { 0 };
6835 char domain_buf
[64] = { 0 };
6836 char srvchall_buf
[1024] = { 0 };
6837 char clichall_buf
[1024] = { 0 };
6839 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6841 char *ptr
= (char *) netntlm
->userdomain_buf
;
6843 user_buf
[i
] = ptr
[j
];
6846 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6848 char *ptr
= (char *) netntlm
->userdomain_buf
;
6850 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6853 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6855 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6857 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6860 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6862 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6864 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6867 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6877 else if (hash_mode
== 5700)
6879 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6881 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6882 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6883 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6884 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6885 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6886 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6887 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6888 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6890 memcpy (tmp_buf
, digest_buf
, 32);
6892 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6896 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6898 else if (hash_mode
== 5800)
6900 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6901 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6902 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6903 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6904 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6906 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6913 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6915 snprintf (out_buf
, len
-1, "%s", hashfile
);
6917 else if (hash_mode
== 6300)
6919 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6921 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6922 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6923 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6924 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6926 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6928 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6930 else if (hash_mode
== 6400)
6932 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6934 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6936 else if (hash_mode
== 6500)
6938 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6940 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6942 else if (hash_mode
== 6600)
6944 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6946 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6948 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6949 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6951 uint buf_len
= len
- 1;
6953 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6956 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6958 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6963 else if (hash_mode
== 6700)
6965 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6967 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6969 else if (hash_mode
== 6800)
6971 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6973 else if (hash_mode
== 7100)
6975 uint
*ptr
= digest_buf
;
6977 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6979 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6981 uint esalt
[8] = { 0 };
6983 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6984 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6985 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6986 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6987 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6988 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6989 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6990 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6992 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",
6993 SIGNATURE_SHA512OSX
,
6995 esalt
[ 0], esalt
[ 1],
6996 esalt
[ 2], esalt
[ 3],
6997 esalt
[ 4], esalt
[ 5],
6998 esalt
[ 6], esalt
[ 7],
7006 ptr
[15], ptr
[14]);
7008 else if (hash_mode
== 7200)
7010 uint
*ptr
= digest_buf
;
7012 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7014 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7018 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7020 len_used
= strlen (out_buf
);
7022 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7024 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7026 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7029 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",
7037 ptr
[15], ptr
[14]);
7039 else if (hash_mode
== 7300)
7041 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7043 rakp_t
*rakp
= &rakps
[salt_pos
];
7045 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7047 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7050 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7057 else if (hash_mode
== 7400)
7059 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7061 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7062 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7063 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7064 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7065 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7066 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7067 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7068 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7070 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7072 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7074 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7078 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7081 else if (hash_mode
== 7500)
7083 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7085 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7087 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7088 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7090 char data
[128] = { 0 };
7092 char *ptr_data
= data
;
7094 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7096 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7099 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7101 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7106 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7108 (char *) krb5pa
->user
,
7109 (char *) krb5pa
->realm
,
7110 (char *) krb5pa
->salt
,
7113 else if (hash_mode
== 7700)
7115 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7116 (char *) salt
.salt_buf
,
7120 else if (hash_mode
== 7800)
7122 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7123 (char *) salt
.salt_buf
,
7130 else if (hash_mode
== 7900)
7132 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7136 char *tmp
= (char *) salt
.salt_buf_pc
;
7138 ptr_plain
[42] = tmp
[0];
7144 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7146 else if (hash_mode
== 8000)
7148 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7149 (unsigned char *) salt
.salt_buf
,
7159 else if (hash_mode
== 8100)
7161 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7162 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7164 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7165 (unsigned char *) salt
.salt_buf
,
7172 else if (hash_mode
== 8200)
7174 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7176 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7178 char data_buf
[4096] = { 0 };
7180 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7182 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7185 data_buf
[cloudkey
->data_len
* 2] = 0;
7187 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7188 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7189 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7190 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7191 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7192 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7193 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7194 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7196 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7197 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7198 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7199 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7201 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7217 else if (hash_mode
== 8300)
7219 char digest_buf_c
[34] = { 0 };
7221 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7223 digest_buf_c
[32] = 0;
7227 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7229 char domain_buf_c
[33] = { 0 };
7231 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7233 for (uint i
= 0; i
< salt_pc_len
; i
++)
7235 const char next
= domain_buf_c
[i
];
7237 domain_buf_c
[i
] = '.';
7242 domain_buf_c
[salt_pc_len
] = 0;
7246 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7248 else if (hash_mode
== 8500)
7250 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7252 else if (hash_mode
== 2612)
7254 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7256 (char *) salt
.salt_buf
,
7262 else if (hash_mode
== 3711)
7264 char *salt_ptr
= (char *) salt
.salt_buf
;
7266 salt_ptr
[salt
.salt_len
- 1] = 0;
7268 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7269 SIGNATURE_MEDIAWIKI_B
,
7276 else if (hash_mode
== 8800)
7278 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7280 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7282 char tmp
[3073] = { 0 };
7284 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7286 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7291 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7292 SIGNATURE_ANDROIDFDE
,
7293 byte_swap_32 (salt
.salt_buf
[0]),
7294 byte_swap_32 (salt
.salt_buf
[1]),
7295 byte_swap_32 (salt
.salt_buf
[2]),
7296 byte_swap_32 (salt
.salt_buf
[3]),
7297 byte_swap_32 (digest_buf
[0]),
7298 byte_swap_32 (digest_buf
[1]),
7299 byte_swap_32 (digest_buf
[2]),
7300 byte_swap_32 (digest_buf
[3]),
7303 else if (hash_mode
== 8900)
7305 uint N
= salt
.scrypt_N
;
7306 uint r
= salt
.scrypt_r
;
7307 uint p
= salt
.scrypt_p
;
7309 char base64_salt
[32] = { 0 };
7311 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7313 memset (tmp_buf
, 0, 46);
7315 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7316 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7317 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7318 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7319 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7320 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7321 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7322 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7323 digest_buf
[8] = 0; // needed for base64_encode ()
7325 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7327 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7335 else if (hash_mode
== 9000)
7337 snprintf (out_buf
, len
-1, "%s", hashfile
);
7339 else if (hash_mode
== 9200)
7343 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7345 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7347 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7351 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7352 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7353 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7354 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7355 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7356 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7357 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7358 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7359 digest_buf
[8] = 0; // needed for base64_encode ()
7361 char tmp_buf
[64] = { 0 };
7363 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7364 tmp_buf
[43] = 0; // cut it here
7368 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7370 else if (hash_mode
== 9300)
7372 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7373 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7374 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7375 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7376 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7377 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7378 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7379 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7380 digest_buf
[8] = 0; // needed for base64_encode ()
7382 char tmp_buf
[64] = { 0 };
7384 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7385 tmp_buf
[43] = 0; // cut it here
7387 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7389 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7391 else if (hash_mode
== 9400)
7393 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7395 office2007_t
*office2007
= &office2007s
[salt_pos
];
7397 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7398 SIGNATURE_OFFICE2007
,
7401 office2007
->keySize
,
7407 office2007
->encryptedVerifier
[0],
7408 office2007
->encryptedVerifier
[1],
7409 office2007
->encryptedVerifier
[2],
7410 office2007
->encryptedVerifier
[3],
7411 office2007
->encryptedVerifierHash
[0],
7412 office2007
->encryptedVerifierHash
[1],
7413 office2007
->encryptedVerifierHash
[2],
7414 office2007
->encryptedVerifierHash
[3],
7415 office2007
->encryptedVerifierHash
[4]);
7417 else if (hash_mode
== 9500)
7419 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7421 office2010_t
*office2010
= &office2010s
[salt_pos
];
7423 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,
7429 office2010
->encryptedVerifier
[0],
7430 office2010
->encryptedVerifier
[1],
7431 office2010
->encryptedVerifier
[2],
7432 office2010
->encryptedVerifier
[3],
7433 office2010
->encryptedVerifierHash
[0],
7434 office2010
->encryptedVerifierHash
[1],
7435 office2010
->encryptedVerifierHash
[2],
7436 office2010
->encryptedVerifierHash
[3],
7437 office2010
->encryptedVerifierHash
[4],
7438 office2010
->encryptedVerifierHash
[5],
7439 office2010
->encryptedVerifierHash
[6],
7440 office2010
->encryptedVerifierHash
[7]);
7442 else if (hash_mode
== 9600)
7444 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7446 office2013_t
*office2013
= &office2013s
[salt_pos
];
7448 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,
7454 office2013
->encryptedVerifier
[0],
7455 office2013
->encryptedVerifier
[1],
7456 office2013
->encryptedVerifier
[2],
7457 office2013
->encryptedVerifier
[3],
7458 office2013
->encryptedVerifierHash
[0],
7459 office2013
->encryptedVerifierHash
[1],
7460 office2013
->encryptedVerifierHash
[2],
7461 office2013
->encryptedVerifierHash
[3],
7462 office2013
->encryptedVerifierHash
[4],
7463 office2013
->encryptedVerifierHash
[5],
7464 office2013
->encryptedVerifierHash
[6],
7465 office2013
->encryptedVerifierHash
[7]);
7467 else if (hash_mode
== 9700)
7469 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7471 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7473 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7474 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7475 byte_swap_32 (salt
.salt_buf
[0]),
7476 byte_swap_32 (salt
.salt_buf
[1]),
7477 byte_swap_32 (salt
.salt_buf
[2]),
7478 byte_swap_32 (salt
.salt_buf
[3]),
7479 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7480 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7481 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7482 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7483 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7484 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7485 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7486 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7488 else if (hash_mode
== 9710)
7490 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7492 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7494 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7495 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7496 byte_swap_32 (salt
.salt_buf
[0]),
7497 byte_swap_32 (salt
.salt_buf
[1]),
7498 byte_swap_32 (salt
.salt_buf
[2]),
7499 byte_swap_32 (salt
.salt_buf
[3]),
7500 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7501 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7502 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7503 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7504 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7505 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7506 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7507 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7509 else if (hash_mode
== 9720)
7511 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7513 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7515 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7517 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7518 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7519 byte_swap_32 (salt
.salt_buf
[0]),
7520 byte_swap_32 (salt
.salt_buf
[1]),
7521 byte_swap_32 (salt
.salt_buf
[2]),
7522 byte_swap_32 (salt
.salt_buf
[3]),
7523 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7524 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7525 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7526 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7527 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7528 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7529 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7530 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7537 else if (hash_mode
== 9800)
7539 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7541 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7543 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7544 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7549 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7550 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7551 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7552 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7553 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7554 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7555 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7556 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7557 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7559 else if (hash_mode
== 9810)
7561 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7563 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7565 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7566 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7571 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7572 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7573 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7574 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7575 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7576 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7577 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7578 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7579 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7581 else if (hash_mode
== 9820)
7583 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7585 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7587 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7589 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7590 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7595 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7596 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7597 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7598 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7599 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7600 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7601 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7602 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7603 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7610 else if (hash_mode
== 10000)
7614 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7616 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7618 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7622 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7623 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7624 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7625 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7626 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7627 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7628 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7629 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7630 digest_buf
[8] = 0; // needed for base64_encode ()
7632 char tmp_buf
[64] = { 0 };
7634 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7638 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7640 else if (hash_mode
== 10100)
7642 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7647 byte_swap_32 (salt
.salt_buf
[0]),
7648 byte_swap_32 (salt
.salt_buf
[1]),
7649 byte_swap_32 (salt
.salt_buf
[2]),
7650 byte_swap_32 (salt
.salt_buf
[3]));
7652 else if (hash_mode
== 10200)
7654 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7656 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7660 char challenge
[100] = { 0 };
7662 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7666 char tmp_buf
[100] = { 0 };
7668 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7669 (char *) cram_md5
->user
,
7675 char response
[100] = { 0 };
7677 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7679 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7681 else if (hash_mode
== 10300)
7683 char tmp_buf
[100] = { 0 };
7685 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7686 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7688 uint tmp_len
= 20 + salt
.salt_len
;
7692 char base64_encoded
[100] = { 0 };
7694 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7696 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7698 else if (hash_mode
== 10400)
7700 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7702 pdf_t
*pdf
= &pdfs
[salt_pos
];
7704 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",
7712 byte_swap_32 (pdf
->id_buf
[0]),
7713 byte_swap_32 (pdf
->id_buf
[1]),
7714 byte_swap_32 (pdf
->id_buf
[2]),
7715 byte_swap_32 (pdf
->id_buf
[3]),
7717 byte_swap_32 (pdf
->u_buf
[0]),
7718 byte_swap_32 (pdf
->u_buf
[1]),
7719 byte_swap_32 (pdf
->u_buf
[2]),
7720 byte_swap_32 (pdf
->u_buf
[3]),
7721 byte_swap_32 (pdf
->u_buf
[4]),
7722 byte_swap_32 (pdf
->u_buf
[5]),
7723 byte_swap_32 (pdf
->u_buf
[6]),
7724 byte_swap_32 (pdf
->u_buf
[7]),
7726 byte_swap_32 (pdf
->o_buf
[0]),
7727 byte_swap_32 (pdf
->o_buf
[1]),
7728 byte_swap_32 (pdf
->o_buf
[2]),
7729 byte_swap_32 (pdf
->o_buf
[3]),
7730 byte_swap_32 (pdf
->o_buf
[4]),
7731 byte_swap_32 (pdf
->o_buf
[5]),
7732 byte_swap_32 (pdf
->o_buf
[6]),
7733 byte_swap_32 (pdf
->o_buf
[7])
7736 else if (hash_mode
== 10410)
7738 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7740 pdf_t
*pdf
= &pdfs
[salt_pos
];
7742 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",
7750 byte_swap_32 (pdf
->id_buf
[0]),
7751 byte_swap_32 (pdf
->id_buf
[1]),
7752 byte_swap_32 (pdf
->id_buf
[2]),
7753 byte_swap_32 (pdf
->id_buf
[3]),
7755 byte_swap_32 (pdf
->u_buf
[0]),
7756 byte_swap_32 (pdf
->u_buf
[1]),
7757 byte_swap_32 (pdf
->u_buf
[2]),
7758 byte_swap_32 (pdf
->u_buf
[3]),
7759 byte_swap_32 (pdf
->u_buf
[4]),
7760 byte_swap_32 (pdf
->u_buf
[5]),
7761 byte_swap_32 (pdf
->u_buf
[6]),
7762 byte_swap_32 (pdf
->u_buf
[7]),
7764 byte_swap_32 (pdf
->o_buf
[0]),
7765 byte_swap_32 (pdf
->o_buf
[1]),
7766 byte_swap_32 (pdf
->o_buf
[2]),
7767 byte_swap_32 (pdf
->o_buf
[3]),
7768 byte_swap_32 (pdf
->o_buf
[4]),
7769 byte_swap_32 (pdf
->o_buf
[5]),
7770 byte_swap_32 (pdf
->o_buf
[6]),
7771 byte_swap_32 (pdf
->o_buf
[7])
7774 else if (hash_mode
== 10420)
7776 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7778 pdf_t
*pdf
= &pdfs
[salt_pos
];
7780 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7782 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",
7790 byte_swap_32 (pdf
->id_buf
[0]),
7791 byte_swap_32 (pdf
->id_buf
[1]),
7792 byte_swap_32 (pdf
->id_buf
[2]),
7793 byte_swap_32 (pdf
->id_buf
[3]),
7795 byte_swap_32 (pdf
->u_buf
[0]),
7796 byte_swap_32 (pdf
->u_buf
[1]),
7797 byte_swap_32 (pdf
->u_buf
[2]),
7798 byte_swap_32 (pdf
->u_buf
[3]),
7799 byte_swap_32 (pdf
->u_buf
[4]),
7800 byte_swap_32 (pdf
->u_buf
[5]),
7801 byte_swap_32 (pdf
->u_buf
[6]),
7802 byte_swap_32 (pdf
->u_buf
[7]),
7804 byte_swap_32 (pdf
->o_buf
[0]),
7805 byte_swap_32 (pdf
->o_buf
[1]),
7806 byte_swap_32 (pdf
->o_buf
[2]),
7807 byte_swap_32 (pdf
->o_buf
[3]),
7808 byte_swap_32 (pdf
->o_buf
[4]),
7809 byte_swap_32 (pdf
->o_buf
[5]),
7810 byte_swap_32 (pdf
->o_buf
[6]),
7811 byte_swap_32 (pdf
->o_buf
[7]),
7819 else if (hash_mode
== 10500)
7821 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7823 pdf_t
*pdf
= &pdfs
[salt_pos
];
7825 if (pdf
->id_len
== 32)
7827 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",
7835 byte_swap_32 (pdf
->id_buf
[0]),
7836 byte_swap_32 (pdf
->id_buf
[1]),
7837 byte_swap_32 (pdf
->id_buf
[2]),
7838 byte_swap_32 (pdf
->id_buf
[3]),
7839 byte_swap_32 (pdf
->id_buf
[4]),
7840 byte_swap_32 (pdf
->id_buf
[5]),
7841 byte_swap_32 (pdf
->id_buf
[6]),
7842 byte_swap_32 (pdf
->id_buf
[7]),
7844 byte_swap_32 (pdf
->u_buf
[0]),
7845 byte_swap_32 (pdf
->u_buf
[1]),
7846 byte_swap_32 (pdf
->u_buf
[2]),
7847 byte_swap_32 (pdf
->u_buf
[3]),
7848 byte_swap_32 (pdf
->u_buf
[4]),
7849 byte_swap_32 (pdf
->u_buf
[5]),
7850 byte_swap_32 (pdf
->u_buf
[6]),
7851 byte_swap_32 (pdf
->u_buf
[7]),
7853 byte_swap_32 (pdf
->o_buf
[0]),
7854 byte_swap_32 (pdf
->o_buf
[1]),
7855 byte_swap_32 (pdf
->o_buf
[2]),
7856 byte_swap_32 (pdf
->o_buf
[3]),
7857 byte_swap_32 (pdf
->o_buf
[4]),
7858 byte_swap_32 (pdf
->o_buf
[5]),
7859 byte_swap_32 (pdf
->o_buf
[6]),
7860 byte_swap_32 (pdf
->o_buf
[7])
7865 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",
7873 byte_swap_32 (pdf
->id_buf
[0]),
7874 byte_swap_32 (pdf
->id_buf
[1]),
7875 byte_swap_32 (pdf
->id_buf
[2]),
7876 byte_swap_32 (pdf
->id_buf
[3]),
7878 byte_swap_32 (pdf
->u_buf
[0]),
7879 byte_swap_32 (pdf
->u_buf
[1]),
7880 byte_swap_32 (pdf
->u_buf
[2]),
7881 byte_swap_32 (pdf
->u_buf
[3]),
7882 byte_swap_32 (pdf
->u_buf
[4]),
7883 byte_swap_32 (pdf
->u_buf
[5]),
7884 byte_swap_32 (pdf
->u_buf
[6]),
7885 byte_swap_32 (pdf
->u_buf
[7]),
7887 byte_swap_32 (pdf
->o_buf
[0]),
7888 byte_swap_32 (pdf
->o_buf
[1]),
7889 byte_swap_32 (pdf
->o_buf
[2]),
7890 byte_swap_32 (pdf
->o_buf
[3]),
7891 byte_swap_32 (pdf
->o_buf
[4]),
7892 byte_swap_32 (pdf
->o_buf
[5]),
7893 byte_swap_32 (pdf
->o_buf
[6]),
7894 byte_swap_32 (pdf
->o_buf
[7])
7898 else if (hash_mode
== 10600)
7900 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7902 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7903 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7905 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7907 else if (hash_mode
== 10700)
7909 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7911 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7912 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7914 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7916 else if (hash_mode
== 10900)
7918 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7920 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7921 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7923 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7925 else if (hash_mode
== 11100)
7927 u32 salt_challenge
= salt
.salt_buf
[0];
7929 salt_challenge
= byte_swap_32 (salt_challenge
);
7931 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7933 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7934 SIGNATURE_POSTGRESQL_AUTH
,
7942 else if (hash_mode
== 11200)
7944 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7945 SIGNATURE_MYSQL_AUTH
,
7946 (unsigned char *) salt
.salt_buf
,
7953 else if (hash_mode
== 11300)
7955 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7957 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7959 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7960 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7961 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7963 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7964 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7965 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7967 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7969 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7971 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7974 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7976 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7978 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7981 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7983 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
7985 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7988 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
7989 SIGNATURE_BITCOIN_WALLET
,
7993 (unsigned char *) salt
.salt_buf
,
8001 free (cry_master_buf
);
8003 free (public_key_buf
);
8005 else if (hash_mode
== 11400)
8007 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8009 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8010 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8012 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8014 else if (hash_mode
== 11600)
8016 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8018 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8020 const uint data_len
= seven_zip
->data_len
;
8022 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8024 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8026 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8028 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8031 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8032 SIGNATURE_SEVEN_ZIP
,
8036 (char *) seven_zip
->salt_buf
,
8038 seven_zip
->iv_buf
[0],
8039 seven_zip
->iv_buf
[1],
8040 seven_zip
->iv_buf
[2],
8041 seven_zip
->iv_buf
[3],
8043 seven_zip
->data_len
,
8044 seven_zip
->unpack_size
,
8049 else if (hash_mode
== 11700)
8051 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8061 else if (hash_mode
== 11800)
8063 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8081 else if (hash_mode
== 11900)
8083 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8085 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8086 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8088 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8090 else if (hash_mode
== 12000)
8092 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8094 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8095 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8097 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8099 else if (hash_mode
== 12100)
8101 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8103 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8104 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8106 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8108 else if (hash_mode
== 12200)
8110 uint
*ptr_digest
= digest_buf
;
8111 uint
*ptr_salt
= salt
.salt_buf
;
8113 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8120 else if (hash_mode
== 12300)
8122 uint
*ptr_digest
= digest_buf
;
8123 uint
*ptr_salt
= salt
.salt_buf
;
8125 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",
8126 ptr_digest
[ 0], ptr_digest
[ 1],
8127 ptr_digest
[ 2], ptr_digest
[ 3],
8128 ptr_digest
[ 4], ptr_digest
[ 5],
8129 ptr_digest
[ 6], ptr_digest
[ 7],
8130 ptr_digest
[ 8], ptr_digest
[ 9],
8131 ptr_digest
[10], ptr_digest
[11],
8132 ptr_digest
[12], ptr_digest
[13],
8133 ptr_digest
[14], ptr_digest
[15],
8139 else if (hash_mode
== 12400)
8141 // encode iteration count
8143 char salt_iter
[5] = { 0 };
8145 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8146 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8147 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8148 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8153 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8154 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8155 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8156 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8161 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8163 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8164 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8166 memcpy (tmp_buf
, digest_buf
, 8);
8168 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8172 // fill the resulting buffer
8174 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8176 else if (hash_mode
== 12500)
8178 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8180 byte_swap_32 (salt
.salt_buf
[0]),
8181 byte_swap_32 (salt
.salt_buf
[1]),
8187 else if (hash_mode
== 12600)
8189 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8190 digest_buf
[0] + salt
.salt_buf_pc
[0],
8191 digest_buf
[1] + salt
.salt_buf_pc
[1],
8192 digest_buf
[2] + salt
.salt_buf_pc
[2],
8193 digest_buf
[3] + salt
.salt_buf_pc
[3],
8194 digest_buf
[4] + salt
.salt_buf_pc
[4],
8195 digest_buf
[5] + salt
.salt_buf_pc
[5],
8196 digest_buf
[6] + salt
.salt_buf_pc
[6],
8197 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8199 else if (hash_mode
== 12700)
8201 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8203 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8204 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8206 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8208 else if (hash_mode
== 12800)
8210 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8212 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",
8225 byte_swap_32 (digest_buf
[0]),
8226 byte_swap_32 (digest_buf
[1]),
8227 byte_swap_32 (digest_buf
[2]),
8228 byte_swap_32 (digest_buf
[3]),
8229 byte_swap_32 (digest_buf
[4]),
8230 byte_swap_32 (digest_buf
[5]),
8231 byte_swap_32 (digest_buf
[6]),
8232 byte_swap_32 (digest_buf
[7])
8235 else if (hash_mode
== 12900)
8237 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",
8246 byte_swap_32 (digest_buf
[0]),
8247 byte_swap_32 (digest_buf
[1]),
8248 byte_swap_32 (digest_buf
[2]),
8249 byte_swap_32 (digest_buf
[3]),
8250 byte_swap_32 (digest_buf
[4]),
8251 byte_swap_32 (digest_buf
[5]),
8252 byte_swap_32 (digest_buf
[6]),
8253 byte_swap_32 (digest_buf
[7]),
8260 else if (hash_mode
== 13000)
8262 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8264 rar5_t
*rar5
= &rar5s
[salt_pos
];
8266 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8276 byte_swap_32 (digest_buf
[0]),
8277 byte_swap_32 (digest_buf
[1])
8282 if (hash_type
== HASH_TYPE_MD4
)
8284 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8290 else if (hash_type
== HASH_TYPE_MD5
)
8292 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8298 else if (hash_type
== HASH_TYPE_SHA1
)
8300 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8307 else if (hash_type
== HASH_TYPE_SHA256
)
8309 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8319 else if (hash_type
== HASH_TYPE_SHA384
)
8321 uint
*ptr
= digest_buf
;
8323 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8331 else if (hash_type
== HASH_TYPE_SHA512
)
8333 uint
*ptr
= digest_buf
;
8335 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8345 else if (hash_type
== HASH_TYPE_LM
)
8347 snprintf (out_buf
, len
-1, "%08x%08x",
8351 else if (hash_type
== HASH_TYPE_ORACLEH
)
8353 snprintf (out_buf
, len
-1, "%08X%08X",
8357 else if (hash_type
== HASH_TYPE_BCRYPT
)
8359 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8360 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8362 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8364 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8366 else if (hash_type
== HASH_TYPE_KECCAK
)
8368 uint
*ptr
= digest_buf
;
8370 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",
8398 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8400 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8402 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8409 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8411 digest_buf
[ 0] = digest_buf
[ 0];
8412 digest_buf
[ 1] = digest_buf
[ 1];
8413 digest_buf
[ 2] = digest_buf
[ 2];
8414 digest_buf
[ 3] = digest_buf
[ 3];
8415 digest_buf
[ 4] = digest_buf
[ 4];
8416 digest_buf
[ 5] = digest_buf
[ 5];
8417 digest_buf
[ 6] = digest_buf
[ 6];
8418 digest_buf
[ 7] = digest_buf
[ 7];
8419 digest_buf
[ 8] = digest_buf
[ 8];
8420 digest_buf
[ 9] = digest_buf
[ 9];
8421 digest_buf
[10] = digest_buf
[10];
8422 digest_buf
[11] = digest_buf
[11];
8423 digest_buf
[12] = digest_buf
[12];
8424 digest_buf
[13] = digest_buf
[13];
8425 digest_buf
[14] = digest_buf
[14];
8426 digest_buf
[15] = digest_buf
[15];
8428 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8446 else if (hash_type
== HASH_TYPE_GOST
)
8448 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8458 else if (hash_type
== HASH_TYPE_MYSQL
)
8460 snprintf (out_buf
, len
-1, "%08x%08x",
8464 else if (hash_type
== HASH_TYPE_LOTUS5
)
8466 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8472 else if (hash_type
== HASH_TYPE_LOTUS6
)
8474 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8475 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8476 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8477 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8479 char buf
[16] = { 0 };
8481 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8482 memcpy (buf
+ 5, digest_buf
, 9);
8486 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8488 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8491 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8493 else if (hash_type
== HASH_TYPE_LOTUS8
)
8495 char buf
[52] = { 0 };
8499 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8505 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8509 buf
[26] = salt
.salt_buf_pc
[0];
8510 buf
[27] = salt
.salt_buf_pc
[1];
8514 memcpy (buf
+ 28, digest_buf
, 8);
8516 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8520 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8522 else if (hash_type
== HASH_TYPE_CRC32
)
8524 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8528 if (salt_type
== SALT_TYPE_INTERN
)
8530 size_t pos
= strlen (out_buf
);
8532 out_buf
[pos
] = data
.separator
;
8534 char *ptr
= (char *) salt
.salt_buf
;
8536 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8538 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8542 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8544 memset (hccap
, 0, sizeof (hccap_t
));
8546 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8548 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8550 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8551 wpa_t
*wpa
= &wpas
[salt_pos
];
8553 hccap
->keyver
= wpa
->keyver
;
8555 hccap
->eapol_size
= wpa
->eapol_size
;
8557 if (wpa
->keyver
!= 1)
8559 uint eapol_tmp
[64] = { 0 };
8561 for (uint i
= 0; i
< 64; i
++)
8563 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8566 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8570 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8573 uint pke_tmp
[25] = { 0 };
8575 for (int i
= 5; i
< 25; i
++)
8577 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8580 char *pke_ptr
= (char *) pke_tmp
;
8582 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8583 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8584 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8585 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8587 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8589 uint dgst_size
= data
.dgst_size
;
8591 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8593 if (wpa
->keyver
!= 1)
8595 uint digest_tmp
[4] = { 0 };
8597 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8598 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8599 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8600 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8602 memcpy (hccap
->keymic
, digest_tmp
, 16);
8606 memcpy (hccap
->keymic
, digest_ptr
, 16);
8610 void SuspendThreads ()
8612 if (data
.devices_status
== STATUS_RUNNING
)
8614 hc_timer_set (&data
.timer_paused
);
8616 data
.devices_status
= STATUS_PAUSED
;
8618 log_info ("Paused");
8622 void ResumeThreads ()
8624 if (data
.devices_status
== STATUS_PAUSED
)
8628 hc_timer_get (data
.timer_paused
, ms_paused
);
8630 data
.ms_paused
+= ms_paused
;
8632 data
.devices_status
= STATUS_RUNNING
;
8634 log_info ("Resumed");
8640 if (data
.devices_status
!= STATUS_RUNNING
) return;
8642 data
.devices_status
= STATUS_BYPASS
;
8644 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8647 void stop_at_checkpoint ()
8649 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8651 if (data
.devices_status
!= STATUS_RUNNING
) return;
8654 // this feature only makes sense if --restore-disable was not specified
8656 if (data
.restore_disable
== 1)
8658 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8663 // check if monitoring of Restore Point updates should be enabled or disabled
8665 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8667 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8669 // save the current restore point value
8671 data
.checkpoint_cur_words
= get_lowest_words_done ();
8673 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8677 data
.devices_status
= STATUS_RUNNING
;
8679 // reset the global value for checkpoint checks
8681 data
.checkpoint_cur_words
= 0;
8683 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8689 if (data
.devices_status
== STATUS_INIT
) return;
8690 if (data
.devices_status
== STATUS_STARTING
) return;
8692 data
.devices_status
= STATUS_ABORTED
;
8697 if (data
.devices_status
== STATUS_INIT
) return;
8698 if (data
.devices_status
== STATUS_STARTING
) return;
8700 data
.devices_status
= STATUS_QUIT
;
8703 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8705 FILE *fp
= fopen (kernel_file
, "rb");
8711 memset (&st
, 0, sizeof (st
));
8713 stat (kernel_file
, &st
);
8715 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8717 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8719 if (num_read
!= (size_t) st
.st_size
)
8721 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8728 buf
[st
.st_size
] = 0;
8730 for (int i
= 0; i
< num_devices
; i
++)
8732 kernel_lengths
[i
] = (size_t) st
.st_size
;
8734 kernel_sources
[i
] = buf
;
8739 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8747 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8749 if (binary_size
> 0)
8751 FILE *fp
= fopen (dst
, "wb");
8754 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8765 restore_data_t
*init_restore (int argc
, char **argv
)
8767 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8769 if (data
.restore_disable
== 0)
8771 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8775 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8779 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8788 char pidbin
[BUFSIZ
] = { 0 };
8790 int pidbin_len
= -1;
8793 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8795 FILE *fd
= fopen (pidbin
, "rb");
8799 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8801 pidbin
[pidbin_len
] = 0;
8805 char *argv0_r
= strrchr (argv
[0], '/');
8807 char *pidbin_r
= strrchr (pidbin
, '/');
8809 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8811 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8813 if (strcmp (argv0_r
, pidbin_r
) == 0)
8815 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8822 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8824 char pidbin2
[BUFSIZ
] = { 0 };
8826 int pidbin2_len
= -1;
8828 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8829 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8831 pidbin
[pidbin_len
] = 0;
8832 pidbin2
[pidbin2_len
] = 0;
8836 if (strcmp (pidbin
, pidbin2
) == 0)
8838 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8846 if (rd
->version_bin
< RESTORE_MIN
)
8848 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8855 memset (rd
, 0, sizeof (restore_data_t
));
8857 rd
->version_bin
= VERSION_BIN
;
8860 rd
->pid
= getpid ();
8862 rd
->pid
= GetCurrentProcessId ();
8865 if (getcwd (rd
->cwd
, 255) == NULL
)
8878 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8880 FILE *fp
= fopen (eff_restore_file
, "rb");
8884 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8889 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8891 log_error ("ERROR: cannot read %s", eff_restore_file
);
8896 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8898 for (uint i
= 0; i
< rd
->argc
; i
++)
8900 char buf
[BUFSIZ
] = { 0 };
8902 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8904 log_error ("ERROR: cannot read %s", eff_restore_file
);
8909 size_t len
= strlen (buf
);
8911 if (len
) buf
[len
- 1] = 0;
8913 rd
->argv
[i
] = mystrdup (buf
);
8918 char new_cwd
[1024] = { 0 };
8920 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8924 log_error ("Restore file is corrupted");
8927 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8929 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8931 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8936 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8939 if (chdir (rd
->cwd
))
8941 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8947 u64
get_lowest_words_done ()
8951 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8953 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8955 if (device_param
->skipped
) continue;
8957 const u64 words_done
= device_param
->words_done
;
8959 if (words_done
< words_cur
) words_cur
= words_done
;
8962 // It's possible that a device's workload isn't finished right after a restore-case.
8963 // In that case, this function would return 0 and overwrite the real restore point
8964 // There's also data.words_cur which is set to rd->words_cur but it changes while
8965 // the attack is running therefore we should stick to rd->words_cur.
8966 // Note that -s influences rd->words_cur we should keep a close look on that.
8968 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
8973 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
8975 u64 words_cur
= get_lowest_words_done ();
8977 rd
->words_cur
= words_cur
;
8979 FILE *fp
= fopen (new_restore_file
, "wb");
8983 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
8988 if (setvbuf (fp
, NULL
, _IONBF
, 0))
8990 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
8995 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
8997 for (uint i
= 0; i
< rd
->argc
; i
++)
8999 fprintf (fp
, "%s", rd
->argv
[i
]);
9005 fsync (fileno (fp
));
9010 void cycle_restore ()
9012 const char *eff_restore_file
= data
.eff_restore_file
;
9013 const char *new_restore_file
= data
.new_restore_file
;
9015 restore_data_t
*rd
= data
.rd
;
9017 write_restore (new_restore_file
, rd
);
9021 memset (&st
, 0, sizeof(st
));
9023 if (stat (eff_restore_file
, &st
) == 0)
9025 if (unlink (eff_restore_file
))
9027 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9031 if (rename (new_restore_file
, eff_restore_file
))
9033 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9037 void check_checkpoint ()
9039 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9041 u64 words_cur
= get_lowest_words_done ();
9043 if (words_cur
!= data
.checkpoint_cur_words
)
9053 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9057 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9059 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9061 myfree (alias
->device_name
);
9062 myfree (alias
->alias_name
);
9065 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9067 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9069 myfree (entry
->device_name
);
9072 myfree (tuning_db
->alias_buf
);
9073 myfree (tuning_db
->entry_buf
);
9078 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9080 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9082 int num_lines
= count_lines (fp
);
9084 // a bit over-allocated
9086 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9087 tuning_db
->alias_cnt
= 0;
9089 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9090 tuning_db
->entry_cnt
= 0;
9095 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9097 FILE *fp
= fopen (tuning_db_file
, "rb");
9101 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9106 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9116 char *line_buf
= fgets (buf
, sizeof (buf
) - 1, fp
);
9118 if (line_buf
== NULL
) break;
9122 const int line_len
= in_superchop (line_buf
);
9124 if (line_len
== 0) continue;
9126 if (line_buf
[0] == '#') continue;
9130 char *token_ptr
[7] = { NULL
};
9134 char *next
= strtok (line_buf
, "\t ");
9136 token_ptr
[token_cnt
] = next
;
9140 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9142 token_ptr
[token_cnt
] = next
;
9149 char *device_name
= token_ptr
[0];
9150 char *alias_name
= token_ptr
[1];
9152 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9154 alias
->device_name
= mystrdup (device_name
);
9155 alias
->alias_name
= mystrdup (alias_name
);
9157 tuning_db
->alias_cnt
++;
9159 else if (token_cnt
== 6)
9161 if ((token_ptr
[1][0] != '0') &&
9162 (token_ptr
[1][0] != '1') &&
9163 (token_ptr
[1][0] != '3') &&
9164 (token_ptr
[1][0] != '*'))
9166 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9171 if ((token_ptr
[3][0] != '1') &&
9172 (token_ptr
[3][0] != '2') &&
9173 (token_ptr
[3][0] != '4') &&
9174 (token_ptr
[3][0] != '8') &&
9175 (token_ptr
[3][0] != 'N'))
9177 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9182 char *device_name
= token_ptr
[0];
9184 int attack_mode
= -1;
9186 int vector_width
= -1;
9187 int kernel_accel
= -1;
9188 int kernel_loops
= -1;
9190 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9191 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9192 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9194 kernel_accel
= atoi (token_ptr
[4]);
9196 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9198 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9203 kernel_loops
= atoi (token_ptr
[5]);
9205 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9207 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9212 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9214 entry
->device_name
= mystrdup (device_name
);
9215 entry
->attack_mode
= attack_mode
;
9216 entry
->hash_type
= hash_type
;
9217 entry
->vector_width
= vector_width
;
9218 entry
->kernel_accel
= kernel_accel
;
9219 entry
->kernel_loops
= kernel_loops
;
9221 tuning_db
->entry_cnt
++;
9225 // todo: some warning message
9233 // todo: print loaded 'cnt' message
9235 // sort the database
9237 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9238 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9243 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, char *device_name
, int attack_mode
, int hash_type
)
9245 static tuning_db_entry_t s
;
9247 // first we need to convert all spaces in the device_name to underscore
9249 char *device_name_nospace
= strdup (device_name
);
9251 int device_name_length
= strlen (device_name_nospace
);
9255 for (i
= 0; i
< device_name_length
; i
++)
9257 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9260 // find out if there's an alias configured
9262 tuning_db_alias_t a
;
9264 a
.device_name
= device_name_nospace
;
9266 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
);
9268 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9270 // attack-mode 6 and 7 are attack-mode 1 basically
9272 if (attack_mode
== 6) attack_mode
= 1;
9273 if (attack_mode
== 7) attack_mode
= 1;
9275 // bsearch is not ideal but fast enough
9277 s
.device_name
= device_name_nospace
;
9278 s
.attack_mode
= attack_mode
;
9279 s
.hash_type
= hash_type
;
9281 tuning_db_entry_t
*entry
= NULL
;
9283 // this will produce all 2^3 combinations required
9285 for (i
= 0; i
< 8; i
++)
9287 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9288 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9289 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9291 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9293 if (entry
!= NULL
) break;
9295 // in non-wildcard mode also check the alias_name
9297 if (((i
& 1) == 0) && (alias_name
!= NULL
))
9299 s
.device_name
= alias_name
;
9301 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9303 if (entry
!= NULL
) break;
9307 // if still not found use some defaults
9311 s
.vector_width
= TUNING_DB_DEFAULT_VECTOR_WIDTH
;
9312 s
.kernel_accel
= TUNING_DB_DEFAULT_KERNEL_ACCEL
;
9313 s
.kernel_loops
= TUNING_DB_DEFAULT_KERNEL_LOOPS
;
9318 // free converted device_name
9320 myfree (device_name_nospace
);
9329 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9331 u8 tmp
[256] = { 0 };
9333 if (salt_len
> sizeof (tmp
))
9338 memcpy (tmp
, in
, salt_len
);
9340 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9342 if ((salt_len
% 2) == 0)
9344 u32 new_salt_len
= salt_len
/ 2;
9346 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9351 tmp
[i
] = hex_convert (p1
) << 0;
9352 tmp
[i
] |= hex_convert (p0
) << 4;
9355 salt_len
= new_salt_len
;
9362 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9364 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9367 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9369 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9373 u32
*tmp_uint
= (u32
*) tmp
;
9375 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9376 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9377 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9378 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9379 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9380 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9381 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9382 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9383 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9384 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9386 salt_len
= salt_len
* 2;
9394 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9396 lowercase (tmp
, salt_len
);
9399 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9401 uppercase (tmp
, salt_len
);
9406 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9411 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9416 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9418 u32
*tmp_uint
= (uint
*) tmp
;
9424 for (u32 i
= 0; i
< max
; i
++)
9426 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9429 // Important: we may need to increase the length of memcpy since
9430 // we don't want to "loose" some swapped bytes (could happen if
9431 // they do not perfectly fit in the 4-byte blocks)
9432 // Memcpy does always copy the bytes in the BE order, but since
9433 // we swapped them, some important bytes could be in positions
9434 // we normally skip with the original len
9436 if (len
% 4) len
+= 4 - (len
% 4);
9439 memcpy (out
, tmp
, len
);
9444 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9446 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9448 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9450 u32
*digest
= (u32
*) hash_buf
->digest
;
9452 salt_t
*salt
= hash_buf
->salt
;
9454 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9456 char *iter_pos
= input_buf
+ 4;
9458 salt
->salt_iter
= 1 << atoi (iter_pos
);
9460 char *salt_pos
= strchr (iter_pos
, '$');
9462 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9468 salt
->salt_len
= salt_len
;
9470 u8 tmp_buf
[100] = { 0 };
9472 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9474 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9476 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9478 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9479 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9480 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9481 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9483 char *hash_pos
= salt_pos
+ 22;
9485 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9487 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9489 memcpy (digest
, tmp_buf
, 24);
9491 digest
[0] = byte_swap_32 (digest
[0]);
9492 digest
[1] = byte_swap_32 (digest
[1]);
9493 digest
[2] = byte_swap_32 (digest
[2]);
9494 digest
[3] = byte_swap_32 (digest
[3]);
9495 digest
[4] = byte_swap_32 (digest
[4]);
9496 digest
[5] = byte_swap_32 (digest
[5]);
9498 digest
[5] &= ~0xff; // its just 23 not 24 !
9503 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9505 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9507 u32
*digest
= (u32
*) hash_buf
->digest
;
9509 u8 tmp_buf
[100] = { 0 };
9511 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9513 memcpy (digest
, tmp_buf
, 32);
9515 digest
[0] = byte_swap_32 (digest
[0]);
9516 digest
[1] = byte_swap_32 (digest
[1]);
9517 digest
[2] = byte_swap_32 (digest
[2]);
9518 digest
[3] = byte_swap_32 (digest
[3]);
9519 digest
[4] = byte_swap_32 (digest
[4]);
9520 digest
[5] = byte_swap_32 (digest
[5]);
9521 digest
[6] = byte_swap_32 (digest
[6]);
9522 digest
[7] = byte_swap_32 (digest
[7]);
9524 digest
[0] -= SHA256M_A
;
9525 digest
[1] -= SHA256M_B
;
9526 digest
[2] -= SHA256M_C
;
9527 digest
[3] -= SHA256M_D
;
9528 digest
[4] -= SHA256M_E
;
9529 digest
[5] -= SHA256M_F
;
9530 digest
[6] -= SHA256M_G
;
9531 digest
[7] -= SHA256M_H
;
9536 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9538 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9540 u32
*digest
= (u32
*) hash_buf
->digest
;
9542 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9543 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9545 digest
[0] = byte_swap_32 (digest
[0]);
9546 digest
[1] = byte_swap_32 (digest
[1]);
9550 IP (digest
[0], digest
[1], tt
);
9552 digest
[0] = digest
[0];
9553 digest
[1] = digest
[1];
9560 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9562 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9564 u32
*digest
= (u32
*) hash_buf
->digest
;
9566 salt_t
*salt
= hash_buf
->salt
;
9568 char *hash_pos
= input_buf
+ 8;
9570 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9571 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9572 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9573 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9574 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9576 digest
[0] -= SHA1M_A
;
9577 digest
[1] -= SHA1M_B
;
9578 digest
[2] -= SHA1M_C
;
9579 digest
[3] -= SHA1M_D
;
9580 digest
[4] -= SHA1M_E
;
9584 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9586 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9588 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9590 salt
->salt_len
= salt_len
;
9595 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9597 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9599 u64
*digest
= (u64
*) hash_buf
->digest
;
9601 salt_t
*salt
= hash_buf
->salt
;
9603 char *hash_pos
= input_buf
+ 8;
9605 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9606 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9607 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9608 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9609 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9610 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9611 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9612 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9614 digest
[0] -= SHA512M_A
;
9615 digest
[1] -= SHA512M_B
;
9616 digest
[2] -= SHA512M_C
;
9617 digest
[3] -= SHA512M_D
;
9618 digest
[4] -= SHA512M_E
;
9619 digest
[5] -= SHA512M_F
;
9620 digest
[6] -= SHA512M_G
;
9621 digest
[7] -= SHA512M_H
;
9625 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9627 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9629 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9631 salt
->salt_len
= salt_len
;
9636 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9638 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9640 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9644 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9647 u32
*digest
= (u32
*) hash_buf
->digest
;
9649 salt_t
*salt
= hash_buf
->salt
;
9651 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9652 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9653 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9654 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9656 digest
[0] = byte_swap_32 (digest
[0]);
9657 digest
[1] = byte_swap_32 (digest
[1]);
9658 digest
[2] = byte_swap_32 (digest
[2]);
9659 digest
[3] = byte_swap_32 (digest
[3]);
9661 digest
[0] -= MD5M_A
;
9662 digest
[1] -= MD5M_B
;
9663 digest
[2] -= MD5M_C
;
9664 digest
[3] -= MD5M_D
;
9666 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9668 uint salt_len
= input_len
- 32 - 1;
9670 char *salt_buf
= input_buf
+ 32 + 1;
9672 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9674 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9676 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9678 salt
->salt_len
= salt_len
;
9683 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9685 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9687 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9691 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9696 char clean_input_buf
[32] = { 0 };
9698 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9699 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9701 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9705 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9711 clean_input_buf
[k
] = input_buf
[i
];
9719 u32
*digest
= (u32
*) hash_buf
->digest
;
9721 salt_t
*salt
= hash_buf
->salt
;
9723 u32 a
, b
, c
, d
, e
, f
;
9725 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9726 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9727 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9728 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9729 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9730 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9732 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9733 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9735 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9736 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9737 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9738 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9739 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9740 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9742 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9743 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9745 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9746 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9747 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9748 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9749 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9750 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9752 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9753 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9755 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9756 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9757 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9758 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9759 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9760 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9762 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9763 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9765 digest
[0] = byte_swap_32 (digest
[0]);
9766 digest
[1] = byte_swap_32 (digest
[1]);
9767 digest
[2] = byte_swap_32 (digest
[2]);
9768 digest
[3] = byte_swap_32 (digest
[3]);
9770 digest
[0] -= MD5M_A
;
9771 digest
[1] -= MD5M_B
;
9772 digest
[2] -= MD5M_C
;
9773 digest
[3] -= MD5M_D
;
9775 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9777 uint salt_len
= input_len
- 30 - 1;
9779 char *salt_buf
= input_buf
+ 30 + 1;
9781 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9783 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9785 // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
9786 if (salt_len
> 10) return (PARSER_SALT_LENGTH
);
9788 salt
->salt_len
= salt_len
;
9790 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9792 salt
->salt_len
+= 22;
9797 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9799 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9801 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9805 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9808 u32
*digest
= (u32
*) hash_buf
->digest
;
9810 salt_t
*salt
= hash_buf
->salt
;
9812 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9813 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9814 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9815 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9816 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
9818 digest
[0] -= SHA1M_A
;
9819 digest
[1] -= SHA1M_B
;
9820 digest
[2] -= SHA1M_C
;
9821 digest
[3] -= SHA1M_D
;
9822 digest
[4] -= SHA1M_E
;
9824 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9826 uint salt_len
= input_len
- 40 - 1;
9828 char *salt_buf
= input_buf
+ 40 + 1;
9830 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9832 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9834 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9836 salt
->salt_len
= salt_len
;
9841 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9843 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9845 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9849 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9852 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9854 char *iter_pos
= input_buf
+ 6;
9856 salt_t
*salt
= hash_buf
->salt
;
9858 uint iter
= atoi (iter_pos
);
9865 salt
->salt_iter
= iter
- 1;
9867 char *salt_pos
= strchr (iter_pos
, '#');
9869 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9873 char *digest_pos
= strchr (salt_pos
, '#');
9875 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9879 uint salt_len
= digest_pos
- salt_pos
- 1;
9881 u32
*digest
= (u32
*) hash_buf
->digest
;
9883 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
9884 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
9885 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
9886 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
9888 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9890 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9892 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9894 salt
->salt_len
= salt_len
;
9899 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9901 u32
*digest
= (u32
*) hash_buf
->digest
;
9903 salt_t
*salt
= hash_buf
->salt
;
9905 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
9909 memcpy (&in
, input_buf
, input_len
);
9911 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
9913 memcpy (digest
, in
.keymic
, 16);
9916 http://www.one-net.eu/jsw/j_sec/m_ptype.html
9917 The phrase "Pairwise key expansion"
9918 Access Point Address (referred to as Authenticator Address AA)
9919 Supplicant Address (referred to as Supplicant Address SA)
9920 Access Point Nonce (referred to as Authenticator Anonce)
9921 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
9924 uint salt_len
= strlen (in
.essid
);
9926 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
9928 salt
->salt_len
= salt_len
;
9930 salt
->salt_iter
= ROUNDS_WPA2
- 1;
9932 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
9934 memcpy (pke_ptr
, "Pairwise key expansion", 23);
9936 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
9938 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
9939 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
9943 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
9944 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
9947 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
9949 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
9950 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
9954 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
9955 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
9958 for (int i
= 0; i
< 25; i
++)
9960 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
9963 wpa
->keyver
= in
.keyver
;
9965 if (wpa
->keyver
> 255)
9967 log_info ("ATTENTION!");
9968 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
9969 log_info (" This could be due to a recent aircrack-ng bug.");
9970 log_info (" The key version was automatically reset to a reasonable value.");
9973 wpa
->keyver
&= 0xff;
9976 wpa
->eapol_size
= in
.eapol_size
;
9978 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
9980 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
9982 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
9984 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
9986 if (wpa
->keyver
== 1)
9992 digest
[0] = byte_swap_32 (digest
[0]);
9993 digest
[1] = byte_swap_32 (digest
[1]);
9994 digest
[2] = byte_swap_32 (digest
[2]);
9995 digest
[3] = byte_swap_32 (digest
[3]);
9997 for (int i
= 0; i
< 64; i
++)
9999 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10003 salt
->salt_buf
[10] = digest
[1];
10004 salt
->salt_buf
[11] = digest
[2];
10006 return (PARSER_OK
);
10009 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10011 u32
*digest
= (u32
*) hash_buf
->digest
;
10013 salt_t
*salt
= hash_buf
->salt
;
10015 if (input_len
== 0)
10017 log_error ("Password Safe v2 container not specified");
10022 FILE *fp
= fopen (input_buf
, "rb");
10026 log_error ("%s: %s", input_buf
, strerror (errno
));
10033 memset (&buf
, 0, sizeof (psafe2_hdr
));
10035 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10039 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10041 salt
->salt_buf
[0] = buf
.random
[0];
10042 salt
->salt_buf
[1] = buf
.random
[1];
10044 salt
->salt_len
= 8;
10045 salt
->salt_iter
= 1000;
10047 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10048 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10049 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10050 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10051 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10053 return (PARSER_OK
);
10056 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10058 u32
*digest
= (u32
*) hash_buf
->digest
;
10060 salt_t
*salt
= hash_buf
->salt
;
10062 if (input_len
== 0)
10064 log_error (".psafe3 not specified");
10069 FILE *fp
= fopen (input_buf
, "rb");
10073 log_error ("%s: %s", input_buf
, strerror (errno
));
10080 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10084 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10086 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10088 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10090 salt
->salt_iter
= in
.iterations
+ 1;
10092 salt
->salt_buf
[0] = in
.salt_buf
[0];
10093 salt
->salt_buf
[1] = in
.salt_buf
[1];
10094 salt
->salt_buf
[2] = in
.salt_buf
[2];
10095 salt
->salt_buf
[3] = in
.salt_buf
[3];
10096 salt
->salt_buf
[4] = in
.salt_buf
[4];
10097 salt
->salt_buf
[5] = in
.salt_buf
[5];
10098 salt
->salt_buf
[6] = in
.salt_buf
[6];
10099 salt
->salt_buf
[7] = in
.salt_buf
[7];
10101 salt
->salt_len
= 32;
10103 digest
[0] = in
.hash_buf
[0];
10104 digest
[1] = in
.hash_buf
[1];
10105 digest
[2] = in
.hash_buf
[2];
10106 digest
[3] = in
.hash_buf
[3];
10107 digest
[4] = in
.hash_buf
[4];
10108 digest
[5] = in
.hash_buf
[5];
10109 digest
[6] = in
.hash_buf
[6];
10110 digest
[7] = in
.hash_buf
[7];
10112 digest
[0] = byte_swap_32 (digest
[0]);
10113 digest
[1] = byte_swap_32 (digest
[1]);
10114 digest
[2] = byte_swap_32 (digest
[2]);
10115 digest
[3] = byte_swap_32 (digest
[3]);
10116 digest
[4] = byte_swap_32 (digest
[4]);
10117 digest
[5] = byte_swap_32 (digest
[5]);
10118 digest
[6] = byte_swap_32 (digest
[6]);
10119 digest
[7] = byte_swap_32 (digest
[7]);
10121 return (PARSER_OK
);
10124 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10126 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10128 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10130 u32
*digest
= (u32
*) hash_buf
->digest
;
10132 salt_t
*salt
= hash_buf
->salt
;
10134 char *iter_pos
= input_buf
+ 3;
10136 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10138 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10140 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10142 salt
->salt_iter
= salt_iter
;
10144 char *salt_pos
= iter_pos
+ 1;
10148 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10150 salt
->salt_len
= salt_len
;
10152 char *hash_pos
= salt_pos
+ salt_len
;
10154 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10156 return (PARSER_OK
);
10159 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10161 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10163 u32
*digest
= (u32
*) hash_buf
->digest
;
10165 salt_t
*salt
= hash_buf
->salt
;
10167 char *salt_pos
= input_buf
+ 3;
10169 uint iterations_len
= 0;
10171 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10175 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10177 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10178 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10182 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10186 iterations_len
+= 8;
10190 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10193 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10195 char *hash_pos
= strchr (salt_pos
, '$');
10197 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10199 uint salt_len
= hash_pos
- salt_pos
;
10201 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10203 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10205 salt
->salt_len
= salt_len
;
10209 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10211 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10213 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10215 return (PARSER_OK
);
10218 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10220 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10222 u32
*digest
= (u32
*) hash_buf
->digest
;
10224 salt_t
*salt
= hash_buf
->salt
;
10226 char *salt_pos
= input_buf
+ 6;
10228 uint iterations_len
= 0;
10230 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10234 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10236 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10237 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10241 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10245 iterations_len
+= 8;
10249 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10252 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10254 char *hash_pos
= strchr (salt_pos
, '$');
10256 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10258 uint salt_len
= hash_pos
- salt_pos
;
10260 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10262 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10264 salt
->salt_len
= salt_len
;
10268 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10270 return (PARSER_OK
);
10273 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10275 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10277 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10279 u32
*digest
= (u32
*) hash_buf
->digest
;
10281 salt_t
*salt
= hash_buf
->salt
;
10283 char *salt_pos
= input_buf
+ 14;
10285 char *hash_pos
= strchr (salt_pos
, '*');
10287 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10291 uint salt_len
= hash_pos
- salt_pos
- 1;
10293 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10295 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10297 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10299 salt
->salt_len
= salt_len
;
10301 u8 tmp_buf
[100] = { 0 };
10303 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10305 memcpy (digest
, tmp_buf
, 20);
10307 digest
[0] = byte_swap_32 (digest
[0]);
10308 digest
[1] = byte_swap_32 (digest
[1]);
10309 digest
[2] = byte_swap_32 (digest
[2]);
10310 digest
[3] = byte_swap_32 (digest
[3]);
10311 digest
[4] = byte_swap_32 (digest
[4]);
10313 digest
[0] -= SHA1M_A
;
10314 digest
[1] -= SHA1M_B
;
10315 digest
[2] -= SHA1M_C
;
10316 digest
[3] -= SHA1M_D
;
10317 digest
[4] -= SHA1M_E
;
10319 return (PARSER_OK
);
10322 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10324 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10326 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10328 if (c12
& 3) return (PARSER_HASH_VALUE
);
10330 u32
*digest
= (u32
*) hash_buf
->digest
;
10332 salt_t
*salt
= hash_buf
->salt
;
10334 // for ascii_digest
10335 salt
->salt_sign
[0] = input_buf
[0];
10336 salt
->salt_sign
[1] = input_buf
[1];
10338 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10339 | itoa64_to_int (input_buf
[1]) << 6;
10341 salt
->salt_len
= 2;
10343 u8 tmp_buf
[100] = { 0 };
10345 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10347 memcpy (digest
, tmp_buf
, 8);
10351 IP (digest
[0], digest
[1], tt
);
10356 return (PARSER_OK
);
10359 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10361 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10363 u32
*digest
= (u32
*) hash_buf
->digest
;
10365 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10366 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10367 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10368 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10370 digest
[0] = byte_swap_32 (digest
[0]);
10371 digest
[1] = byte_swap_32 (digest
[1]);
10372 digest
[2] = byte_swap_32 (digest
[2]);
10373 digest
[3] = byte_swap_32 (digest
[3]);
10375 digest
[0] -= MD4M_A
;
10376 digest
[1] -= MD4M_B
;
10377 digest
[2] -= MD4M_C
;
10378 digest
[3] -= MD4M_D
;
10380 return (PARSER_OK
);
10383 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10385 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10387 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10391 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10394 u32
*digest
= (u32
*) hash_buf
->digest
;
10396 salt_t
*salt
= hash_buf
->salt
;
10398 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10399 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10400 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10401 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10403 digest
[0] = byte_swap_32 (digest
[0]);
10404 digest
[1] = byte_swap_32 (digest
[1]);
10405 digest
[2] = byte_swap_32 (digest
[2]);
10406 digest
[3] = byte_swap_32 (digest
[3]);
10408 digest
[0] -= MD4M_A
;
10409 digest
[1] -= MD4M_B
;
10410 digest
[2] -= MD4M_C
;
10411 digest
[3] -= MD4M_D
;
10413 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10415 uint salt_len
= input_len
- 32 - 1;
10417 char *salt_buf
= input_buf
+ 32 + 1;
10419 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10421 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10423 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10425 salt
->salt_len
= salt_len
;
10427 return (PARSER_OK
);
10430 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10432 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10434 u32
*digest
= (u32
*) hash_buf
->digest
;
10436 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10437 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10438 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10439 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10441 digest
[0] = byte_swap_32 (digest
[0]);
10442 digest
[1] = byte_swap_32 (digest
[1]);
10443 digest
[2] = byte_swap_32 (digest
[2]);
10444 digest
[3] = byte_swap_32 (digest
[3]);
10446 digest
[0] -= MD5M_A
;
10447 digest
[1] -= MD5M_B
;
10448 digest
[2] -= MD5M_C
;
10449 digest
[3] -= MD5M_D
;
10451 return (PARSER_OK
);
10454 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10456 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10458 u32
*digest
= (u32
*) hash_buf
->digest
;
10460 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10461 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10465 digest
[0] = byte_swap_32 (digest
[0]);
10466 digest
[1] = byte_swap_32 (digest
[1]);
10468 return (PARSER_OK
);
10471 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10473 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10475 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10479 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10482 u32
*digest
= (u32
*) hash_buf
->digest
;
10484 salt_t
*salt
= hash_buf
->salt
;
10486 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10487 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10488 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10489 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10491 digest
[0] = byte_swap_32 (digest
[0]);
10492 digest
[1] = byte_swap_32 (digest
[1]);
10493 digest
[2] = byte_swap_32 (digest
[2]);
10494 digest
[3] = byte_swap_32 (digest
[3]);
10496 digest
[0] -= MD5M_A
;
10497 digest
[1] -= MD5M_B
;
10498 digest
[2] -= MD5M_C
;
10499 digest
[3] -= MD5M_D
;
10501 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10503 uint salt_len
= input_len
- 32 - 1;
10505 char *salt_buf
= input_buf
+ 32 + 1;
10507 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10509 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10511 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10513 salt
->salt_len
= salt_len
;
10515 return (PARSER_OK
);
10518 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10520 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10522 u32
*digest
= (u32
*) hash_buf
->digest
;
10524 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10525 | itoa64_to_int (input_buf
[ 1]) << 6
10526 | itoa64_to_int (input_buf
[ 2]) << 12
10527 | itoa64_to_int (input_buf
[ 3]) << 18;
10528 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10529 | itoa64_to_int (input_buf
[ 5]) << 6
10530 | itoa64_to_int (input_buf
[ 6]) << 12
10531 | itoa64_to_int (input_buf
[ 7]) << 18;
10532 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10533 | itoa64_to_int (input_buf
[ 9]) << 6
10534 | itoa64_to_int (input_buf
[10]) << 12
10535 | itoa64_to_int (input_buf
[11]) << 18;
10536 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10537 | itoa64_to_int (input_buf
[13]) << 6
10538 | itoa64_to_int (input_buf
[14]) << 12
10539 | itoa64_to_int (input_buf
[15]) << 18;
10541 digest
[0] -= MD5M_A
;
10542 digest
[1] -= MD5M_B
;
10543 digest
[2] -= MD5M_C
;
10544 digest
[3] -= MD5M_D
;
10546 digest
[0] &= 0x00ffffff;
10547 digest
[1] &= 0x00ffffff;
10548 digest
[2] &= 0x00ffffff;
10549 digest
[3] &= 0x00ffffff;
10551 return (PARSER_OK
);
10554 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10556 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10558 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10562 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10565 u32
*digest
= (u32
*) hash_buf
->digest
;
10567 salt_t
*salt
= hash_buf
->salt
;
10569 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10570 | itoa64_to_int (input_buf
[ 1]) << 6
10571 | itoa64_to_int (input_buf
[ 2]) << 12
10572 | itoa64_to_int (input_buf
[ 3]) << 18;
10573 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10574 | itoa64_to_int (input_buf
[ 5]) << 6
10575 | itoa64_to_int (input_buf
[ 6]) << 12
10576 | itoa64_to_int (input_buf
[ 7]) << 18;
10577 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10578 | itoa64_to_int (input_buf
[ 9]) << 6
10579 | itoa64_to_int (input_buf
[10]) << 12
10580 | itoa64_to_int (input_buf
[11]) << 18;
10581 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10582 | itoa64_to_int (input_buf
[13]) << 6
10583 | itoa64_to_int (input_buf
[14]) << 12
10584 | itoa64_to_int (input_buf
[15]) << 18;
10586 digest
[0] -= MD5M_A
;
10587 digest
[1] -= MD5M_B
;
10588 digest
[2] -= MD5M_C
;
10589 digest
[3] -= MD5M_D
;
10591 digest
[0] &= 0x00ffffff;
10592 digest
[1] &= 0x00ffffff;
10593 digest
[2] &= 0x00ffffff;
10594 digest
[3] &= 0x00ffffff;
10596 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10598 uint salt_len
= input_len
- 16 - 1;
10600 char *salt_buf
= input_buf
+ 16 + 1;
10602 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10604 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10606 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10608 salt
->salt_len
= salt_len
;
10610 return (PARSER_OK
);
10613 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10615 key
[0] = (nthash
[0] >> 0);
10616 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10617 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10618 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10619 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10620 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10621 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10622 key
[7] = (nthash
[6] << 1);
10634 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10636 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10638 u32
*digest
= (u32
*) hash_buf
->digest
;
10640 salt_t
*salt
= hash_buf
->salt
;
10642 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10648 char *user_pos
= input_buf
;
10650 char *unused_pos
= strchr (user_pos
, ':');
10652 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10654 uint user_len
= unused_pos
- user_pos
;
10656 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10660 char *domain_pos
= strchr (unused_pos
, ':');
10662 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10664 uint unused_len
= domain_pos
- unused_pos
;
10666 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10670 char *srvchall_pos
= strchr (domain_pos
, ':');
10672 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10674 uint domain_len
= srvchall_pos
- domain_pos
;
10676 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10680 char *hash_pos
= strchr (srvchall_pos
, ':');
10682 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10684 uint srvchall_len
= hash_pos
- srvchall_pos
;
10686 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10690 char *clichall_pos
= strchr (hash_pos
, ':');
10692 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10694 uint hash_len
= clichall_pos
- hash_pos
;
10696 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10700 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10702 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10705 * store some data for later use
10708 netntlm
->user_len
= user_len
* 2;
10709 netntlm
->domain_len
= domain_len
* 2;
10710 netntlm
->srvchall_len
= srvchall_len
/ 2;
10711 netntlm
->clichall_len
= clichall_len
/ 2;
10713 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10714 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10717 * handle username and domainname
10720 for (uint i
= 0; i
< user_len
; i
++)
10722 *userdomain_ptr
++ = user_pos
[i
];
10723 *userdomain_ptr
++ = 0;
10726 for (uint i
= 0; i
< domain_len
; i
++)
10728 *userdomain_ptr
++ = domain_pos
[i
];
10729 *userdomain_ptr
++ = 0;
10733 * handle server challenge encoding
10736 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10738 const char p0
= srvchall_pos
[i
+ 0];
10739 const char p1
= srvchall_pos
[i
+ 1];
10741 *chall_ptr
++ = hex_convert (p1
) << 0
10742 | hex_convert (p0
) << 4;
10746 * handle client challenge encoding
10749 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10751 const char p0
= clichall_pos
[i
+ 0];
10752 const char p1
= clichall_pos
[i
+ 1];
10754 *chall_ptr
++ = hex_convert (p1
) << 0
10755 | hex_convert (p0
) << 4;
10762 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10764 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10766 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10768 salt
->salt_len
= salt_len
;
10770 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10771 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10772 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10773 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10775 digest
[0] = byte_swap_32 (digest
[0]);
10776 digest
[1] = byte_swap_32 (digest
[1]);
10777 digest
[2] = byte_swap_32 (digest
[2]);
10778 digest
[3] = byte_swap_32 (digest
[3]);
10780 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10782 uint digest_tmp
[2] = { 0 };
10784 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10785 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
10787 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10788 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10790 /* special case 2: ESS */
10792 if (srvchall_len
== 48)
10794 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10796 uint w
[16] = { 0 };
10798 w
[ 0] = netntlm
->chall_buf
[6];
10799 w
[ 1] = netntlm
->chall_buf
[7];
10800 w
[ 2] = netntlm
->chall_buf
[0];
10801 w
[ 3] = netntlm
->chall_buf
[1];
10805 uint dgst
[4] = { 0 };
10814 salt
->salt_buf
[0] = dgst
[0];
10815 salt
->salt_buf
[1] = dgst
[1];
10819 /* precompute netntlmv1 exploit start */
10821 for (uint i
= 0; i
< 0x10000; i
++)
10823 uint key_md4
[2] = { i
, 0 };
10824 uint key_des
[2] = { 0, 0 };
10826 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
10828 uint Kc
[16] = { 0 };
10829 uint Kd
[16] = { 0 };
10831 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10833 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10835 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10837 if (data3
[0] != digest_tmp
[0]) continue;
10838 if (data3
[1] != digest_tmp
[1]) continue;
10840 salt
->salt_buf
[2] = i
;
10842 salt
->salt_len
= 24;
10847 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10848 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10850 /* precompute netntlmv1 exploit stop */
10854 IP (digest
[0], digest
[1], tt
);
10855 IP (digest
[2], digest
[3], tt
);
10857 digest
[0] = rotr32 (digest
[0], 29);
10858 digest
[1] = rotr32 (digest
[1], 29);
10859 digest
[2] = rotr32 (digest
[2], 29);
10860 digest
[3] = rotr32 (digest
[3], 29);
10862 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10864 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
10865 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
10867 return (PARSER_OK
);
10870 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10872 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10874 u32
*digest
= (u32
*) hash_buf
->digest
;
10876 salt_t
*salt
= hash_buf
->salt
;
10878 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10884 char *user_pos
= input_buf
;
10886 char *unused_pos
= strchr (user_pos
, ':');
10888 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10890 uint user_len
= unused_pos
- user_pos
;
10892 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10896 char *domain_pos
= strchr (unused_pos
, ':');
10898 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10900 uint unused_len
= domain_pos
- unused_pos
;
10902 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10906 char *srvchall_pos
= strchr (domain_pos
, ':');
10908 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10910 uint domain_len
= srvchall_pos
- domain_pos
;
10912 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10916 char *hash_pos
= strchr (srvchall_pos
, ':');
10918 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10920 uint srvchall_len
= hash_pos
- srvchall_pos
;
10922 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
10926 char *clichall_pos
= strchr (hash_pos
, ':');
10928 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10930 uint hash_len
= clichall_pos
- hash_pos
;
10932 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
10936 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10938 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
10940 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
10943 * store some data for later use
10946 netntlm
->user_len
= user_len
* 2;
10947 netntlm
->domain_len
= domain_len
* 2;
10948 netntlm
->srvchall_len
= srvchall_len
/ 2;
10949 netntlm
->clichall_len
= clichall_len
/ 2;
10951 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10952 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10955 * handle username and domainname
10958 for (uint i
= 0; i
< user_len
; i
++)
10960 *userdomain_ptr
++ = toupper (user_pos
[i
]);
10961 *userdomain_ptr
++ = 0;
10964 for (uint i
= 0; i
< domain_len
; i
++)
10966 *userdomain_ptr
++ = domain_pos
[i
];
10967 *userdomain_ptr
++ = 0;
10970 *userdomain_ptr
++ = 0x80;
10973 * handle server challenge encoding
10976 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10978 const char p0
= srvchall_pos
[i
+ 0];
10979 const char p1
= srvchall_pos
[i
+ 1];
10981 *chall_ptr
++ = hex_convert (p1
) << 0
10982 | hex_convert (p0
) << 4;
10986 * handle client challenge encoding
10989 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10991 const char p0
= clichall_pos
[i
+ 0];
10992 const char p1
= clichall_pos
[i
+ 1];
10994 *chall_ptr
++ = hex_convert (p1
) << 0
10995 | hex_convert (p0
) << 4;
10998 *chall_ptr
++ = 0x80;
11001 * handle hash itself
11004 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11005 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11006 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11007 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11009 digest
[0] = byte_swap_32 (digest
[0]);
11010 digest
[1] = byte_swap_32 (digest
[1]);
11011 digest
[2] = byte_swap_32 (digest
[2]);
11012 digest
[3] = byte_swap_32 (digest
[3]);
11015 * reuse challange data as salt_buf, its the buffer that is most likely unique
11018 salt
->salt_buf
[0] = 0;
11019 salt
->salt_buf
[1] = 0;
11020 salt
->salt_buf
[2] = 0;
11021 salt
->salt_buf
[3] = 0;
11022 salt
->salt_buf
[4] = 0;
11023 salt
->salt_buf
[5] = 0;
11024 salt
->salt_buf
[6] = 0;
11025 salt
->salt_buf
[7] = 0;
11029 uptr
= (uint
*) netntlm
->userdomain_buf
;
11031 for (uint i
= 0; i
< 16; i
+= 16)
11033 md5_64 (uptr
, salt
->salt_buf
);
11036 uptr
= (uint
*) netntlm
->chall_buf
;
11038 for (uint i
= 0; i
< 256; i
+= 16)
11040 md5_64 (uptr
, salt
->salt_buf
);
11043 salt
->salt_len
= 16;
11045 return (PARSER_OK
);
11048 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11050 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11052 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11056 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11059 u32
*digest
= (u32
*) hash_buf
->digest
;
11061 salt_t
*salt
= hash_buf
->salt
;
11063 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11064 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11065 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11066 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11068 digest
[0] = byte_swap_32 (digest
[0]);
11069 digest
[1] = byte_swap_32 (digest
[1]);
11070 digest
[2] = byte_swap_32 (digest
[2]);
11071 digest
[3] = byte_swap_32 (digest
[3]);
11073 digest
[0] -= MD5M_A
;
11074 digest
[1] -= MD5M_B
;
11075 digest
[2] -= MD5M_C
;
11076 digest
[3] -= MD5M_D
;
11078 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11080 uint salt_len
= input_len
- 32 - 1;
11082 char *salt_buf
= input_buf
+ 32 + 1;
11084 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11086 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11088 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11090 salt
->salt_len
= salt_len
;
11092 return (PARSER_OK
);
11095 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11097 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11099 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11103 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11106 u32
*digest
= (u32
*) hash_buf
->digest
;
11108 salt_t
*salt
= hash_buf
->salt
;
11110 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11111 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11112 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11113 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11115 digest
[0] = byte_swap_32 (digest
[0]);
11116 digest
[1] = byte_swap_32 (digest
[1]);
11117 digest
[2] = byte_swap_32 (digest
[2]);
11118 digest
[3] = byte_swap_32 (digest
[3]);
11120 digest
[0] -= MD5M_A
;
11121 digest
[1] -= MD5M_B
;
11122 digest
[2] -= MD5M_C
;
11123 digest
[3] -= MD5M_D
;
11125 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11127 uint salt_len
= input_len
- 32 - 1;
11129 char *salt_buf
= input_buf
+ 32 + 1;
11131 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11133 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11135 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11137 salt
->salt_len
= salt_len
;
11139 return (PARSER_OK
);
11142 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11144 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11146 u32
*digest
= (u32
*) hash_buf
->digest
;
11148 salt_t
*salt
= hash_buf
->salt
;
11150 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11151 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11152 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11153 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11155 digest
[0] = byte_swap_32 (digest
[0]);
11156 digest
[1] = byte_swap_32 (digest
[1]);
11157 digest
[2] = byte_swap_32 (digest
[2]);
11158 digest
[3] = byte_swap_32 (digest
[3]);
11160 digest
[0] -= MD5M_A
;
11161 digest
[1] -= MD5M_B
;
11162 digest
[2] -= MD5M_C
;
11163 digest
[3] -= MD5M_D
;
11166 * This is a virtual salt. While the algorithm is basically not salted
11167 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11168 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11171 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11173 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11175 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11177 salt
->salt_len
= salt_len
;
11179 return (PARSER_OK
);
11182 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11184 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11186 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11190 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11193 u32
*digest
= (u32
*) hash_buf
->digest
;
11195 salt_t
*salt
= hash_buf
->salt
;
11197 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11198 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11199 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11200 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11202 digest
[0] = byte_swap_32 (digest
[0]);
11203 digest
[1] = byte_swap_32 (digest
[1]);
11204 digest
[2] = byte_swap_32 (digest
[2]);
11205 digest
[3] = byte_swap_32 (digest
[3]);
11207 digest
[0] -= MD5M_A
;
11208 digest
[1] -= MD5M_B
;
11209 digest
[2] -= MD5M_C
;
11210 digest
[3] -= MD5M_D
;
11212 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11214 uint salt_len
= input_len
- 32 - 1;
11216 char *salt_buf
= input_buf
+ 32 + 1;
11218 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11220 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11222 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11224 salt
->salt_len
= salt_len
;
11226 return (PARSER_OK
);
11229 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11231 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11233 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11237 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11240 u32
*digest
= (u32
*) hash_buf
->digest
;
11242 salt_t
*salt
= hash_buf
->salt
;
11244 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11245 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11246 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11247 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11249 digest
[0] = byte_swap_32 (digest
[0]);
11250 digest
[1] = byte_swap_32 (digest
[1]);
11251 digest
[2] = byte_swap_32 (digest
[2]);
11252 digest
[3] = byte_swap_32 (digest
[3]);
11254 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11256 uint salt_len
= input_len
- 32 - 1;
11258 char *salt_buf
= input_buf
+ 32 + 1;
11260 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11262 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11264 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11266 salt
->salt_len
= salt_len
;
11268 return (PARSER_OK
);
11271 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11273 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11275 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11279 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11282 u32
*digest
= (u32
*) hash_buf
->digest
;
11284 salt_t
*salt
= hash_buf
->salt
;
11286 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11287 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11288 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11289 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11291 digest
[0] = byte_swap_32 (digest
[0]);
11292 digest
[1] = byte_swap_32 (digest
[1]);
11293 digest
[2] = byte_swap_32 (digest
[2]);
11294 digest
[3] = byte_swap_32 (digest
[3]);
11296 digest
[0] -= MD4M_A
;
11297 digest
[1] -= MD4M_B
;
11298 digest
[2] -= MD4M_C
;
11299 digest
[3] -= MD4M_D
;
11301 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11303 uint salt_len
= input_len
- 32 - 1;
11305 char *salt_buf
= input_buf
+ 32 + 1;
11307 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11309 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11311 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11313 salt
->salt_len
= salt_len
;
11315 return (PARSER_OK
);
11318 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11320 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11322 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11326 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11329 u32
*digest
= (u32
*) hash_buf
->digest
;
11331 salt_t
*salt
= hash_buf
->salt
;
11333 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11334 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11335 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11336 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11338 digest
[0] = byte_swap_32 (digest
[0]);
11339 digest
[1] = byte_swap_32 (digest
[1]);
11340 digest
[2] = byte_swap_32 (digest
[2]);
11341 digest
[3] = byte_swap_32 (digest
[3]);
11343 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11345 uint salt_len
= input_len
- 32 - 1;
11347 char *salt_buf
= input_buf
+ 32 + 1;
11349 uint salt_pc_block
[16] = { 0 };
11351 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11353 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11355 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11357 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11359 salt_pc_block
[14] = salt_len
* 8;
11361 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11363 md5_64 (salt_pc_block
, salt_pc_digest
);
11365 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11366 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11367 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11368 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11370 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11372 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11374 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11376 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11377 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11378 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11379 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11381 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11383 return (PARSER_OK
);
11386 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11388 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11390 u32
*digest
= (u32
*) hash_buf
->digest
;
11392 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11393 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11394 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11395 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11396 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11398 digest
[0] -= SHA1M_A
;
11399 digest
[1] -= SHA1M_B
;
11400 digest
[2] -= SHA1M_C
;
11401 digest
[3] -= SHA1M_D
;
11402 digest
[4] -= SHA1M_E
;
11404 return (PARSER_OK
);
11407 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11409 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11411 u32
*digest
= (u32
*) hash_buf
->digest
;
11413 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11414 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11415 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11416 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11417 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11419 return (PARSER_OK
);
11422 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11424 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11426 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11430 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11433 u32
*digest
= (u32
*) hash_buf
->digest
;
11435 salt_t
*salt
= hash_buf
->salt
;
11437 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11438 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11439 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11440 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11441 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11443 digest
[0] -= SHA1M_A
;
11444 digest
[1] -= SHA1M_B
;
11445 digest
[2] -= SHA1M_C
;
11446 digest
[3] -= SHA1M_D
;
11447 digest
[4] -= SHA1M_E
;
11449 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11451 uint salt_len
= input_len
- 40 - 1;
11453 char *salt_buf
= input_buf
+ 40 + 1;
11455 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11457 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11459 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11461 salt
->salt_len
= salt_len
;
11463 return (PARSER_OK
);
11466 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11468 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11470 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11472 u32
*digest
= (u32
*) hash_buf
->digest
;
11474 u8 tmp_buf
[100] = { 0 };
11476 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11478 memcpy (digest
, tmp_buf
, 20);
11480 digest
[0] = byte_swap_32 (digest
[0]);
11481 digest
[1] = byte_swap_32 (digest
[1]);
11482 digest
[2] = byte_swap_32 (digest
[2]);
11483 digest
[3] = byte_swap_32 (digest
[3]);
11484 digest
[4] = byte_swap_32 (digest
[4]);
11486 digest
[0] -= SHA1M_A
;
11487 digest
[1] -= SHA1M_B
;
11488 digest
[2] -= SHA1M_C
;
11489 digest
[3] -= SHA1M_D
;
11490 digest
[4] -= SHA1M_E
;
11492 return (PARSER_OK
);
11495 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11497 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11499 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11501 u32
*digest
= (u32
*) hash_buf
->digest
;
11503 salt_t
*salt
= hash_buf
->salt
;
11505 u8 tmp_buf
[100] = { 0 };
11507 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11509 memcpy (digest
, tmp_buf
, 20);
11511 salt
->salt_len
= tmp_len
- 20;
11513 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11515 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11517 char *ptr
= (char *) salt
->salt_buf
;
11519 ptr
[salt
->salt_len
] = 0x80;
11522 digest
[0] = byte_swap_32 (digest
[0]);
11523 digest
[1] = byte_swap_32 (digest
[1]);
11524 digest
[2] = byte_swap_32 (digest
[2]);
11525 digest
[3] = byte_swap_32 (digest
[3]);
11526 digest
[4] = byte_swap_32 (digest
[4]);
11528 digest
[0] -= SHA1M_A
;
11529 digest
[1] -= SHA1M_B
;
11530 digest
[2] -= SHA1M_C
;
11531 digest
[3] -= SHA1M_D
;
11532 digest
[4] -= SHA1M_E
;
11534 return (PARSER_OK
);
11537 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11539 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11541 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11543 u32
*digest
= (u32
*) hash_buf
->digest
;
11545 salt_t
*salt
= hash_buf
->salt
;
11547 char *salt_buf
= input_buf
+ 6;
11551 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11553 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11555 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11557 salt
->salt_len
= salt_len
;
11559 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11561 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11562 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11563 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11564 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11565 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11567 digest
[0] -= SHA1M_A
;
11568 digest
[1] -= SHA1M_B
;
11569 digest
[2] -= SHA1M_C
;
11570 digest
[3] -= SHA1M_D
;
11571 digest
[4] -= SHA1M_E
;
11573 return (PARSER_OK
);
11576 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11578 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11580 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11582 u32
*digest
= (u32
*) hash_buf
->digest
;
11584 salt_t
*salt
= hash_buf
->salt
;
11586 char *salt_buf
= input_buf
+ 6;
11590 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11592 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11594 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11596 salt
->salt_len
= salt_len
;
11598 char *hash_pos
= input_buf
+ 6 + 8;
11600 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11601 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11602 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11603 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11604 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11606 digest
[0] -= SHA1M_A
;
11607 digest
[1] -= SHA1M_B
;
11608 digest
[2] -= SHA1M_C
;
11609 digest
[3] -= SHA1M_D
;
11610 digest
[4] -= SHA1M_E
;
11612 return (PARSER_OK
);
11615 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11617 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11619 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11621 u64
*digest
= (u64
*) hash_buf
->digest
;
11623 salt_t
*salt
= hash_buf
->salt
;
11625 char *salt_buf
= input_buf
+ 6;
11629 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11631 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11633 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11635 salt
->salt_len
= salt_len
;
11637 char *hash_pos
= input_buf
+ 6 + 8;
11639 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11640 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11641 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11642 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11643 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11644 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11645 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11646 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11648 digest
[0] -= SHA512M_A
;
11649 digest
[1] -= SHA512M_B
;
11650 digest
[2] -= SHA512M_C
;
11651 digest
[3] -= SHA512M_D
;
11652 digest
[4] -= SHA512M_E
;
11653 digest
[5] -= SHA512M_F
;
11654 digest
[6] -= SHA512M_G
;
11655 digest
[7] -= SHA512M_H
;
11657 return (PARSER_OK
);
11660 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11662 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11664 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11668 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11671 u32
*digest
= (u32
*) hash_buf
->digest
;
11673 salt_t
*salt
= hash_buf
->salt
;
11675 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11676 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11680 digest
[0] = byte_swap_32 (digest
[0]);
11681 digest
[1] = byte_swap_32 (digest
[1]);
11683 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11685 uint salt_len
= input_len
- 16 - 1;
11687 char *salt_buf
= input_buf
+ 16 + 1;
11689 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11691 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11693 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11695 salt
->salt_len
= salt_len
;
11697 return (PARSER_OK
);
11700 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11702 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11704 u32
*digest
= (u32
*) hash_buf
->digest
;
11706 salt_t
*salt
= hash_buf
->salt
;
11708 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11709 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11710 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11711 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11712 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11714 digest
[0] -= SHA1M_A
;
11715 digest
[1] -= SHA1M_B
;
11716 digest
[2] -= SHA1M_C
;
11717 digest
[3] -= SHA1M_D
;
11718 digest
[4] -= SHA1M_E
;
11720 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11722 uint salt_len
= input_len
- 40 - 1;
11724 char *salt_buf
= input_buf
+ 40 + 1;
11726 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11728 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11730 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11732 salt
->salt_len
= salt_len
;
11734 return (PARSER_OK
);
11737 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11739 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11741 u32
*digest
= (u32
*) hash_buf
->digest
;
11743 salt_t
*salt
= hash_buf
->salt
;
11745 char *hash_pos
= input_buf
;
11747 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11748 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11749 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
11750 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
11751 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
11752 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
11753 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
11754 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
11755 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
11756 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
11757 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
11758 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
11759 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
11760 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
11761 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
11762 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
11764 char *salt_pos
= input_buf
+ 128;
11766 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
11767 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
11768 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
11769 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
11771 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11772 salt
->salt_len
= 16;
11774 return (PARSER_OK
);
11777 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11779 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11781 u32
*digest
= (u32
*) hash_buf
->digest
;
11783 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11784 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11785 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11786 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11787 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11788 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11789 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11790 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11792 digest
[0] -= SHA256M_A
;
11793 digest
[1] -= SHA256M_B
;
11794 digest
[2] -= SHA256M_C
;
11795 digest
[3] -= SHA256M_D
;
11796 digest
[4] -= SHA256M_E
;
11797 digest
[5] -= SHA256M_F
;
11798 digest
[6] -= SHA256M_G
;
11799 digest
[7] -= SHA256M_H
;
11801 return (PARSER_OK
);
11804 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11806 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11808 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11812 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11815 u32
*digest
= (u32
*) hash_buf
->digest
;
11817 salt_t
*salt
= hash_buf
->salt
;
11819 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11820 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11821 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11822 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11823 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11824 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11825 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11826 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11828 digest
[0] -= SHA256M_A
;
11829 digest
[1] -= SHA256M_B
;
11830 digest
[2] -= SHA256M_C
;
11831 digest
[3] -= SHA256M_D
;
11832 digest
[4] -= SHA256M_E
;
11833 digest
[5] -= SHA256M_F
;
11834 digest
[6] -= SHA256M_G
;
11835 digest
[7] -= SHA256M_H
;
11837 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11839 uint salt_len
= input_len
- 64 - 1;
11841 char *salt_buf
= input_buf
+ 64 + 1;
11843 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11845 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11847 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11849 salt
->salt_len
= salt_len
;
11851 return (PARSER_OK
);
11854 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11856 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11858 u64
*digest
= (u64
*) hash_buf
->digest
;
11860 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11861 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11862 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11863 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11864 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11865 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11869 digest
[0] -= SHA384M_A
;
11870 digest
[1] -= SHA384M_B
;
11871 digest
[2] -= SHA384M_C
;
11872 digest
[3] -= SHA384M_D
;
11873 digest
[4] -= SHA384M_E
;
11874 digest
[5] -= SHA384M_F
;
11878 return (PARSER_OK
);
11881 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11883 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
11885 u64
*digest
= (u64
*) hash_buf
->digest
;
11887 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11888 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11889 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11890 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11891 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11892 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11893 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11894 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11896 digest
[0] -= SHA512M_A
;
11897 digest
[1] -= SHA512M_B
;
11898 digest
[2] -= SHA512M_C
;
11899 digest
[3] -= SHA512M_D
;
11900 digest
[4] -= SHA512M_E
;
11901 digest
[5] -= SHA512M_F
;
11902 digest
[6] -= SHA512M_G
;
11903 digest
[7] -= SHA512M_H
;
11905 return (PARSER_OK
);
11908 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11910 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11912 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
11916 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
11919 u64
*digest
= (u64
*) hash_buf
->digest
;
11921 salt_t
*salt
= hash_buf
->salt
;
11923 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11924 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11925 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11926 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11927 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11928 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11929 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11930 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11932 digest
[0] -= SHA512M_A
;
11933 digest
[1] -= SHA512M_B
;
11934 digest
[2] -= SHA512M_C
;
11935 digest
[3] -= SHA512M_D
;
11936 digest
[4] -= SHA512M_E
;
11937 digest
[5] -= SHA512M_F
;
11938 digest
[6] -= SHA512M_G
;
11939 digest
[7] -= SHA512M_H
;
11941 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11943 uint salt_len
= input_len
- 128 - 1;
11945 char *salt_buf
= input_buf
+ 128 + 1;
11947 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11949 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11951 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11953 salt
->salt_len
= salt_len
;
11955 return (PARSER_OK
);
11958 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11960 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
11962 u64
*digest
= (u64
*) hash_buf
->digest
;
11964 salt_t
*salt
= hash_buf
->salt
;
11966 char *salt_pos
= input_buf
+ 3;
11968 uint iterations_len
= 0;
11970 if (memcmp (salt_pos
, "rounds=", 7) == 0)
11974 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
11976 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
11977 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
11981 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
11985 iterations_len
+= 8;
11989 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
11992 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
11994 char *hash_pos
= strchr (salt_pos
, '$');
11996 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11998 uint salt_len
= hash_pos
- salt_pos
;
12000 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12002 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12004 salt
->salt_len
= salt_len
;
12008 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12010 return (PARSER_OK
);
12013 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12015 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12017 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12019 u64
*digest
= (u64
*) hash_buf
->digest
;
12021 salt_t
*salt
= hash_buf
->salt
;
12023 uint keccak_mdlen
= input_len
/ 2;
12025 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12027 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12029 digest
[i
] = byte_swap_64 (digest
[i
]);
12032 salt
->keccak_mdlen
= keccak_mdlen
;
12034 return (PARSER_OK
);
12037 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12039 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12041 u32
*digest
= (u32
*) hash_buf
->digest
;
12043 salt_t
*salt
= hash_buf
->salt
;
12045 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12048 * Parse that strange long line
12053 size_t in_len
[9] = { 0 };
12055 in_off
[0] = strtok (input_buf
, ":");
12057 in_len
[0] = strlen (in_off
[0]);
12061 for (i
= 1; i
< 9; i
++)
12063 in_off
[i
] = strtok (NULL
, ":");
12065 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12067 in_len
[i
] = strlen (in_off
[i
]);
12070 char *ptr
= (char *) ikepsk
->msg_buf
;
12072 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12073 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12074 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12075 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12076 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12077 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12081 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12083 ptr
= (char *) ikepsk
->nr_buf
;
12085 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12086 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12090 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12093 * Store to database
12098 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12099 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12100 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12101 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12103 digest
[0] = byte_swap_32 (digest
[0]);
12104 digest
[1] = byte_swap_32 (digest
[1]);
12105 digest
[2] = byte_swap_32 (digest
[2]);
12106 digest
[3] = byte_swap_32 (digest
[3]);
12108 salt
->salt_len
= 32;
12110 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12111 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12112 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12113 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12114 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12115 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12116 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12117 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12119 return (PARSER_OK
);
12122 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12124 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12126 u32
*digest
= (u32
*) hash_buf
->digest
;
12128 salt_t
*salt
= hash_buf
->salt
;
12130 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12133 * Parse that strange long line
12138 size_t in_len
[9] = { 0 };
12140 in_off
[0] = strtok (input_buf
, ":");
12142 in_len
[0] = strlen (in_off
[0]);
12146 for (i
= 1; i
< 9; i
++)
12148 in_off
[i
] = strtok (NULL
, ":");
12150 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12152 in_len
[i
] = strlen (in_off
[i
]);
12155 char *ptr
= (char *) ikepsk
->msg_buf
;
12157 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12158 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12159 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12160 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12161 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12162 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12166 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12168 ptr
= (char *) ikepsk
->nr_buf
;
12170 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12171 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12175 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12178 * Store to database
12183 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12184 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12185 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12186 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12187 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12189 salt
->salt_len
= 32;
12191 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12192 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12193 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12194 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12195 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12196 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12197 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12198 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12200 return (PARSER_OK
);
12203 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12205 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12207 u32
*digest
= (u32
*) hash_buf
->digest
;
12209 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12210 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12211 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12212 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12213 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12215 digest
[0] = byte_swap_32 (digest
[0]);
12216 digest
[1] = byte_swap_32 (digest
[1]);
12217 digest
[2] = byte_swap_32 (digest
[2]);
12218 digest
[3] = byte_swap_32 (digest
[3]);
12219 digest
[4] = byte_swap_32 (digest
[4]);
12221 return (PARSER_OK
);
12224 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12226 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12228 u32
*digest
= (u32
*) hash_buf
->digest
;
12230 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12231 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12232 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12233 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12234 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12235 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12236 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12237 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12238 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12239 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12240 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12241 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12242 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12243 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12244 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12245 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12247 return (PARSER_OK
);
12250 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12252 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12254 u32
*digest
= (u32
*) hash_buf
->digest
;
12256 salt_t
*salt
= hash_buf
->salt
;
12258 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12259 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12260 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12261 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12262 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12264 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12266 uint salt_len
= input_len
- 40 - 1;
12268 char *salt_buf
= input_buf
+ 40 + 1;
12270 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12272 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12274 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12276 salt
->salt_len
= salt_len
;
12278 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12280 return (PARSER_OK
);
12283 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12285 u32
*digest
= (u32
*) hash_buf
->digest
;
12287 salt_t
*salt
= hash_buf
->salt
;
12289 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12291 if (input_len
== 0)
12293 log_error ("TrueCrypt container not specified");
12298 FILE *fp
= fopen (input_buf
, "rb");
12302 log_error ("%s: %s", input_buf
, strerror (errno
));
12307 char buf
[512] = { 0 };
12309 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12313 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12315 memcpy (tc
->salt_buf
, buf
, 64);
12317 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12319 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12321 salt
->salt_len
= 4;
12323 salt
->salt_iter
= 1000 - 1;
12325 digest
[0] = tc
->data_buf
[0];
12327 return (PARSER_OK
);
12330 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12332 u32
*digest
= (u32
*) hash_buf
->digest
;
12334 salt_t
*salt
= hash_buf
->salt
;
12336 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12338 if (input_len
== 0)
12340 log_error ("TrueCrypt container not specified");
12345 FILE *fp
= fopen (input_buf
, "rb");
12349 log_error ("%s: %s", input_buf
, strerror (errno
));
12354 char buf
[512] = { 0 };
12356 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12360 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12362 memcpy (tc
->salt_buf
, buf
, 64);
12364 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12366 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12368 salt
->salt_len
= 4;
12370 salt
->salt_iter
= 2000 - 1;
12372 digest
[0] = tc
->data_buf
[0];
12374 return (PARSER_OK
);
12377 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12379 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12381 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12383 u32
*digest
= (u32
*) hash_buf
->digest
;
12385 salt_t
*salt
= hash_buf
->salt
;
12387 char *salt_pos
= input_buf
+ 6;
12389 char *hash_pos
= strchr (salt_pos
, '$');
12391 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12393 uint salt_len
= hash_pos
- salt_pos
;
12395 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12397 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12399 salt
->salt_len
= salt_len
;
12401 salt
->salt_iter
= 1000;
12405 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12407 return (PARSER_OK
);
12410 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12412 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12414 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12416 u32
*digest
= (u32
*) hash_buf
->digest
;
12418 salt_t
*salt
= hash_buf
->salt
;
12420 char *iter_pos
= input_buf
+ 7;
12422 char *salt_pos
= strchr (iter_pos
, '$');
12424 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12428 char *hash_pos
= strchr (salt_pos
, '$');
12430 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12432 uint salt_len
= hash_pos
- salt_pos
;
12434 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12436 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12438 salt
->salt_len
= salt_len
;
12440 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12442 salt
->salt_sign
[0] = atoi (salt_iter
);
12444 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12448 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12450 digest
[0] = byte_swap_32 (digest
[0]);
12451 digest
[1] = byte_swap_32 (digest
[1]);
12452 digest
[2] = byte_swap_32 (digest
[2]);
12453 digest
[3] = byte_swap_32 (digest
[3]);
12454 digest
[4] = byte_swap_32 (digest
[4]);
12456 return (PARSER_OK
);
12459 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12461 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12463 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12465 u32
*digest
= (u32
*) hash_buf
->digest
;
12467 salt_t
*salt
= hash_buf
->salt
;
12469 char *iter_pos
= input_buf
+ 9;
12471 char *salt_pos
= strchr (iter_pos
, '$');
12473 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12477 char *hash_pos
= strchr (salt_pos
, '$');
12479 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12481 uint salt_len
= hash_pos
- salt_pos
;
12483 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12485 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12487 salt
->salt_len
= salt_len
;
12489 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12491 salt
->salt_sign
[0] = atoi (salt_iter
);
12493 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12497 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12499 digest
[0] = byte_swap_32 (digest
[0]);
12500 digest
[1] = byte_swap_32 (digest
[1]);
12501 digest
[2] = byte_swap_32 (digest
[2]);
12502 digest
[3] = byte_swap_32 (digest
[3]);
12503 digest
[4] = byte_swap_32 (digest
[4]);
12504 digest
[5] = byte_swap_32 (digest
[5]);
12505 digest
[6] = byte_swap_32 (digest
[6]);
12506 digest
[7] = byte_swap_32 (digest
[7]);
12508 return (PARSER_OK
);
12511 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12513 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12515 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12517 u64
*digest
= (u64
*) hash_buf
->digest
;
12519 salt_t
*salt
= hash_buf
->salt
;
12521 char *iter_pos
= input_buf
+ 9;
12523 char *salt_pos
= strchr (iter_pos
, '$');
12525 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12529 char *hash_pos
= strchr (salt_pos
, '$');
12531 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12533 uint salt_len
= hash_pos
- salt_pos
;
12535 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12537 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12539 salt
->salt_len
= salt_len
;
12541 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12543 salt
->salt_sign
[0] = atoi (salt_iter
);
12545 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12549 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12551 digest
[0] = byte_swap_64 (digest
[0]);
12552 digest
[1] = byte_swap_64 (digest
[1]);
12553 digest
[2] = byte_swap_64 (digest
[2]);
12554 digest
[3] = byte_swap_64 (digest
[3]);
12555 digest
[4] = byte_swap_64 (digest
[4]);
12556 digest
[5] = byte_swap_64 (digest
[5]);
12557 digest
[6] = byte_swap_64 (digest
[6]);
12558 digest
[7] = byte_swap_64 (digest
[7]);
12560 return (PARSER_OK
);
12563 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12565 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12567 u32
*digest
= (u32
*) hash_buf
->digest
;
12569 salt_t
*salt
= hash_buf
->salt
;
12571 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12577 char *iterations_pos
= input_buf
;
12579 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12581 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12583 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12585 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12589 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12591 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12593 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12595 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12597 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12599 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12604 * pbkdf2 iterations
12607 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12610 * handle salt encoding
12613 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12615 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12617 const char p0
= saltbuf_pos
[i
+ 0];
12618 const char p1
= saltbuf_pos
[i
+ 1];
12620 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12621 | hex_convert (p0
) << 4;
12624 salt
->salt_len
= saltbuf_len
/ 2;
12627 * handle cipher encoding
12630 uint
*tmp
= (uint
*) mymalloc (32);
12632 char *cipherbuf_ptr
= (char *) tmp
;
12634 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12636 const char p0
= cipherbuf_pos
[i
+ 0];
12637 const char p1
= cipherbuf_pos
[i
+ 1];
12639 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12640 | hex_convert (p0
) << 4;
12643 // iv is stored at salt_buf 4 (length 16)
12644 // data is stored at salt_buf 8 (length 16)
12646 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12647 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12648 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12649 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12651 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12652 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12653 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12654 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12658 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12660 const char p0
= cipherbuf_pos
[j
+ 0];
12661 const char p1
= cipherbuf_pos
[j
+ 1];
12663 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12664 | hex_convert (p0
) << 4;
12671 digest
[0] = 0x10101010;
12672 digest
[1] = 0x10101010;
12673 digest
[2] = 0x10101010;
12674 digest
[3] = 0x10101010;
12676 return (PARSER_OK
);
12679 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12681 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12683 u32
*digest
= (u32
*) hash_buf
->digest
;
12685 salt_t
*salt
= hash_buf
->salt
;
12687 char *hashbuf_pos
= input_buf
;
12689 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12691 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12693 uint hash_len
= iterations_pos
- hashbuf_pos
;
12695 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12699 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12701 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12703 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12707 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12709 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12711 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12713 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12715 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12717 salt
->salt_len
= salt_len
;
12719 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12721 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
12722 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
12723 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
12724 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
12726 return (PARSER_OK
);
12729 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12731 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12733 u32
*digest
= (u32
*) hash_buf
->digest
;
12735 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12736 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12737 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12738 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12739 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12740 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12741 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12742 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12744 digest
[0] = byte_swap_32 (digest
[0]);
12745 digest
[1] = byte_swap_32 (digest
[1]);
12746 digest
[2] = byte_swap_32 (digest
[2]);
12747 digest
[3] = byte_swap_32 (digest
[3]);
12748 digest
[4] = byte_swap_32 (digest
[4]);
12749 digest
[5] = byte_swap_32 (digest
[5]);
12750 digest
[6] = byte_swap_32 (digest
[6]);
12751 digest
[7] = byte_swap_32 (digest
[7]);
12753 return (PARSER_OK
);
12756 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12758 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12760 u32
*digest
= (u32
*) hash_buf
->digest
;
12762 salt_t
*salt
= hash_buf
->salt
;
12764 char *salt_pos
= input_buf
+ 3;
12766 uint iterations_len
= 0;
12768 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12772 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12774 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12775 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12779 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12783 iterations_len
+= 8;
12787 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12790 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12792 char *hash_pos
= strchr (salt_pos
, '$');
12794 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12796 uint salt_len
= hash_pos
- salt_pos
;
12798 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12800 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12802 salt
->salt_len
= salt_len
;
12806 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12808 return (PARSER_OK
);
12811 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12813 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12815 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12817 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12819 u64
*digest
= (u64
*) hash_buf
->digest
;
12821 salt_t
*salt
= hash_buf
->salt
;
12823 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12825 char *iter_pos
= input_buf
+ 4;
12827 char *salt_pos
= strchr (iter_pos
, '$');
12829 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12833 char *hash_pos
= strchr (salt_pos
, '$');
12835 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12837 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12841 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12842 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12843 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12844 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12845 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12846 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12847 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12848 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12850 uint salt_len
= hash_pos
- salt_pos
- 1;
12852 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12854 salt
->salt_len
= salt_len
/ 2;
12856 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12857 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12858 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12859 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12860 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
12861 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
12862 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
12863 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
12865 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12866 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12867 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12868 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12869 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12870 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12871 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12872 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12873 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12874 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12876 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12878 salt
->salt_iter
= atoi (iter_pos
) - 1;
12880 return (PARSER_OK
);
12883 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12885 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12887 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12889 u32
*digest
= (u32
*) hash_buf
->digest
;
12891 salt_t
*salt
= hash_buf
->salt
;
12893 char *salt_pos
= input_buf
+ 14;
12895 char *hash_pos
= strchr (salt_pos
, '*');
12897 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12901 uint salt_len
= hash_pos
- salt_pos
- 1;
12903 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12905 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
12907 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12909 salt
->salt_len
= salt_len
;
12911 u8 tmp_buf
[100] = { 0 };
12913 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
12915 memcpy (digest
, tmp_buf
, 32);
12917 digest
[0] = byte_swap_32 (digest
[0]);
12918 digest
[1] = byte_swap_32 (digest
[1]);
12919 digest
[2] = byte_swap_32 (digest
[2]);
12920 digest
[3] = byte_swap_32 (digest
[3]);
12921 digest
[4] = byte_swap_32 (digest
[4]);
12922 digest
[5] = byte_swap_32 (digest
[5]);
12923 digest
[6] = byte_swap_32 (digest
[6]);
12924 digest
[7] = byte_swap_32 (digest
[7]);
12926 digest
[0] -= SHA256M_A
;
12927 digest
[1] -= SHA256M_B
;
12928 digest
[2] -= SHA256M_C
;
12929 digest
[3] -= SHA256M_D
;
12930 digest
[4] -= SHA256M_E
;
12931 digest
[5] -= SHA256M_F
;
12932 digest
[6] -= SHA256M_G
;
12933 digest
[7] -= SHA256M_H
;
12935 return (PARSER_OK
);
12938 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12940 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
12942 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12944 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
12946 u64
*digest
= (u64
*) hash_buf
->digest
;
12948 salt_t
*salt
= hash_buf
->salt
;
12950 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12952 char *iter_pos
= input_buf
+ 19;
12954 char *salt_pos
= strchr (iter_pos
, '.');
12956 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12960 char *hash_pos
= strchr (salt_pos
, '.');
12962 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12964 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12968 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12969 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12970 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12971 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12972 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12973 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12974 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12975 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12977 uint salt_len
= hash_pos
- salt_pos
- 1;
12981 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
12985 for (i
= 0; i
< salt_len
; i
++)
12987 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
12990 salt_buf_ptr
[salt_len
+ 3] = 0x01;
12991 salt_buf_ptr
[salt_len
+ 4] = 0x80;
12993 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12995 salt
->salt_len
= salt_len
;
12997 salt
->salt_iter
= atoi (iter_pos
) - 1;
12999 return (PARSER_OK
);
13002 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13004 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13006 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13008 u64
*digest
= (u64
*) hash_buf
->digest
;
13010 salt_t
*salt
= hash_buf
->salt
;
13012 u8 tmp_buf
[120] = { 0 };
13014 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13016 memcpy (digest
, tmp_buf
, 64);
13018 digest
[0] = byte_swap_64 (digest
[0]);
13019 digest
[1] = byte_swap_64 (digest
[1]);
13020 digest
[2] = byte_swap_64 (digest
[2]);
13021 digest
[3] = byte_swap_64 (digest
[3]);
13022 digest
[4] = byte_swap_64 (digest
[4]);
13023 digest
[5] = byte_swap_64 (digest
[5]);
13024 digest
[6] = byte_swap_64 (digest
[6]);
13025 digest
[7] = byte_swap_64 (digest
[7]);
13027 digest
[0] -= SHA512M_A
;
13028 digest
[1] -= SHA512M_B
;
13029 digest
[2] -= SHA512M_C
;
13030 digest
[3] -= SHA512M_D
;
13031 digest
[4] -= SHA512M_E
;
13032 digest
[5] -= SHA512M_F
;
13033 digest
[6] -= SHA512M_G
;
13034 digest
[7] -= SHA512M_H
;
13036 salt
->salt_len
= tmp_len
- 64;
13038 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13040 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13042 char *ptr
= (char *) salt
->salt_buf
;
13044 ptr
[salt
->salt_len
] = 0x80;
13047 return (PARSER_OK
);
13050 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13052 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13054 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13058 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13061 u32
*digest
= (u32
*) hash_buf
->digest
;
13063 salt_t
*salt
= hash_buf
->salt
;
13065 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13066 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13067 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13068 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13070 digest
[0] = byte_swap_32 (digest
[0]);
13071 digest
[1] = byte_swap_32 (digest
[1]);
13072 digest
[2] = byte_swap_32 (digest
[2]);
13073 digest
[3] = byte_swap_32 (digest
[3]);
13075 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13077 uint salt_len
= input_len
- 32 - 1;
13079 char *salt_buf
= input_buf
+ 32 + 1;
13081 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13083 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13085 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13087 salt
->salt_len
= salt_len
;
13089 return (PARSER_OK
);
13092 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13094 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13096 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13100 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13103 u32
*digest
= (u32
*) hash_buf
->digest
;
13105 salt_t
*salt
= hash_buf
->salt
;
13107 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13108 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13109 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13110 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13111 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13113 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13115 uint salt_len
= input_len
- 40 - 1;
13117 char *salt_buf
= input_buf
+ 40 + 1;
13119 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13121 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13123 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13125 salt
->salt_len
= salt_len
;
13127 return (PARSER_OK
);
13130 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13132 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13134 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13138 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13141 u32
*digest
= (u32
*) hash_buf
->digest
;
13143 salt_t
*salt
= hash_buf
->salt
;
13145 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13146 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13147 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13148 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13149 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13150 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13151 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13152 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13154 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13156 uint salt_len
= input_len
- 64 - 1;
13158 char *salt_buf
= input_buf
+ 64 + 1;
13160 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13162 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13164 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13166 salt
->salt_len
= salt_len
;
13168 return (PARSER_OK
);
13171 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13173 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13175 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13179 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13182 u64
*digest
= (u64
*) hash_buf
->digest
;
13184 salt_t
*salt
= hash_buf
->salt
;
13186 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13187 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13188 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13189 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13190 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13191 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13192 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13193 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13195 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13197 uint salt_len
= input_len
- 128 - 1;
13199 char *salt_buf
= input_buf
+ 128 + 1;
13201 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13203 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13205 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13207 salt
->salt_len
= salt_len
;
13209 return (PARSER_OK
);
13212 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13214 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13216 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13218 u32
*digest
= (u32
*) hash_buf
->digest
;
13220 salt_t
*salt
= hash_buf
->salt
;
13222 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13228 char *user_pos
= input_buf
+ 10 + 1;
13230 char *realm_pos
= strchr (user_pos
, '$');
13232 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13234 uint user_len
= realm_pos
- user_pos
;
13236 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13240 char *salt_pos
= strchr (realm_pos
, '$');
13242 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13244 uint realm_len
= salt_pos
- realm_pos
;
13246 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13250 char *data_pos
= strchr (salt_pos
, '$');
13252 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13254 uint salt_len
= data_pos
- salt_pos
;
13256 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13260 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13262 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13268 memcpy (krb5pa
->user
, user_pos
, user_len
);
13269 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13270 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13272 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13274 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13276 const char p0
= data_pos
[i
+ 0];
13277 const char p1
= data_pos
[i
+ 1];
13279 *timestamp_ptr
++ = hex_convert (p1
) << 0
13280 | hex_convert (p0
) << 4;
13283 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13285 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13287 const char p0
= data_pos
[i
+ 0];
13288 const char p1
= data_pos
[i
+ 1];
13290 *checksum_ptr
++ = hex_convert (p1
) << 0
13291 | hex_convert (p0
) << 4;
13295 * copy some data to generic buffers to make sorting happy
13298 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13299 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13300 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13301 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13302 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13303 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13304 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13305 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13306 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13308 salt
->salt_len
= 36;
13310 digest
[0] = krb5pa
->checksum
[0];
13311 digest
[1] = krb5pa
->checksum
[1];
13312 digest
[2] = krb5pa
->checksum
[2];
13313 digest
[3] = krb5pa
->checksum
[3];
13315 return (PARSER_OK
);
13318 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13320 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13322 u32
*digest
= (u32
*) hash_buf
->digest
;
13324 salt_t
*salt
= hash_buf
->salt
;
13330 char *salt_pos
= input_buf
;
13332 char *hash_pos
= strchr (salt_pos
, '$');
13334 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13336 uint salt_len
= hash_pos
- salt_pos
;
13338 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13342 uint hash_len
= input_len
- 1 - salt_len
;
13344 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13352 for (uint i
= 0; i
< salt_len
; i
++)
13354 if (salt_pos
[i
] == ' ') continue;
13359 // SAP user names cannot be longer than 12 characters
13360 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13362 // SAP user name cannot start with ! or ?
13363 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13369 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13371 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13373 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13375 salt
->salt_len
= salt_len
;
13377 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13378 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13382 digest
[0] = byte_swap_32 (digest
[0]);
13383 digest
[1] = byte_swap_32 (digest
[1]);
13385 return (PARSER_OK
);
13388 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13390 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13392 u32
*digest
= (u32
*) hash_buf
->digest
;
13394 salt_t
*salt
= hash_buf
->salt
;
13400 char *salt_pos
= input_buf
;
13402 char *hash_pos
= strchr (salt_pos
, '$');
13404 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13406 uint salt_len
= hash_pos
- salt_pos
;
13408 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13412 uint hash_len
= input_len
- 1 - salt_len
;
13414 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13422 for (uint i
= 0; i
< salt_len
; i
++)
13424 if (salt_pos
[i
] == ' ') continue;
13429 // SAP user names cannot be longer than 12 characters
13430 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13431 // so far nobody complained so we stay with this because it helps in optimization
13432 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13434 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13436 // SAP user name cannot start with ! or ?
13437 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13443 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13445 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13447 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13449 salt
->salt_len
= salt_len
;
13451 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13452 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13453 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13454 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13455 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13457 return (PARSER_OK
);
13460 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13462 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13464 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13466 u64
*digest
= (u64
*) hash_buf
->digest
;
13468 salt_t
*salt
= hash_buf
->salt
;
13470 char *iter_pos
= input_buf
+ 3;
13472 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13474 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13476 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13478 salt
->salt_iter
= salt_iter
;
13480 char *salt_pos
= iter_pos
+ 1;
13484 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13486 salt
->salt_len
= salt_len
;
13488 char *hash_pos
= salt_pos
+ salt_len
;
13490 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13494 char *tmp
= (char *) salt
->salt_buf_pc
;
13496 tmp
[0] = hash_pos
[42];
13500 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13501 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13502 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13503 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13509 return (PARSER_OK
);
13512 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13514 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13516 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13518 u32
*digest
= (u32
*) hash_buf
->digest
;
13520 salt_t
*salt
= hash_buf
->salt
;
13522 char *salt_buf
= input_buf
+ 6;
13524 uint salt_len
= 16;
13526 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13528 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13530 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13532 salt
->salt_len
= salt_len
;
13534 char *hash_pos
= input_buf
+ 6 + 16;
13536 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13537 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13538 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13539 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13540 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13541 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13542 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13543 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13545 return (PARSER_OK
);
13548 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13550 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13552 u32
*digest
= (u32
*) hash_buf
->digest
;
13554 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13555 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13559 return (PARSER_OK
);
13562 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13564 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13566 u32
*digest
= (u32
*) hash_buf
->digest
;
13568 salt_t
*salt
= hash_buf
->salt
;
13570 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13572 char *saltbuf_pos
= input_buf
;
13574 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13576 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13578 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13580 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13581 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13583 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13587 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13589 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13591 char *salt_ptr
= (char *) saltbuf_pos
;
13592 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13597 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13599 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13602 rakp_ptr
[j
] = 0x80;
13604 rakp
->salt_len
= j
;
13606 for (i
= 0; i
< 64; i
++)
13608 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13611 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13612 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13613 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13614 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13615 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13616 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13617 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13618 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13620 salt
->salt_len
= 32; // muss min. 32 haben
13622 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13623 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13624 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13625 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13626 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13628 return (PARSER_OK
);
13631 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13633 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13635 u32
*digest
= (u32
*) hash_buf
->digest
;
13637 salt_t
*salt
= hash_buf
->salt
;
13639 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13641 char *salt_pos
= input_buf
+ 1;
13643 memcpy (salt
->salt_buf
, salt_pos
, 8);
13645 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13646 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13648 salt
->salt_len
= 8;
13650 char *hash_pos
= salt_pos
+ 8;
13652 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13653 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13654 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13655 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13656 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13658 digest
[0] -= SHA1M_A
;
13659 digest
[1] -= SHA1M_B
;
13660 digest
[2] -= SHA1M_C
;
13661 digest
[3] -= SHA1M_D
;
13662 digest
[4] -= SHA1M_E
;
13664 return (PARSER_OK
);
13667 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13669 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13671 u32
*digest
= (u32
*) hash_buf
->digest
;
13673 salt_t
*salt
= hash_buf
->salt
;
13675 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13676 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13677 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13678 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13680 digest
[0] = byte_swap_32 (digest
[0]);
13681 digest
[1] = byte_swap_32 (digest
[1]);
13682 digest
[2] = byte_swap_32 (digest
[2]);
13683 digest
[3] = byte_swap_32 (digest
[3]);
13685 digest
[0] -= MD5M_A
;
13686 digest
[1] -= MD5M_B
;
13687 digest
[2] -= MD5M_C
;
13688 digest
[3] -= MD5M_D
;
13690 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13692 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13694 u32
*salt_buf
= salt
->salt_buf
;
13696 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
13697 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
13698 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
13699 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
13701 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13702 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13703 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13704 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13706 salt
->salt_len
= 16 + 1;
13708 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13710 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13712 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
13714 return (PARSER_OK
);
13717 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13719 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13721 u32
*digest
= (u32
*) hash_buf
->digest
;
13723 salt_t
*salt
= hash_buf
->salt
;
13725 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13731 char *hashbuf_pos
= input_buf
;
13733 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13735 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13737 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13739 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13743 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13745 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13747 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13749 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13753 char *databuf_pos
= strchr (iteration_pos
, ':');
13755 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13757 const uint iteration_len
= databuf_pos
- iteration_pos
;
13759 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13760 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13762 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13764 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13765 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13771 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13772 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13773 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13774 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13775 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13776 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
13777 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
13778 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
13782 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13784 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13786 const char p0
= saltbuf_pos
[i
+ 0];
13787 const char p1
= saltbuf_pos
[i
+ 1];
13789 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13790 | hex_convert (p0
) << 4;
13793 salt
->salt_buf
[4] = 0x01000000;
13794 salt
->salt_buf
[5] = 0x80;
13796 salt
->salt_len
= saltbuf_len
/ 2;
13800 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13804 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13806 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13808 const char p0
= databuf_pos
[i
+ 0];
13809 const char p1
= databuf_pos
[i
+ 1];
13811 *databuf_ptr
++ = hex_convert (p1
) << 0
13812 | hex_convert (p0
) << 4;
13815 *databuf_ptr
++ = 0x80;
13817 for (uint i
= 0; i
< 512; i
++)
13819 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13822 cloudkey
->data_len
= databuf_len
/ 2;
13824 return (PARSER_OK
);
13827 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13829 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13831 u32
*digest
= (u32
*) hash_buf
->digest
;
13833 salt_t
*salt
= hash_buf
->salt
;
13839 char *hashbuf_pos
= input_buf
;
13841 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13843 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13845 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13847 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13851 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13853 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13855 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13857 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13859 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13863 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13865 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13867 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13869 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13871 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13875 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13877 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13878 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13880 // ok, the plan for this algorithm is the following:
13881 // we have 2 salts here, the domain-name and a random salt
13882 // while both are used in the initial transformation,
13883 // only the random salt is used in the following iterations
13884 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13885 // and one that includes only the real salt (stored into salt_buf[]).
13886 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13888 u8 tmp_buf
[100] = { 0 };
13890 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
13892 memcpy (digest
, tmp_buf
, 20);
13894 digest
[0] = byte_swap_32 (digest
[0]);
13895 digest
[1] = byte_swap_32 (digest
[1]);
13896 digest
[2] = byte_swap_32 (digest
[2]);
13897 digest
[3] = byte_swap_32 (digest
[3]);
13898 digest
[4] = byte_swap_32 (digest
[4]);
13902 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13904 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
13906 char *len_ptr
= NULL
;
13908 for (uint i
= 0; i
< domainbuf_len
; i
++)
13910 if (salt_buf_pc_ptr
[i
] == '.')
13912 len_ptr
= &salt_buf_pc_ptr
[i
];
13922 salt
->salt_buf_pc
[7] = domainbuf_len
;
13926 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13928 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
13930 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13932 salt
->salt_len
= salt_len
;
13936 salt
->salt_iter
= atoi (iteration_pos
);
13938 return (PARSER_OK
);
13941 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13943 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
13945 u32
*digest
= (u32
*) hash_buf
->digest
;
13947 salt_t
*salt
= hash_buf
->salt
;
13949 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13950 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13951 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13952 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13953 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13955 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13957 uint salt_len
= input_len
- 40 - 1;
13959 char *salt_buf
= input_buf
+ 40 + 1;
13961 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13963 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13965 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13967 salt
->salt_len
= salt_len
;
13969 return (PARSER_OK
);
13972 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13974 const u8 ascii_to_ebcdic
[] =
13976 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
13977 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
13978 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
13979 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
13980 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
13981 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
13982 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
13983 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
13984 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
13985 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
13986 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
13987 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
13988 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
13989 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
13990 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
13991 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
13994 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
13996 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13998 u32
*digest
= (u32
*) hash_buf
->digest
;
14000 salt_t
*salt
= hash_buf
->salt
;
14002 char *salt_pos
= input_buf
+ 6 + 1;
14004 char *digest_pos
= strchr (salt_pos
, '*');
14006 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14008 uint salt_len
= digest_pos
- salt_pos
;
14010 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14012 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14014 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14018 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14019 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14021 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14023 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14025 salt
->salt_len
= salt_len
;
14027 for (uint i
= 0; i
< salt_len
; i
++)
14029 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14031 for (uint i
= salt_len
; i
< 8; i
++)
14033 salt_buf_pc_ptr
[i
] = 0x40;
14038 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14040 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14041 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14043 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14044 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14046 digest
[0] = byte_swap_32 (digest
[0]);
14047 digest
[1] = byte_swap_32 (digest
[1]);
14049 IP (digest
[0], digest
[1], tt
);
14051 digest
[0] = rotr32 (digest
[0], 29);
14052 digest
[1] = rotr32 (digest
[1], 29);
14056 return (PARSER_OK
);
14059 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14061 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14063 u32
*digest
= (u32
*) hash_buf
->digest
;
14065 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14066 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14067 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14068 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14070 digest
[0] = byte_swap_32 (digest
[0]);
14071 digest
[1] = byte_swap_32 (digest
[1]);
14072 digest
[2] = byte_swap_32 (digest
[2]);
14073 digest
[3] = byte_swap_32 (digest
[3]);
14075 return (PARSER_OK
);
14078 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14080 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14082 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14084 u32
*digest
= (u32
*) hash_buf
->digest
;
14086 salt_t
*salt
= hash_buf
->salt
;
14088 u8 tmp_buf
[120] = { 0 };
14090 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14092 tmp_buf
[3] += -4; // dont ask!
14094 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14096 salt
->salt_len
= 5;
14098 memcpy (digest
, tmp_buf
+ 5, 9);
14100 // yes, only 9 byte are needed to crack, but 10 to display
14102 salt
->salt_buf_pc
[7] = input_buf
[20];
14104 return (PARSER_OK
);
14107 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14109 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14111 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14113 u32
*digest
= (u32
*) hash_buf
->digest
;
14115 salt_t
*salt
= hash_buf
->salt
;
14117 u8 tmp_buf
[120] = { 0 };
14119 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14121 tmp_buf
[3] += -4; // dont ask!
14125 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14127 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)
14131 char tmp_iter_buf
[11] = { 0 };
14133 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14135 tmp_iter_buf
[10] = 0;
14137 salt
->salt_iter
= atoi (tmp_iter_buf
);
14139 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14141 return (PARSER_SALT_ITERATION
);
14144 salt
->salt_iter
--; // first round in init
14146 // 2 additional bytes for display only
14148 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14149 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14153 memcpy (digest
, tmp_buf
+ 28, 8);
14155 digest
[0] = byte_swap_32 (digest
[0]);
14156 digest
[1] = byte_swap_32 (digest
[1]);
14160 return (PARSER_OK
);
14163 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14165 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14167 u32
*digest
= (u32
*) hash_buf
->digest
;
14169 salt_t
*salt
= hash_buf
->salt
;
14171 char *salt_buf_pos
= input_buf
;
14173 char *hash_buf_pos
= salt_buf_pos
+ 6;
14175 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14176 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14177 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14178 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14179 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14180 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14181 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14182 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14184 digest
[0] -= SHA256M_A
;
14185 digest
[1] -= SHA256M_B
;
14186 digest
[2] -= SHA256M_C
;
14187 digest
[3] -= SHA256M_D
;
14188 digest
[4] -= SHA256M_E
;
14189 digest
[5] -= SHA256M_F
;
14190 digest
[6] -= SHA256M_G
;
14191 digest
[7] -= SHA256M_H
;
14193 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14195 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14197 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14199 salt
->salt_len
= salt_len
;
14201 return (PARSER_OK
);
14204 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14206 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14208 u32
*digest
= (u32
*) hash_buf
->digest
;
14210 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14212 salt_t
*salt
= hash_buf
->salt
;
14214 char *salt_buf
= input_buf
+ 6;
14216 char *digest_buf
= strchr (salt_buf
, '$');
14218 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14220 uint salt_len
= digest_buf
- salt_buf
;
14222 digest_buf
++; // skip the '$' symbol
14224 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14226 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14228 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14230 salt
->salt_len
= salt_len
;
14232 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14233 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14234 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14235 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14237 digest
[0] = byte_swap_32 (digest
[0]);
14238 digest
[1] = byte_swap_32 (digest
[1]);
14239 digest
[2] = byte_swap_32 (digest
[2]);
14240 digest
[3] = byte_swap_32 (digest
[3]);
14242 digest
[0] -= MD5M_A
;
14243 digest
[1] -= MD5M_B
;
14244 digest
[2] -= MD5M_C
;
14245 digest
[3] -= MD5M_D
;
14247 return (PARSER_OK
);
14250 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14252 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14254 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14256 u32
*digest
= (u32
*) hash_buf
->digest
;
14258 salt_t
*salt
= hash_buf
->salt
;
14260 char *salt_buf
= input_buf
+ 3;
14262 char *digest_buf
= strchr (salt_buf
, '$');
14264 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14266 uint salt_len
= digest_buf
- salt_buf
;
14268 digest_buf
++; // skip the '$' symbol
14270 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14272 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14274 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14276 salt_buf_ptr
[salt_len
] = 0x2d;
14278 salt
->salt_len
= salt_len
+ 1;
14280 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14281 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14282 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14283 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14285 digest
[0] = byte_swap_32 (digest
[0]);
14286 digest
[1] = byte_swap_32 (digest
[1]);
14287 digest
[2] = byte_swap_32 (digest
[2]);
14288 digest
[3] = byte_swap_32 (digest
[3]);
14290 digest
[0] -= MD5M_A
;
14291 digest
[1] -= MD5M_B
;
14292 digest
[2] -= MD5M_C
;
14293 digest
[3] -= MD5M_D
;
14295 return (PARSER_OK
);
14298 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14300 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14302 u32
*digest
= (u32
*) hash_buf
->digest
;
14304 u8 tmp_buf
[100] = { 0 };
14306 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14308 memcpy (digest
, tmp_buf
, 20);
14310 digest
[0] = byte_swap_32 (digest
[0]);
14311 digest
[1] = byte_swap_32 (digest
[1]);
14312 digest
[2] = byte_swap_32 (digest
[2]);
14313 digest
[3] = byte_swap_32 (digest
[3]);
14314 digest
[4] = byte_swap_32 (digest
[4]);
14316 digest
[0] -= SHA1M_A
;
14317 digest
[1] -= SHA1M_B
;
14318 digest
[2] -= SHA1M_C
;
14319 digest
[3] -= SHA1M_D
;
14320 digest
[4] -= SHA1M_E
;
14322 return (PARSER_OK
);
14325 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14327 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14329 u32
*digest
= (u32
*) hash_buf
->digest
;
14331 salt_t
*salt
= hash_buf
->salt
;
14333 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14334 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14335 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14336 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14338 digest
[0] = byte_swap_32 (digest
[0]);
14339 digest
[1] = byte_swap_32 (digest
[1]);
14340 digest
[2] = byte_swap_32 (digest
[2]);
14341 digest
[3] = byte_swap_32 (digest
[3]);
14343 digest
[0] -= MD5M_A
;
14344 digest
[1] -= MD5M_B
;
14345 digest
[2] -= MD5M_C
;
14346 digest
[3] -= MD5M_D
;
14348 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14350 uint salt_len
= input_len
- 32 - 1;
14352 char *salt_buf
= input_buf
+ 32 + 1;
14354 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14356 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14358 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14361 * add static "salt" part
14364 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14368 salt
->salt_len
= salt_len
;
14370 return (PARSER_OK
);
14373 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14375 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14377 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14379 u32
*digest
= (u32
*) hash_buf
->digest
;
14381 salt_t
*salt
= hash_buf
->salt
;
14383 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14389 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14391 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14393 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14395 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14397 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14401 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14403 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14405 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14407 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14411 char *keybuf_pos
= strchr (keylen_pos
, '$');
14413 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14415 uint keylen_len
= keybuf_pos
- keylen_pos
;
14417 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14421 char *databuf_pos
= strchr (keybuf_pos
, '$');
14423 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14425 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14427 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14431 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14433 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14439 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14440 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14441 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14442 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14444 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14445 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14446 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14447 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14449 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14450 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14451 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14452 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14454 salt
->salt_len
= 16;
14455 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14457 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14459 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14462 return (PARSER_OK
);
14465 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14467 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14469 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14471 u32
*digest
= (u32
*) hash_buf
->digest
;
14473 salt_t
*salt
= hash_buf
->salt
;
14479 // first is the N salt parameter
14481 char *N_pos
= input_buf
+ 6;
14483 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14487 salt
->scrypt_N
= atoi (N_pos
);
14491 char *r_pos
= strchr (N_pos
, ':');
14493 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14497 salt
->scrypt_r
= atoi (r_pos
);
14501 char *p_pos
= strchr (r_pos
, ':');
14503 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14507 salt
->scrypt_p
= atoi (p_pos
);
14511 char *saltbuf_pos
= strchr (p_pos
, ':');
14513 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14517 char *hash_pos
= strchr (saltbuf_pos
, ':');
14519 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14525 u8 tmp_buf
[33] = { 0 };
14527 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14529 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14531 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14533 salt
->salt_len
= tmp_len
;
14534 salt
->salt_iter
= 1;
14536 // digest - base64 decode
14538 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14540 tmp_len
= input_len
- (hash_pos
- input_buf
);
14542 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14544 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14546 memcpy (digest
, tmp_buf
, 32);
14548 return (PARSER_OK
);
14551 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14553 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14555 u32
*digest
= (u32
*) hash_buf
->digest
;
14557 salt_t
*salt
= hash_buf
->salt
;
14563 char decrypted
[76] = { 0 }; // iv + hash
14565 juniper_decrypt_hash (input_buf
, decrypted
);
14567 char *md5crypt_hash
= decrypted
+ 12;
14569 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14571 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14573 char *salt_pos
= md5crypt_hash
+ 3;
14575 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14577 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14579 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14583 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14585 return (PARSER_OK
);
14588 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14590 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14592 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14594 u32
*digest
= (u32
*) hash_buf
->digest
;
14596 salt_t
*salt
= hash_buf
->salt
;
14598 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14604 // first is *raw* salt
14606 char *salt_pos
= input_buf
+ 3;
14608 char *hash_pos
= strchr (salt_pos
, '$');
14610 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14612 uint salt_len
= hash_pos
- salt_pos
;
14614 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14618 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14620 memcpy (salt_buf_ptr
, salt_pos
, 14);
14622 salt_buf_ptr
[17] = 0x01;
14623 salt_buf_ptr
[18] = 0x80;
14625 // add some stuff to normal salt to make sorted happy
14627 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14628 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14629 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14630 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14632 salt
->salt_len
= salt_len
;
14633 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14635 // base64 decode hash
14637 u8 tmp_buf
[100] = { 0 };
14639 uint hash_len
= input_len
- 3 - salt_len
- 1;
14641 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14643 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14645 memcpy (digest
, tmp_buf
, 32);
14647 digest
[0] = byte_swap_32 (digest
[0]);
14648 digest
[1] = byte_swap_32 (digest
[1]);
14649 digest
[2] = byte_swap_32 (digest
[2]);
14650 digest
[3] = byte_swap_32 (digest
[3]);
14651 digest
[4] = byte_swap_32 (digest
[4]);
14652 digest
[5] = byte_swap_32 (digest
[5]);
14653 digest
[6] = byte_swap_32 (digest
[6]);
14654 digest
[7] = byte_swap_32 (digest
[7]);
14656 return (PARSER_OK
);
14659 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14661 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14663 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14665 u32
*digest
= (u32
*) hash_buf
->digest
;
14667 salt_t
*salt
= hash_buf
->salt
;
14673 // first is *raw* salt
14675 char *salt_pos
= input_buf
+ 3;
14677 char *hash_pos
= strchr (salt_pos
, '$');
14679 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14681 uint salt_len
= hash_pos
- salt_pos
;
14683 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14685 salt
->salt_len
= salt_len
;
14688 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14690 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14691 salt_buf_ptr
[salt_len
] = 0;
14693 // base64 decode hash
14695 u8 tmp_buf
[100] = { 0 };
14697 uint hash_len
= input_len
- 3 - salt_len
- 1;
14699 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14701 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14703 memcpy (digest
, tmp_buf
, 32);
14706 salt
->scrypt_N
= 16384;
14707 salt
->scrypt_r
= 1;
14708 salt
->scrypt_p
= 1;
14709 salt
->salt_iter
= 1;
14711 return (PARSER_OK
);
14714 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14716 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14718 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14720 u32
*digest
= (u32
*) hash_buf
->digest
;
14722 salt_t
*salt
= hash_buf
->salt
;
14724 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14730 char *version_pos
= input_buf
+ 8 + 1;
14732 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14734 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14736 u32 version_len
= verifierHashSize_pos
- version_pos
;
14738 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14740 verifierHashSize_pos
++;
14742 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14744 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14746 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14748 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14752 char *saltSize_pos
= strchr (keySize_pos
, '*');
14754 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14756 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14758 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14762 char *osalt_pos
= strchr (saltSize_pos
, '*');
14764 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14766 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14768 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14772 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14774 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14776 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14778 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14780 encryptedVerifier_pos
++;
14782 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14784 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14786 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14788 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14790 encryptedVerifierHash_pos
++;
14792 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;
14794 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14796 const uint version
= atoi (version_pos
);
14798 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14800 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14802 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14804 const uint keySize
= atoi (keySize_pos
);
14806 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14808 office2007
->keySize
= keySize
;
14810 const uint saltSize
= atoi (saltSize_pos
);
14812 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14818 salt
->salt_len
= 16;
14819 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14821 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
14822 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
14823 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
14824 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
14830 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
14831 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
14832 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
14833 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
14835 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
14836 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
14837 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
14838 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
14839 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
14845 digest
[0] = office2007
->encryptedVerifierHash
[0];
14846 digest
[1] = office2007
->encryptedVerifierHash
[1];
14847 digest
[2] = office2007
->encryptedVerifierHash
[2];
14848 digest
[3] = office2007
->encryptedVerifierHash
[3];
14850 return (PARSER_OK
);
14853 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14855 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14857 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14859 u32
*digest
= (u32
*) hash_buf
->digest
;
14861 salt_t
*salt
= hash_buf
->salt
;
14863 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14869 char *version_pos
= input_buf
+ 8 + 1;
14871 char *spinCount_pos
= strchr (version_pos
, '*');
14873 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14875 u32 version_len
= spinCount_pos
- version_pos
;
14877 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14881 char *keySize_pos
= strchr (spinCount_pos
, '*');
14883 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14885 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
14887 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14891 char *saltSize_pos
= strchr (keySize_pos
, '*');
14893 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14895 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14897 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14901 char *osalt_pos
= strchr (saltSize_pos
, '*');
14903 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14905 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14907 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14911 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14913 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14915 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14917 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14919 encryptedVerifier_pos
++;
14921 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14923 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14925 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14927 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14929 encryptedVerifierHash_pos
++;
14931 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;
14933 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14935 const uint version
= atoi (version_pos
);
14937 if (version
!= 2010) return (PARSER_SALT_VALUE
);
14939 const uint spinCount
= atoi (spinCount_pos
);
14941 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
14943 const uint keySize
= atoi (keySize_pos
);
14945 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
14947 const uint saltSize
= atoi (saltSize_pos
);
14949 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14955 salt
->salt_len
= 16;
14956 salt
->salt_iter
= spinCount
;
14958 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
14959 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
14960 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
14961 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
14967 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
14968 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
14969 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
14970 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
14972 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
14973 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
14974 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
14975 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
14976 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
14977 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
14978 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
14979 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
14985 digest
[0] = office2010
->encryptedVerifierHash
[0];
14986 digest
[1] = office2010
->encryptedVerifierHash
[1];
14987 digest
[2] = office2010
->encryptedVerifierHash
[2];
14988 digest
[3] = office2010
->encryptedVerifierHash
[3];
14990 return (PARSER_OK
);
14993 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14995 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
14997 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14999 u32
*digest
= (u32
*) hash_buf
->digest
;
15001 salt_t
*salt
= hash_buf
->salt
;
15003 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15009 char *version_pos
= input_buf
+ 8 + 1;
15011 char *spinCount_pos
= strchr (version_pos
, '*');
15013 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15015 u32 version_len
= spinCount_pos
- version_pos
;
15017 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15021 char *keySize_pos
= strchr (spinCount_pos
, '*');
15023 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15025 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15027 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15031 char *saltSize_pos
= strchr (keySize_pos
, '*');
15033 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15035 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15037 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15041 char *osalt_pos
= strchr (saltSize_pos
, '*');
15043 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15045 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15047 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15051 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15053 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15055 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15057 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15059 encryptedVerifier_pos
++;
15061 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15063 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15065 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15067 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15069 encryptedVerifierHash_pos
++;
15071 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;
15073 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15075 const uint version
= atoi (version_pos
);
15077 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15079 const uint spinCount
= atoi (spinCount_pos
);
15081 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15083 const uint keySize
= atoi (keySize_pos
);
15085 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15087 const uint saltSize
= atoi (saltSize_pos
);
15089 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15095 salt
->salt_len
= 16;
15096 salt
->salt_iter
= spinCount
;
15098 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15099 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15100 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15101 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15107 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15108 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15109 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15110 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15112 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15113 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15114 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15115 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15116 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15117 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15118 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15119 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15125 digest
[0] = office2013
->encryptedVerifierHash
[0];
15126 digest
[1] = office2013
->encryptedVerifierHash
[1];
15127 digest
[2] = office2013
->encryptedVerifierHash
[2];
15128 digest
[3] = office2013
->encryptedVerifierHash
[3];
15130 return (PARSER_OK
);
15133 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15135 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15137 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15139 u32
*digest
= (u32
*) hash_buf
->digest
;
15141 salt_t
*salt
= hash_buf
->salt
;
15143 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15149 char *version_pos
= input_buf
+ 11;
15151 char *osalt_pos
= strchr (version_pos
, '*');
15153 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15155 u32 version_len
= osalt_pos
- version_pos
;
15157 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15161 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15163 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15165 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15167 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15169 encryptedVerifier_pos
++;
15171 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15173 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15175 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15177 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15179 encryptedVerifierHash_pos
++;
15181 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15183 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15185 const uint version
= *version_pos
- 0x30;
15187 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15193 oldoffice01
->version
= version
;
15195 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15196 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15197 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15198 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15200 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15201 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15202 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15203 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15205 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15206 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15207 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15208 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15210 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15211 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15212 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15213 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15219 salt
->salt_len
= 16;
15221 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15222 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15223 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15224 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15226 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15227 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15228 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15229 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15231 // this is a workaround as office produces multiple documents with the same salt
15233 salt
->salt_len
+= 32;
15235 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15236 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15237 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15238 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15239 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15240 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15241 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15242 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15248 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15249 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15250 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15251 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15253 return (PARSER_OK
);
15256 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15258 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15261 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15263 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15265 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15267 u32
*digest
= (u32
*) hash_buf
->digest
;
15269 salt_t
*salt
= hash_buf
->salt
;
15271 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15277 char *version_pos
= input_buf
+ 11;
15279 char *osalt_pos
= strchr (version_pos
, '*');
15281 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15283 u32 version_len
= osalt_pos
- version_pos
;
15285 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15289 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15291 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15293 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15295 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15297 encryptedVerifier_pos
++;
15299 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15301 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15303 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15305 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15307 encryptedVerifierHash_pos
++;
15309 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15311 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15313 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15315 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15319 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15321 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15323 const uint version
= *version_pos
- 0x30;
15325 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15331 oldoffice01
->version
= version
;
15333 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15334 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15335 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15336 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15338 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15339 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15340 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15341 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15343 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15344 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15345 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15346 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15348 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15349 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15350 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15351 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15353 oldoffice01
->rc4key
[1] = 0;
15354 oldoffice01
->rc4key
[0] = 0;
15356 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15357 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15358 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15359 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15360 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15361 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15362 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15363 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15364 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15365 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15367 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15368 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15374 salt
->salt_len
= 16;
15376 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15377 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15378 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15379 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15381 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15382 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15383 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15384 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15386 // this is a workaround as office produces multiple documents with the same salt
15388 salt
->salt_len
+= 32;
15390 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15391 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15392 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15393 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15394 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15395 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15396 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15397 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15403 digest
[0] = oldoffice01
->rc4key
[0];
15404 digest
[1] = oldoffice01
->rc4key
[1];
15408 return (PARSER_OK
);
15411 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15413 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15415 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15417 u32
*digest
= (u32
*) hash_buf
->digest
;
15419 salt_t
*salt
= hash_buf
->salt
;
15421 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15427 char *version_pos
= input_buf
+ 11;
15429 char *osalt_pos
= strchr (version_pos
, '*');
15431 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15433 u32 version_len
= osalt_pos
- version_pos
;
15435 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15439 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15441 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15443 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15445 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15447 encryptedVerifier_pos
++;
15449 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15451 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15453 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15455 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15457 encryptedVerifierHash_pos
++;
15459 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15461 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15463 const uint version
= *version_pos
- 0x30;
15465 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15471 oldoffice34
->version
= version
;
15473 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15474 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15475 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15476 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15478 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15479 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15480 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15481 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15483 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15484 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15485 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15486 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15487 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15489 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15490 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15491 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15492 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15493 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15499 salt
->salt_len
= 16;
15501 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15502 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15503 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15504 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15506 // this is a workaround as office produces multiple documents with the same salt
15508 salt
->salt_len
+= 32;
15510 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15511 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15512 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15513 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15514 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15515 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15516 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15517 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15523 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15524 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15525 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15526 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15528 return (PARSER_OK
);
15531 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15533 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15535 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15538 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15540 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15542 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15544 u32
*digest
= (u32
*) hash_buf
->digest
;
15546 salt_t
*salt
= hash_buf
->salt
;
15548 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15554 char *version_pos
= input_buf
+ 11;
15556 char *osalt_pos
= strchr (version_pos
, '*');
15558 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15560 u32 version_len
= osalt_pos
- version_pos
;
15562 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15566 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15568 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15570 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15572 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15574 encryptedVerifier_pos
++;
15576 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15578 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15580 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15582 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15584 encryptedVerifierHash_pos
++;
15586 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15588 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15590 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15592 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15596 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15598 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15600 const uint version
= *version_pos
- 0x30;
15602 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15608 oldoffice34
->version
= version
;
15610 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15611 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15612 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15613 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15615 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15616 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15617 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15618 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15620 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15621 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15622 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15623 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15624 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15626 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15627 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15628 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15629 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15630 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15632 oldoffice34
->rc4key
[1] = 0;
15633 oldoffice34
->rc4key
[0] = 0;
15635 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15636 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15637 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15638 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15639 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15640 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15641 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15642 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15643 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15644 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15646 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15647 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15653 salt
->salt_len
= 16;
15655 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15656 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15657 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15658 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15660 // this is a workaround as office produces multiple documents with the same salt
15662 salt
->salt_len
+= 32;
15664 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15665 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15666 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15667 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15668 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15669 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15670 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15671 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15677 digest
[0] = oldoffice34
->rc4key
[0];
15678 digest
[1] = oldoffice34
->rc4key
[1];
15682 return (PARSER_OK
);
15685 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15687 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15689 u32
*digest
= (u32
*) hash_buf
->digest
;
15691 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15692 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15693 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15694 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15696 digest
[0] = byte_swap_32 (digest
[0]);
15697 digest
[1] = byte_swap_32 (digest
[1]);
15698 digest
[2] = byte_swap_32 (digest
[2]);
15699 digest
[3] = byte_swap_32 (digest
[3]);
15701 return (PARSER_OK
);
15704 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15706 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15708 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15710 u32
*digest
= (u32
*) hash_buf
->digest
;
15712 salt_t
*salt
= hash_buf
->salt
;
15714 char *signature_pos
= input_buf
;
15716 char *salt_pos
= strchr (signature_pos
, '$');
15718 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15720 u32 signature_len
= salt_pos
- signature_pos
;
15722 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15726 char *hash_pos
= strchr (salt_pos
, '$');
15728 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15730 u32 salt_len
= hash_pos
- salt_pos
;
15732 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15736 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15738 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15740 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
15741 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
15742 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
15743 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
15744 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
15746 digest
[0] -= SHA1M_A
;
15747 digest
[1] -= SHA1M_B
;
15748 digest
[2] -= SHA1M_C
;
15749 digest
[3] -= SHA1M_D
;
15750 digest
[4] -= SHA1M_E
;
15752 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15754 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15756 salt
->salt_len
= salt_len
;
15758 return (PARSER_OK
);
15761 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15763 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15765 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15767 u32
*digest
= (u32
*) hash_buf
->digest
;
15769 salt_t
*salt
= hash_buf
->salt
;
15771 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15777 char *iter_pos
= input_buf
+ 14;
15779 const int iter
= atoi (iter_pos
);
15781 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15783 salt
->salt_iter
= iter
- 1;
15785 char *salt_pos
= strchr (iter_pos
, '$');
15787 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15791 char *hash_pos
= strchr (salt_pos
, '$');
15793 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15795 const uint salt_len
= hash_pos
- salt_pos
;
15799 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15801 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15803 salt
->salt_len
= salt_len
;
15805 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15806 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15808 // add some stuff to normal salt to make sorted happy
15810 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15811 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15812 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15813 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15814 salt
->salt_buf
[4] = salt
->salt_iter
;
15816 // base64 decode hash
15818 u8 tmp_buf
[100] = { 0 };
15820 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15822 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15824 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15826 memcpy (digest
, tmp_buf
, 32);
15828 digest
[0] = byte_swap_32 (digest
[0]);
15829 digest
[1] = byte_swap_32 (digest
[1]);
15830 digest
[2] = byte_swap_32 (digest
[2]);
15831 digest
[3] = byte_swap_32 (digest
[3]);
15832 digest
[4] = byte_swap_32 (digest
[4]);
15833 digest
[5] = byte_swap_32 (digest
[5]);
15834 digest
[6] = byte_swap_32 (digest
[6]);
15835 digest
[7] = byte_swap_32 (digest
[7]);
15837 return (PARSER_OK
);
15840 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15842 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15844 u32
*digest
= (u32
*) hash_buf
->digest
;
15846 salt_t
*salt
= hash_buf
->salt
;
15848 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15849 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15853 digest
[0] = byte_swap_32 (digest
[0]);
15854 digest
[1] = byte_swap_32 (digest
[1]);
15856 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15857 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15858 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15860 char iter_c
= input_buf
[17];
15861 char iter_d
= input_buf
[19];
15863 // atm only defaults, let's see if there's more request
15864 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15865 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15867 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15869 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
15870 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
15871 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
15872 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
15874 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15875 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15876 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15877 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15879 salt
->salt_len
= 16;
15881 return (PARSER_OK
);
15884 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15886 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
15888 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15890 u32
*digest
= (u32
*) hash_buf
->digest
;
15892 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
15894 salt_t
*salt
= hash_buf
->salt
;
15896 char *salt_pos
= input_buf
+ 10;
15898 char *hash_pos
= strchr (salt_pos
, '$');
15900 uint salt_len
= hash_pos
- salt_pos
;
15902 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15906 uint hash_len
= input_len
- 10 - salt_len
- 1;
15908 // base64 decode salt
15910 u8 tmp_buf
[100] = { 0 };
15912 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
15914 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
15916 tmp_buf
[salt_len
] = 0x80;
15918 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
15920 salt
->salt_len
= salt_len
;
15922 // base64 decode salt
15924 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15926 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15928 uint user_len
= hash_len
- 32;
15930 const u8
*tmp_hash
= tmp_buf
+ user_len
;
15932 user_len
--; // skip the trailing space
15934 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
15935 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
15936 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
15937 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
15939 digest
[0] = byte_swap_32 (digest
[0]);
15940 digest
[1] = byte_swap_32 (digest
[1]);
15941 digest
[2] = byte_swap_32 (digest
[2]);
15942 digest
[3] = byte_swap_32 (digest
[3]);
15944 // store username for host only (output hash if cracked)
15946 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
15947 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
15949 return (PARSER_OK
);
15952 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15954 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
15956 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15958 u32
*digest
= (u32
*) hash_buf
->digest
;
15960 salt_t
*salt
= hash_buf
->salt
;
15962 char *iter_pos
= input_buf
+ 10;
15964 u32 iter
= atoi (iter_pos
);
15968 return (PARSER_SALT_ITERATION
);
15971 iter
--; // first iteration is special
15973 salt
->salt_iter
= iter
;
15975 char *base64_pos
= strchr (iter_pos
, '}');
15977 if (base64_pos
== NULL
)
15979 return (PARSER_SIGNATURE_UNMATCHED
);
15984 // base64 decode salt
15986 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
15988 u8 tmp_buf
[100] = { 0 };
15990 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
15992 if (decoded_len
< 24)
15994 return (PARSER_SALT_LENGTH
);
15999 uint salt_len
= decoded_len
- 20;
16001 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16002 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16004 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16006 salt
->salt_len
= salt_len
;
16010 u32
*digest_ptr
= (u32
*) tmp_buf
;
16012 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16013 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16014 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16015 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16016 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16018 return (PARSER_OK
);
16021 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16023 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16025 u32
*digest
= (u32
*) hash_buf
->digest
;
16027 salt_t
*salt
= hash_buf
->salt
;
16029 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16030 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16031 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16032 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16033 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16035 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16037 uint salt_len
= input_len
- 40 - 1;
16039 char *salt_buf
= input_buf
+ 40 + 1;
16041 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16043 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16045 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16047 salt
->salt_len
= salt_len
;
16049 return (PARSER_OK
);
16052 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16054 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16056 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16058 u32
*digest
= (u32
*) hash_buf
->digest
;
16060 salt_t
*salt
= hash_buf
->salt
;
16062 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16068 char *V_pos
= input_buf
+ 5;
16070 char *R_pos
= strchr (V_pos
, '*');
16072 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16074 u32 V_len
= R_pos
- V_pos
;
16078 char *bits_pos
= strchr (R_pos
, '*');
16080 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16082 u32 R_len
= bits_pos
- R_pos
;
16086 char *P_pos
= strchr (bits_pos
, '*');
16088 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16090 u32 bits_len
= P_pos
- bits_pos
;
16094 char *enc_md_pos
= strchr (P_pos
, '*');
16096 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16098 u32 P_len
= enc_md_pos
- P_pos
;
16102 char *id_len_pos
= strchr (enc_md_pos
, '*');
16104 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16106 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16110 char *id_buf_pos
= strchr (id_len_pos
, '*');
16112 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16114 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16118 char *u_len_pos
= strchr (id_buf_pos
, '*');
16120 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16122 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16124 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16128 char *u_buf_pos
= strchr (u_len_pos
, '*');
16130 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16132 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16136 char *o_len_pos
= strchr (u_buf_pos
, '*');
16138 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16140 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16142 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16146 char *o_buf_pos
= strchr (o_len_pos
, '*');
16148 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16150 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16154 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;
16156 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16160 const int V
= atoi (V_pos
);
16161 const int R
= atoi (R_pos
);
16162 const int P
= atoi (P_pos
);
16164 if (V
!= 1) return (PARSER_SALT_VALUE
);
16165 if (R
!= 2) return (PARSER_SALT_VALUE
);
16167 const int enc_md
= atoi (enc_md_pos
);
16169 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16171 const int id_len
= atoi (id_len_pos
);
16172 const int u_len
= atoi (u_len_pos
);
16173 const int o_len
= atoi (o_len_pos
);
16175 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16176 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16177 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16179 const int bits
= atoi (bits_pos
);
16181 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16183 // copy data to esalt
16189 pdf
->enc_md
= enc_md
;
16191 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16192 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16193 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16194 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16195 pdf
->id_len
= id_len
;
16197 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16198 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16199 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16200 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16201 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16202 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16203 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16204 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16205 pdf
->u_len
= u_len
;
16207 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16208 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16209 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16210 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16211 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16212 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16213 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16214 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16215 pdf
->o_len
= o_len
;
16217 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16218 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16219 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16220 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16222 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16223 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16224 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16225 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16226 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16227 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16228 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16229 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16231 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16232 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16233 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16234 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16235 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16236 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16237 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16238 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16240 // we use ID for salt, maybe needs to change, we will see...
16242 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16243 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16244 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16245 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16246 salt
->salt_len
= pdf
->id_len
;
16248 digest
[0] = pdf
->u_buf
[0];
16249 digest
[1] = pdf
->u_buf
[1];
16250 digest
[2] = pdf
->u_buf
[2];
16251 digest
[3] = pdf
->u_buf
[3];
16253 return (PARSER_OK
);
16256 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16258 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16261 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16263 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16265 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16267 u32
*digest
= (u32
*) hash_buf
->digest
;
16269 salt_t
*salt
= hash_buf
->salt
;
16271 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16277 char *V_pos
= input_buf
+ 5;
16279 char *R_pos
= strchr (V_pos
, '*');
16281 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16283 u32 V_len
= R_pos
- V_pos
;
16287 char *bits_pos
= strchr (R_pos
, '*');
16289 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16291 u32 R_len
= bits_pos
- R_pos
;
16295 char *P_pos
= strchr (bits_pos
, '*');
16297 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16299 u32 bits_len
= P_pos
- bits_pos
;
16303 char *enc_md_pos
= strchr (P_pos
, '*');
16305 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16307 u32 P_len
= enc_md_pos
- P_pos
;
16311 char *id_len_pos
= strchr (enc_md_pos
, '*');
16313 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16315 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16319 char *id_buf_pos
= strchr (id_len_pos
, '*');
16321 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16323 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16327 char *u_len_pos
= strchr (id_buf_pos
, '*');
16329 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16331 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16333 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16337 char *u_buf_pos
= strchr (u_len_pos
, '*');
16339 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16341 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16345 char *o_len_pos
= strchr (u_buf_pos
, '*');
16347 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16349 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16351 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16355 char *o_buf_pos
= strchr (o_len_pos
, '*');
16357 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16359 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16363 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16365 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16367 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16369 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16373 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;
16375 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16379 const int V
= atoi (V_pos
);
16380 const int R
= atoi (R_pos
);
16381 const int P
= atoi (P_pos
);
16383 if (V
!= 1) return (PARSER_SALT_VALUE
);
16384 if (R
!= 2) return (PARSER_SALT_VALUE
);
16386 const int enc_md
= atoi (enc_md_pos
);
16388 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16390 const int id_len
= atoi (id_len_pos
);
16391 const int u_len
= atoi (u_len_pos
);
16392 const int o_len
= atoi (o_len_pos
);
16394 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16395 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16396 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16398 const int bits
= atoi (bits_pos
);
16400 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16402 // copy data to esalt
16408 pdf
->enc_md
= enc_md
;
16410 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16411 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16412 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16413 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16414 pdf
->id_len
= id_len
;
16416 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16417 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16418 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16419 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16420 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16421 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16422 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16423 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16424 pdf
->u_len
= u_len
;
16426 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16427 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16428 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16429 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16430 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16431 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16432 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16433 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16434 pdf
->o_len
= o_len
;
16436 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16437 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16438 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16439 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16441 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16442 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16443 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16444 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16445 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16446 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16447 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16448 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16450 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16451 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16452 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16453 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16454 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16455 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16456 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16457 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16459 pdf
->rc4key
[1] = 0;
16460 pdf
->rc4key
[0] = 0;
16462 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16463 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16464 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16465 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16466 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16467 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16468 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16469 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16470 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16471 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16473 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16474 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16476 // we use ID for salt, maybe needs to change, we will see...
16478 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16479 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16480 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16481 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16482 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16483 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16484 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16485 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16486 salt
->salt_len
= pdf
->id_len
+ 16;
16488 digest
[0] = pdf
->rc4key
[0];
16489 digest
[1] = pdf
->rc4key
[1];
16493 return (PARSER_OK
);
16496 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16498 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16500 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16502 u32
*digest
= (u32
*) hash_buf
->digest
;
16504 salt_t
*salt
= hash_buf
->salt
;
16506 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16512 char *V_pos
= input_buf
+ 5;
16514 char *R_pos
= strchr (V_pos
, '*');
16516 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16518 u32 V_len
= R_pos
- V_pos
;
16522 char *bits_pos
= strchr (R_pos
, '*');
16524 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16526 u32 R_len
= bits_pos
- R_pos
;
16530 char *P_pos
= strchr (bits_pos
, '*');
16532 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16534 u32 bits_len
= P_pos
- bits_pos
;
16538 char *enc_md_pos
= strchr (P_pos
, '*');
16540 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16542 u32 P_len
= enc_md_pos
- P_pos
;
16546 char *id_len_pos
= strchr (enc_md_pos
, '*');
16548 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16550 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16554 char *id_buf_pos
= strchr (id_len_pos
, '*');
16556 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16558 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16562 char *u_len_pos
= strchr (id_buf_pos
, '*');
16564 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16566 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16568 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16572 char *u_buf_pos
= strchr (u_len_pos
, '*');
16574 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16576 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16580 char *o_len_pos
= strchr (u_buf_pos
, '*');
16582 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16584 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16586 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16590 char *o_buf_pos
= strchr (o_len_pos
, '*');
16592 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16594 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16598 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;
16600 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16604 const int V
= atoi (V_pos
);
16605 const int R
= atoi (R_pos
);
16606 const int P
= atoi (P_pos
);
16610 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16611 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16613 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16615 const int id_len
= atoi (id_len_pos
);
16616 const int u_len
= atoi (u_len_pos
);
16617 const int o_len
= atoi (o_len_pos
);
16619 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16621 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16622 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16624 const int bits
= atoi (bits_pos
);
16626 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16632 enc_md
= atoi (enc_md_pos
);
16635 // copy data to esalt
16641 pdf
->enc_md
= enc_md
;
16643 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16644 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16645 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16646 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16650 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
16651 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
16652 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
16653 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
16656 pdf
->id_len
= id_len
;
16658 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16659 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16660 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16661 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16662 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16663 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16664 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16665 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16666 pdf
->u_len
= u_len
;
16668 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16669 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16670 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16671 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16672 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16673 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16674 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16675 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16676 pdf
->o_len
= o_len
;
16678 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16679 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16680 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16681 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16685 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16686 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16687 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16688 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16691 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16692 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16693 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16694 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16695 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16696 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16697 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16698 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16700 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16701 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16702 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16703 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16704 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16705 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16706 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16707 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16709 // precompute rc4 data for later use
16725 uint salt_pc_block
[32] = { 0 };
16727 char *salt_pc_ptr
= (char *) salt_pc_block
;
16729 memcpy (salt_pc_ptr
, padding
, 32);
16730 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16732 uint salt_pc_digest
[4] = { 0 };
16734 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16736 pdf
->rc4data
[0] = salt_pc_digest
[0];
16737 pdf
->rc4data
[1] = salt_pc_digest
[1];
16739 // we use ID for salt, maybe needs to change, we will see...
16741 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16742 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16743 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16744 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16745 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16746 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16747 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16748 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16749 salt
->salt_len
= pdf
->id_len
+ 16;
16751 salt
->salt_iter
= ROUNDS_PDF14
;
16753 digest
[0] = pdf
->u_buf
[0];
16754 digest
[1] = pdf
->u_buf
[1];
16758 return (PARSER_OK
);
16761 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16763 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16765 if (ret
!= PARSER_OK
)
16770 u32
*digest
= (u32
*) hash_buf
->digest
;
16772 salt_t
*salt
= hash_buf
->salt
;
16774 digest
[0] -= SHA256M_A
;
16775 digest
[1] -= SHA256M_B
;
16776 digest
[2] -= SHA256M_C
;
16777 digest
[3] -= SHA256M_D
;
16778 digest
[4] -= SHA256M_E
;
16779 digest
[5] -= SHA256M_F
;
16780 digest
[6] -= SHA256M_G
;
16781 digest
[7] -= SHA256M_H
;
16783 salt
->salt_buf
[2] = 0x80;
16785 return (PARSER_OK
);
16788 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16790 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16792 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16794 u32
*digest
= (u32
*) hash_buf
->digest
;
16796 salt_t
*salt
= hash_buf
->salt
;
16798 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16804 char *V_pos
= input_buf
+ 5;
16806 char *R_pos
= strchr (V_pos
, '*');
16808 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16810 u32 V_len
= R_pos
- V_pos
;
16814 char *bits_pos
= strchr (R_pos
, '*');
16816 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16818 u32 R_len
= bits_pos
- R_pos
;
16822 char *P_pos
= strchr (bits_pos
, '*');
16824 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16826 u32 bits_len
= P_pos
- bits_pos
;
16830 char *enc_md_pos
= strchr (P_pos
, '*');
16832 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16834 u32 P_len
= enc_md_pos
- P_pos
;
16838 char *id_len_pos
= strchr (enc_md_pos
, '*');
16840 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16842 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16846 char *id_buf_pos
= strchr (id_len_pos
, '*');
16848 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16850 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16854 char *u_len_pos
= strchr (id_buf_pos
, '*');
16856 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16858 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16862 char *u_buf_pos
= strchr (u_len_pos
, '*');
16864 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16866 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16870 char *o_len_pos
= strchr (u_buf_pos
, '*');
16872 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16874 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16878 char *o_buf_pos
= strchr (o_len_pos
, '*');
16880 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16882 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16886 char *last
= strchr (o_buf_pos
, '*');
16888 if (last
== NULL
) last
= input_buf
+ input_len
;
16890 u32 o_buf_len
= last
- o_buf_pos
;
16894 const int V
= atoi (V_pos
);
16895 const int R
= atoi (R_pos
);
16899 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
16900 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
16902 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16904 const int bits
= atoi (bits_pos
);
16906 if (bits
!= 256) return (PARSER_SALT_VALUE
);
16908 int enc_md
= atoi (enc_md_pos
);
16910 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
16912 const uint id_len
= atoi (id_len_pos
);
16913 const uint u_len
= atoi (u_len_pos
);
16914 const uint o_len
= atoi (o_len_pos
);
16916 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
16917 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
16918 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
16919 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
16920 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
16921 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
16922 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
16923 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
16925 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
16926 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
16927 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
16929 // copy data to esalt
16931 if (u_len
< 40) return (PARSER_SALT_VALUE
);
16933 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
16935 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
16938 salt
->salt_buf
[0] = pdf
->u_buf
[8];
16939 salt
->salt_buf
[1] = pdf
->u_buf
[9];
16941 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16942 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16944 salt
->salt_len
= 8;
16945 salt
->salt_iter
= ROUNDS_PDF17L8
;
16947 digest
[0] = pdf
->u_buf
[0];
16948 digest
[1] = pdf
->u_buf
[1];
16949 digest
[2] = pdf
->u_buf
[2];
16950 digest
[3] = pdf
->u_buf
[3];
16951 digest
[4] = pdf
->u_buf
[4];
16952 digest
[5] = pdf
->u_buf
[5];
16953 digest
[6] = pdf
->u_buf
[6];
16954 digest
[7] = pdf
->u_buf
[7];
16956 return (PARSER_OK
);
16959 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16961 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
16963 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
16965 u32
*digest
= (u32
*) hash_buf
->digest
;
16967 salt_t
*salt
= hash_buf
->salt
;
16969 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16977 char *iter_pos
= input_buf
+ 7;
16979 u32 iter
= atoi (iter_pos
);
16981 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16982 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
16984 // first is *raw* salt
16986 char *salt_pos
= strchr (iter_pos
, ':');
16988 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16992 char *hash_pos
= strchr (salt_pos
, ':');
16994 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16996 u32 salt_len
= hash_pos
- salt_pos
;
16998 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17002 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17004 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17008 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17010 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17012 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17014 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17015 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17017 salt
->salt_len
= salt_len
;
17018 salt
->salt_iter
= iter
- 1;
17022 u8 tmp_buf
[100] = { 0 };
17024 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17026 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17028 memcpy (digest
, tmp_buf
, 16);
17030 digest
[0] = byte_swap_32 (digest
[0]);
17031 digest
[1] = byte_swap_32 (digest
[1]);
17032 digest
[2] = byte_swap_32 (digest
[2]);
17033 digest
[3] = byte_swap_32 (digest
[3]);
17035 // add some stuff to normal salt to make sorted happy
17037 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17038 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17039 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17040 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17041 salt
->salt_buf
[4] = salt
->salt_iter
;
17043 return (PARSER_OK
);
17046 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17048 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17050 u32
*digest
= (u32
*) hash_buf
->digest
;
17052 salt_t
*salt
= hash_buf
->salt
;
17054 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17055 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17056 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17057 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17059 digest
[0] = byte_swap_32 (digest
[0]);
17060 digest
[1] = byte_swap_32 (digest
[1]);
17061 digest
[2] = byte_swap_32 (digest
[2]);
17062 digest
[3] = byte_swap_32 (digest
[3]);
17064 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17066 uint salt_len
= input_len
- 32 - 1;
17068 char *salt_buf
= input_buf
+ 32 + 1;
17070 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17072 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17074 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17076 salt
->salt_len
= salt_len
;
17078 return (PARSER_OK
);
17081 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17083 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17085 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17087 u32
*digest
= (u32
*) hash_buf
->digest
;
17089 salt_t
*salt
= hash_buf
->salt
;
17091 char *user_pos
= input_buf
+ 10;
17093 char *salt_pos
= strchr (user_pos
, '*');
17095 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17099 char *hash_pos
= strchr (salt_pos
, '*');
17103 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17105 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17107 uint user_len
= salt_pos
- user_pos
- 1;
17109 uint salt_len
= hash_pos
- salt_pos
- 1;
17111 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17117 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17118 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17119 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17120 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17122 digest
[0] = byte_swap_32 (digest
[0]);
17123 digest
[1] = byte_swap_32 (digest
[1]);
17124 digest
[2] = byte_swap_32 (digest
[2]);
17125 digest
[3] = byte_swap_32 (digest
[3]);
17127 digest
[0] -= MD5M_A
;
17128 digest
[1] -= MD5M_B
;
17129 digest
[2] -= MD5M_C
;
17130 digest
[3] -= MD5M_D
;
17136 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17138 // first 4 bytes are the "challenge"
17140 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17141 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17142 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17143 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17145 // append the user name
17147 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17149 salt
->salt_len
= 4 + user_len
;
17151 return (PARSER_OK
);
17154 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17156 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17158 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17160 u32
*digest
= (u32
*) hash_buf
->digest
;
17162 salt_t
*salt
= hash_buf
->salt
;
17164 char *salt_pos
= input_buf
+ 9;
17166 char *hash_pos
= strchr (salt_pos
, '*');
17168 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17172 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17174 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17176 uint salt_len
= hash_pos
- salt_pos
- 1;
17178 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17184 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17185 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17186 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17187 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17188 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17194 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17196 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17198 salt
->salt_len
= salt_len
;
17200 return (PARSER_OK
);
17203 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17205 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17207 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17209 u32
*digest
= (u32
*) hash_buf
->digest
;
17211 salt_t
*salt
= hash_buf
->salt
;
17213 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17219 char *cry_master_len_pos
= input_buf
+ 9;
17221 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17223 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17225 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17227 cry_master_buf_pos
++;
17229 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17231 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17233 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17235 cry_salt_len_pos
++;
17237 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17239 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17241 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17243 cry_salt_buf_pos
++;
17245 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17247 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17249 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17253 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17255 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17257 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17261 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17263 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17265 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17269 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17271 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17273 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17275 public_key_len_pos
++;
17277 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17279 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17281 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17283 public_key_buf_pos
++;
17285 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;
17287 const uint cry_master_len
= atoi (cry_master_len_pos
);
17288 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17289 const uint ckey_len
= atoi (ckey_len_pos
);
17290 const uint public_key_len
= atoi (public_key_len_pos
);
17292 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17293 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17294 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17295 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17297 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17299 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17301 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17304 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17306 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17308 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17311 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17313 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17315 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17318 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17319 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17320 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17323 * store digest (should be unique enought, hopefully)
17326 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17327 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17328 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17329 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17335 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17337 const uint cry_rounds
= atoi (cry_rounds_pos
);
17339 salt
->salt_iter
= cry_rounds
- 1;
17341 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17343 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17345 salt
->salt_len
= salt_len
;
17347 return (PARSER_OK
);
17350 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17352 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17354 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17356 u32
*digest
= (u32
*) hash_buf
->digest
;
17358 salt_t
*salt
= hash_buf
->salt
;
17360 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17362 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17364 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17366 memcpy (temp_input_buf
, input_buf
, input_len
);
17370 char *URI_server_pos
= temp_input_buf
+ 6;
17372 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17374 if (URI_client_pos
== NULL
)
17376 myfree (temp_input_buf
);
17378 return (PARSER_SEPARATOR_UNMATCHED
);
17381 URI_client_pos
[0] = 0;
17384 uint URI_server_len
= strlen (URI_server_pos
);
17386 if (URI_server_len
> 512)
17388 myfree (temp_input_buf
);
17390 return (PARSER_SALT_LENGTH
);
17395 char *user_pos
= strchr (URI_client_pos
, '*');
17397 if (user_pos
== NULL
)
17399 myfree (temp_input_buf
);
17401 return (PARSER_SEPARATOR_UNMATCHED
);
17407 uint URI_client_len
= strlen (URI_client_pos
);
17409 if (URI_client_len
> 512)
17411 myfree (temp_input_buf
);
17413 return (PARSER_SALT_LENGTH
);
17418 char *realm_pos
= strchr (user_pos
, '*');
17420 if (realm_pos
== NULL
)
17422 myfree (temp_input_buf
);
17424 return (PARSER_SEPARATOR_UNMATCHED
);
17430 uint user_len
= strlen (user_pos
);
17432 if (user_len
> 116)
17434 myfree (temp_input_buf
);
17436 return (PARSER_SALT_LENGTH
);
17441 char *method_pos
= strchr (realm_pos
, '*');
17443 if (method_pos
== NULL
)
17445 myfree (temp_input_buf
);
17447 return (PARSER_SEPARATOR_UNMATCHED
);
17453 uint realm_len
= strlen (realm_pos
);
17455 if (realm_len
> 116)
17457 myfree (temp_input_buf
);
17459 return (PARSER_SALT_LENGTH
);
17464 char *URI_prefix_pos
= strchr (method_pos
, '*');
17466 if (URI_prefix_pos
== NULL
)
17468 myfree (temp_input_buf
);
17470 return (PARSER_SEPARATOR_UNMATCHED
);
17473 URI_prefix_pos
[0] = 0;
17476 uint method_len
= strlen (method_pos
);
17478 if (method_len
> 246)
17480 myfree (temp_input_buf
);
17482 return (PARSER_SALT_LENGTH
);
17487 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17489 if (URI_resource_pos
== NULL
)
17491 myfree (temp_input_buf
);
17493 return (PARSER_SEPARATOR_UNMATCHED
);
17496 URI_resource_pos
[0] = 0;
17497 URI_resource_pos
++;
17499 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17501 if (URI_prefix_len
> 245)
17503 myfree (temp_input_buf
);
17505 return (PARSER_SALT_LENGTH
);
17510 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17512 if (URI_suffix_pos
== NULL
)
17514 myfree (temp_input_buf
);
17516 return (PARSER_SEPARATOR_UNMATCHED
);
17519 URI_suffix_pos
[0] = 0;
17522 uint URI_resource_len
= strlen (URI_resource_pos
);
17524 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17526 myfree (temp_input_buf
);
17528 return (PARSER_SALT_LENGTH
);
17533 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17535 if (nonce_pos
== NULL
)
17537 myfree (temp_input_buf
);
17539 return (PARSER_SEPARATOR_UNMATCHED
);
17545 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17547 if (URI_suffix_len
> 245)
17549 myfree (temp_input_buf
);
17551 return (PARSER_SALT_LENGTH
);
17556 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17558 if (nonce_client_pos
== NULL
)
17560 myfree (temp_input_buf
);
17562 return (PARSER_SEPARATOR_UNMATCHED
);
17565 nonce_client_pos
[0] = 0;
17566 nonce_client_pos
++;
17568 uint nonce_len
= strlen (nonce_pos
);
17570 if (nonce_len
< 1 || nonce_len
> 50)
17572 myfree (temp_input_buf
);
17574 return (PARSER_SALT_LENGTH
);
17579 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17581 if (nonce_count_pos
== NULL
)
17583 myfree (temp_input_buf
);
17585 return (PARSER_SEPARATOR_UNMATCHED
);
17588 nonce_count_pos
[0] = 0;
17591 uint nonce_client_len
= strlen (nonce_client_pos
);
17593 if (nonce_client_len
> 50)
17595 myfree (temp_input_buf
);
17597 return (PARSER_SALT_LENGTH
);
17602 char *qop_pos
= strchr (nonce_count_pos
, '*');
17604 if (qop_pos
== NULL
)
17606 myfree (temp_input_buf
);
17608 return (PARSER_SEPARATOR_UNMATCHED
);
17614 uint nonce_count_len
= strlen (nonce_count_pos
);
17616 if (nonce_count_len
> 50)
17618 myfree (temp_input_buf
);
17620 return (PARSER_SALT_LENGTH
);
17625 char *directive_pos
= strchr (qop_pos
, '*');
17627 if (directive_pos
== NULL
)
17629 myfree (temp_input_buf
);
17631 return (PARSER_SEPARATOR_UNMATCHED
);
17634 directive_pos
[0] = 0;
17637 uint qop_len
= strlen (qop_pos
);
17641 myfree (temp_input_buf
);
17643 return (PARSER_SALT_LENGTH
);
17648 char *digest_pos
= strchr (directive_pos
, '*');
17650 if (digest_pos
== NULL
)
17652 myfree (temp_input_buf
);
17654 return (PARSER_SEPARATOR_UNMATCHED
);
17660 uint directive_len
= strlen (directive_pos
);
17662 if (directive_len
!= 3)
17664 myfree (temp_input_buf
);
17666 return (PARSER_SALT_LENGTH
);
17669 if (memcmp (directive_pos
, "MD5", 3))
17671 log_info ("ERROR: only the MD5 directive is currently supported\n");
17673 myfree (temp_input_buf
);
17675 return (PARSER_SIP_AUTH_DIRECTIVE
);
17679 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17684 uint md5_max_len
= 4 * 64;
17686 uint md5_remaining_len
= md5_max_len
;
17688 uint tmp_md5_buf
[64] = { 0 };
17690 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17692 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17694 md5_len
+= method_len
+ 1;
17695 tmp_md5_ptr
+= method_len
+ 1;
17697 if (URI_prefix_len
> 0)
17699 md5_remaining_len
= md5_max_len
- md5_len
;
17701 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17703 md5_len
+= URI_prefix_len
+ 1;
17704 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17707 md5_remaining_len
= md5_max_len
- md5_len
;
17709 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17711 md5_len
+= URI_resource_len
;
17712 tmp_md5_ptr
+= URI_resource_len
;
17714 if (URI_suffix_len
> 0)
17716 md5_remaining_len
= md5_max_len
- md5_len
;
17718 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17720 md5_len
+= 1 + URI_suffix_len
;
17723 uint tmp_digest
[4] = { 0 };
17725 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17727 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17728 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17729 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17730 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17736 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17738 uint esalt_len
= 0;
17740 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17742 // there are 2 possibilities for the esalt:
17744 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17746 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17748 if (esalt_len
> max_esalt_len
)
17750 myfree (temp_input_buf
);
17752 return (PARSER_SALT_LENGTH
);
17755 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17767 esalt_len
= 1 + nonce_len
+ 1 + 32;
17769 if (esalt_len
> max_esalt_len
)
17771 myfree (temp_input_buf
);
17773 return (PARSER_SALT_LENGTH
);
17776 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17784 // add 0x80 to esalt
17786 esalt_buf_ptr
[esalt_len
] = 0x80;
17788 sip
->esalt_len
= esalt_len
;
17794 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17796 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17798 uint max_salt_len
= 119;
17800 if (salt_len
> max_salt_len
)
17802 myfree (temp_input_buf
);
17804 return (PARSER_SALT_LENGTH
);
17807 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17809 sip
->salt_len
= salt_len
;
17812 * fake salt (for sorting)
17815 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17819 uint fake_salt_len
= salt_len
;
17821 if (fake_salt_len
> max_salt_len
)
17823 fake_salt_len
= max_salt_len
;
17826 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17828 salt
->salt_len
= fake_salt_len
;
17834 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
17835 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
17836 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
17837 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
17839 digest
[0] = byte_swap_32 (digest
[0]);
17840 digest
[1] = byte_swap_32 (digest
[1]);
17841 digest
[2] = byte_swap_32 (digest
[2]);
17842 digest
[3] = byte_swap_32 (digest
[3]);
17844 myfree (temp_input_buf
);
17846 return (PARSER_OK
);
17849 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17851 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17853 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17855 u32
*digest
= (u32
*) hash_buf
->digest
;
17857 salt_t
*salt
= hash_buf
->salt
;
17861 char *digest_pos
= input_buf
;
17863 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
17870 char *salt_buf
= input_buf
+ 8 + 1;
17874 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17876 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17878 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17880 salt
->salt_len
= salt_len
;
17882 return (PARSER_OK
);
17885 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17887 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
17889 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17891 u32
*digest
= (u32
*) hash_buf
->digest
;
17893 salt_t
*salt
= hash_buf
->salt
;
17895 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
17901 char *p_buf_pos
= input_buf
+ 4;
17903 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
17905 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17907 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
17909 NumCyclesPower_pos
++;
17911 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
17913 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17915 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
17919 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
17921 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17923 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
17927 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
17929 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17931 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
17935 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
17937 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17939 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
17943 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
17945 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17947 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
17951 char *data_len_pos
= strchr (crc_buf_pos
, '$');
17953 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17955 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
17959 char *unpack_size_pos
= strchr (data_len_pos
, '$');
17961 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17963 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
17967 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
17969 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17971 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
17975 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;
17977 const uint iter
= atoi (NumCyclesPower_pos
);
17978 const uint crc
= atoi (crc_buf_pos
);
17979 const uint p_buf
= atoi (p_buf_pos
);
17980 const uint salt_len
= atoi (salt_len_pos
);
17981 const uint iv_len
= atoi (iv_len_pos
);
17982 const uint unpack_size
= atoi (unpack_size_pos
);
17983 const uint data_len
= atoi (data_len_pos
);
17989 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
17990 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
17992 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
17994 if (data_len
> 384) return (PARSER_SALT_VALUE
);
17996 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18002 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18003 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18004 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18005 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18007 seven_zip
->iv_len
= iv_len
;
18009 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18011 seven_zip
->salt_len
= 0;
18013 seven_zip
->crc
= crc
;
18015 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18017 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18019 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18022 seven_zip
->data_len
= data_len
;
18024 seven_zip
->unpack_size
= unpack_size
;
18028 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18029 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18030 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18031 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18033 salt
->salt_len
= 16;
18035 salt
->salt_sign
[0] = iter
;
18037 salt
->salt_iter
= 1 << iter
;
18048 return (PARSER_OK
);
18051 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18053 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18055 u32
*digest
= (u32
*) hash_buf
->digest
;
18057 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18058 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18059 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18060 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18061 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18062 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18063 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18064 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18066 digest
[0] = byte_swap_32 (digest
[0]);
18067 digest
[1] = byte_swap_32 (digest
[1]);
18068 digest
[2] = byte_swap_32 (digest
[2]);
18069 digest
[3] = byte_swap_32 (digest
[3]);
18070 digest
[4] = byte_swap_32 (digest
[4]);
18071 digest
[5] = byte_swap_32 (digest
[5]);
18072 digest
[6] = byte_swap_32 (digest
[6]);
18073 digest
[7] = byte_swap_32 (digest
[7]);
18075 return (PARSER_OK
);
18078 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18080 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18082 u32
*digest
= (u32
*) hash_buf
->digest
;
18084 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18085 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18086 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18087 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18088 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18089 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18090 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18091 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18092 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18093 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18094 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18095 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18096 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18097 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18098 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18099 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18101 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18102 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18103 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18104 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18105 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18106 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18107 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18108 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18109 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18110 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18111 digest
[10] = byte_swap_32 (digest
[10]);
18112 digest
[11] = byte_swap_32 (digest
[11]);
18113 digest
[12] = byte_swap_32 (digest
[12]);
18114 digest
[13] = byte_swap_32 (digest
[13]);
18115 digest
[14] = byte_swap_32 (digest
[14]);
18116 digest
[15] = byte_swap_32 (digest
[15]);
18118 return (PARSER_OK
);
18121 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18123 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18125 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18127 u32
*digest
= (u32
*) hash_buf
->digest
;
18129 salt_t
*salt
= hash_buf
->salt
;
18131 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18139 char *iter_pos
= input_buf
+ 4;
18141 u32 iter
= atoi (iter_pos
);
18143 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18144 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18146 // first is *raw* salt
18148 char *salt_pos
= strchr (iter_pos
, ':');
18150 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18154 char *hash_pos
= strchr (salt_pos
, ':');
18156 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18158 u32 salt_len
= hash_pos
- salt_pos
;
18160 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18164 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18166 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18170 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18172 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18174 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18176 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18177 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18179 salt
->salt_len
= salt_len
;
18180 salt
->salt_iter
= iter
- 1;
18184 u8 tmp_buf
[100] = { 0 };
18186 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18188 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18190 memcpy (digest
, tmp_buf
, 16);
18192 // add some stuff to normal salt to make sorted happy
18194 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18195 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18196 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18197 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18198 salt
->salt_buf
[4] = salt
->salt_iter
;
18200 return (PARSER_OK
);
18203 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18205 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18207 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18209 u32
*digest
= (u32
*) hash_buf
->digest
;
18211 salt_t
*salt
= hash_buf
->salt
;
18213 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18221 char *iter_pos
= input_buf
+ 5;
18223 u32 iter
= atoi (iter_pos
);
18225 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18226 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18228 // first is *raw* salt
18230 char *salt_pos
= strchr (iter_pos
, ':');
18232 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18236 char *hash_pos
= strchr (salt_pos
, ':');
18238 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18240 u32 salt_len
= hash_pos
- salt_pos
;
18242 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18246 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18248 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18252 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18254 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18256 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18258 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18259 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18261 salt
->salt_len
= salt_len
;
18262 salt
->salt_iter
= iter
- 1;
18266 u8 tmp_buf
[100] = { 0 };
18268 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18270 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18272 memcpy (digest
, tmp_buf
, 16);
18274 digest
[0] = byte_swap_32 (digest
[0]);
18275 digest
[1] = byte_swap_32 (digest
[1]);
18276 digest
[2] = byte_swap_32 (digest
[2]);
18277 digest
[3] = byte_swap_32 (digest
[3]);
18279 // add some stuff to normal salt to make sorted happy
18281 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18282 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18283 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18284 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18285 salt
->salt_buf
[4] = salt
->salt_iter
;
18287 return (PARSER_OK
);
18290 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18292 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18294 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18296 u64
*digest
= (u64
*) hash_buf
->digest
;
18298 salt_t
*salt
= hash_buf
->salt
;
18300 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18308 char *iter_pos
= input_buf
+ 7;
18310 u32 iter
= atoi (iter_pos
);
18312 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18313 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18315 // first is *raw* salt
18317 char *salt_pos
= strchr (iter_pos
, ':');
18319 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18323 char *hash_pos
= strchr (salt_pos
, ':');
18325 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18327 u32 salt_len
= hash_pos
- salt_pos
;
18329 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18333 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18335 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18339 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18341 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18343 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18345 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18346 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18348 salt
->salt_len
= salt_len
;
18349 salt
->salt_iter
= iter
- 1;
18353 u8 tmp_buf
[100] = { 0 };
18355 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18357 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18359 memcpy (digest
, tmp_buf
, 64);
18361 digest
[0] = byte_swap_64 (digest
[0]);
18362 digest
[1] = byte_swap_64 (digest
[1]);
18363 digest
[2] = byte_swap_64 (digest
[2]);
18364 digest
[3] = byte_swap_64 (digest
[3]);
18365 digest
[4] = byte_swap_64 (digest
[4]);
18366 digest
[5] = byte_swap_64 (digest
[5]);
18367 digest
[6] = byte_swap_64 (digest
[6]);
18368 digest
[7] = byte_swap_64 (digest
[7]);
18370 // add some stuff to normal salt to make sorted happy
18372 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18373 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18374 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18375 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18376 salt
->salt_buf
[4] = salt
->salt_iter
;
18378 return (PARSER_OK
);
18381 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18383 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18385 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18387 uint
*digest
= (uint
*) hash_buf
->digest
;
18389 salt_t
*salt
= hash_buf
->salt
;
18395 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18397 char *hash_pos
= strchr (salt_pos
, '$');
18399 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18401 u32 salt_len
= hash_pos
- salt_pos
;
18403 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18407 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18409 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18413 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18414 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18432 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18433 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18435 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18436 salt
->salt_len
= 8;
18438 return (PARSER_OK
);
18441 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18443 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18445 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18447 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18449 if (c19
& 3) return (PARSER_HASH_VALUE
);
18451 salt_t
*salt
= hash_buf
->salt
;
18453 u32
*digest
= (u32
*) hash_buf
->digest
;
18457 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18458 | itoa64_to_int (input_buf
[2]) << 6
18459 | itoa64_to_int (input_buf
[3]) << 12
18460 | itoa64_to_int (input_buf
[4]) << 18;
18464 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18465 | itoa64_to_int (input_buf
[6]) << 6
18466 | itoa64_to_int (input_buf
[7]) << 12
18467 | itoa64_to_int (input_buf
[8]) << 18;
18469 salt
->salt_len
= 4;
18471 u8 tmp_buf
[100] = { 0 };
18473 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18475 memcpy (digest
, tmp_buf
, 8);
18479 IP (digest
[0], digest
[1], tt
);
18481 digest
[0] = rotr32 (digest
[0], 31);
18482 digest
[1] = rotr32 (digest
[1], 31);
18486 return (PARSER_OK
);
18489 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18491 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18493 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18495 u32
*digest
= (u32
*) hash_buf
->digest
;
18497 salt_t
*salt
= hash_buf
->salt
;
18503 char *type_pos
= input_buf
+ 6 + 1;
18505 char *salt_pos
= strchr (type_pos
, '*');
18507 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18509 u32 type_len
= salt_pos
- type_pos
;
18511 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18515 char *crypted_pos
= strchr (salt_pos
, '*');
18517 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18519 u32 salt_len
= crypted_pos
- salt_pos
;
18521 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18525 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18527 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18533 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18534 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18536 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18537 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18539 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18540 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18541 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18542 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18544 salt
->salt_len
= 24;
18545 salt
->salt_iter
= ROUNDS_RAR3
;
18547 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18548 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18550 digest
[0] = 0xc43d7b00;
18551 digest
[1] = 0x40070000;
18555 return (PARSER_OK
);
18558 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18560 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18562 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18564 u32
*digest
= (u32
*) hash_buf
->digest
;
18566 salt_t
*salt
= hash_buf
->salt
;
18568 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18574 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18576 char *param1_pos
= strchr (param0_pos
, '$');
18578 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18580 u32 param0_len
= param1_pos
- param0_pos
;
18584 char *param2_pos
= strchr (param1_pos
, '$');
18586 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18588 u32 param1_len
= param2_pos
- param1_pos
;
18592 char *param3_pos
= strchr (param2_pos
, '$');
18594 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18596 u32 param2_len
= param3_pos
- param2_pos
;
18600 char *param4_pos
= strchr (param3_pos
, '$');
18602 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18604 u32 param3_len
= param4_pos
- param3_pos
;
18608 char *param5_pos
= strchr (param4_pos
, '$');
18610 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18612 u32 param4_len
= param5_pos
- param4_pos
;
18616 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18618 char *salt_buf
= param1_pos
;
18619 char *iv
= param3_pos
;
18620 char *pswcheck
= param5_pos
;
18622 const uint salt_len
= atoi (param0_pos
);
18623 const uint iterations
= atoi (param2_pos
);
18624 const uint pswcheck_len
= atoi (param4_pos
);
18630 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18631 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18632 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18634 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18635 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18636 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18642 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18643 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18644 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18645 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
18647 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
18648 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
18649 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
18650 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
18652 salt
->salt_len
= 16;
18654 salt
->salt_sign
[0] = iterations
;
18656 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18662 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
18663 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
18667 return (PARSER_OK
);
18670 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18672 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18674 u32
*digest
= (u32
*) hash_buf
->digest
;
18676 salt_t
*salt
= hash_buf
->salt
;
18678 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18679 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18680 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18681 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18682 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18683 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18684 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18685 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18687 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18689 uint salt_len
= input_len
- 64 - 1;
18691 char *salt_buf
= input_buf
+ 64 + 1;
18693 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18695 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18697 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18699 salt
->salt_len
= salt_len
;
18702 * we can precompute the first sha256 transform
18705 uint w
[16] = { 0 };
18707 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18708 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18709 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18710 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18711 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18712 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18713 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18714 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18715 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18716 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18717 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18718 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18719 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18720 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18721 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18722 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18724 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
18726 sha256_64 (w
, pc256
);
18728 salt
->salt_buf_pc
[0] = pc256
[0];
18729 salt
->salt_buf_pc
[1] = pc256
[1];
18730 salt
->salt_buf_pc
[2] = pc256
[2];
18731 salt
->salt_buf_pc
[3] = pc256
[3];
18732 salt
->salt_buf_pc
[4] = pc256
[4];
18733 salt
->salt_buf_pc
[5] = pc256
[5];
18734 salt
->salt_buf_pc
[6] = pc256
[6];
18735 salt
->salt_buf_pc
[7] = pc256
[7];
18737 digest
[0] -= pc256
[0];
18738 digest
[1] -= pc256
[1];
18739 digest
[2] -= pc256
[2];
18740 digest
[3] -= pc256
[3];
18741 digest
[4] -= pc256
[4];
18742 digest
[5] -= pc256
[5];
18743 digest
[6] -= pc256
[6];
18744 digest
[7] -= pc256
[7];
18746 return (PARSER_OK
);
18749 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18751 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18753 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18755 u32
*digest
= (u32
*) hash_buf
->digest
;
18757 salt_t
*salt
= hash_buf
->salt
;
18763 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18765 char *data_buf_pos
= strchr (data_len_pos
, '$');
18767 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18769 u32 data_len_len
= data_buf_pos
- data_len_pos
;
18771 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18772 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18776 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18778 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
18780 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
18782 u32 data_len
= atoi (data_len_pos
);
18784 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
18790 char *salt_pos
= data_buf_pos
;
18792 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18793 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18794 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
18795 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
18797 // this is actually the CT, which is also the hash later (if matched)
18799 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
18800 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
18801 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
18802 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
18804 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
18806 salt
->salt_iter
= 10 - 1;
18812 digest
[0] = salt
->salt_buf
[4];
18813 digest
[1] = salt
->salt_buf
[5];
18814 digest
[2] = salt
->salt_buf
[6];
18815 digest
[3] = salt
->salt_buf
[7];
18817 return (PARSER_OK
);
18820 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18822 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
18824 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18826 u32
*digest
= (u32
*) hash_buf
->digest
;
18828 salt_t
*salt
= hash_buf
->salt
;
18834 char *salt_pos
= input_buf
+ 11 + 1;
18836 char *iter_pos
= strchr (salt_pos
, ',');
18838 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18840 u32 salt_len
= iter_pos
- salt_pos
;
18842 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
18846 char *hash_pos
= strchr (iter_pos
, ',');
18848 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18850 u32 iter_len
= hash_pos
- iter_pos
;
18852 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
18856 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
18858 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
18864 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18865 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18866 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
18867 salt
->salt_buf
[3] = 0x00018000;
18869 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18870 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18871 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
18872 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
18874 salt
->salt_len
= salt_len
/ 2;
18876 salt
->salt_iter
= atoi (iter_pos
) - 1;
18882 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18883 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18884 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18885 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18886 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18887 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
18888 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
18889 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
18891 return (PARSER_OK
);
18894 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18896 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
18898 u32
*digest
= (u32
*) hash_buf
->digest
;
18900 salt_t
*salt
= hash_buf
->salt
;
18906 char *hash_pos
= input_buf
+ 64;
18907 char *salt1_pos
= input_buf
+ 128;
18908 char *salt2_pos
= input_buf
;
18914 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
18915 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
18916 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
18917 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
18919 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
18920 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
18921 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
18922 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
18924 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
18925 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
18926 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
18927 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
18929 salt
->salt_len
= 48;
18931 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
18937 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18938 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18939 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18940 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18941 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18942 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
18943 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
18944 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
18946 return (PARSER_OK
);
18950 * parallel running threads
18955 BOOL WINAPI
sigHandler_default (DWORD sig
)
18959 case CTRL_CLOSE_EVENT
:
18962 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
18963 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
18964 * function otherwise it is too late (e.g. after returning from this function)
18969 SetConsoleCtrlHandler (NULL
, TRUE
);
18976 case CTRL_LOGOFF_EVENT
:
18977 case CTRL_SHUTDOWN_EVENT
:
18981 SetConsoleCtrlHandler (NULL
, TRUE
);
18989 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
18993 case CTRL_CLOSE_EVENT
:
18997 SetConsoleCtrlHandler (NULL
, TRUE
);
19004 case CTRL_LOGOFF_EVENT
:
19005 case CTRL_SHUTDOWN_EVENT
:
19009 SetConsoleCtrlHandler (NULL
, TRUE
);
19017 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19019 if (callback
== NULL
)
19021 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19025 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19031 void sigHandler_default (int sig
)
19035 signal (sig
, NULL
);
19038 void sigHandler_benchmark (int sig
)
19042 signal (sig
, NULL
);
19045 void hc_signal (void (callback
) (int))
19047 if (callback
== NULL
) callback
= SIG_DFL
;
19049 signal (SIGINT
, callback
);
19050 signal (SIGTERM
, callback
);
19051 signal (SIGABRT
, callback
);
19056 void status_display ();
19058 void *thread_keypress (void *p
)
19060 int benchmark
= *((int *) p
);
19062 uint quiet
= data
.quiet
;
19066 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19068 int ch
= tty_getchar();
19070 if (ch
== -1) break;
19072 if (ch
== 0) continue;
19078 hc_thread_mutex_lock (mux_display
);
19093 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19094 if (quiet
== 0) fflush (stdout
);
19106 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19107 if (quiet
== 0) fflush (stdout
);
19119 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19120 if (quiet
== 0) fflush (stdout
);
19132 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19133 if (quiet
== 0) fflush (stdout
);
19141 if (benchmark
== 1) break;
19143 stop_at_checkpoint ();
19147 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19148 if (quiet
== 0) fflush (stdout
);
19156 if (benchmark
== 1)
19168 hc_thread_mutex_unlock (mux_display
);
19180 bool class_num (const u8 c
)
19182 return ((c
>= '0') && (c
<= '9'));
19185 bool class_lower (const u8 c
)
19187 return ((c
>= 'a') && (c
<= 'z'));
19190 bool class_upper (const u8 c
)
19192 return ((c
>= 'A') && (c
<= 'Z'));
19195 bool class_alpha (const u8 c
)
19197 return (class_lower (c
) || class_upper (c
));
19200 int conv_ctoi (const u8 c
)
19206 else if (class_upper (c
))
19208 return c
- 'A' + 10;
19214 int conv_itoc (const u8 c
)
19222 return c
+ 'A' - 10;
19232 #define INCR_POS if (++rule_pos == rule_len) return (-1)
19233 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
19234 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
19235 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
19236 #define MAX_KERNEL_RULES 255
19237 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
19238 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19239 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19241 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
19242 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
19243 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19244 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19246 int cpu_rule_to_kernel_rule (char rule_buf
[BUFSIZ
], uint rule_len
, kernel_rule_t
*rule
)
19251 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19253 switch (rule_buf
[rule_pos
])
19259 case RULE_OP_MANGLE_NOOP
:
19260 SET_NAME (rule
, rule_buf
[rule_pos
]);
19263 case RULE_OP_MANGLE_LREST
:
19264 SET_NAME (rule
, rule_buf
[rule_pos
]);
19267 case RULE_OP_MANGLE_UREST
:
19268 SET_NAME (rule
, rule_buf
[rule_pos
]);
19271 case RULE_OP_MANGLE_LREST_UFIRST
:
19272 SET_NAME (rule
, rule_buf
[rule_pos
]);
19275 case RULE_OP_MANGLE_UREST_LFIRST
:
19276 SET_NAME (rule
, rule_buf
[rule_pos
]);
19279 case RULE_OP_MANGLE_TREST
:
19280 SET_NAME (rule
, rule_buf
[rule_pos
]);
19283 case RULE_OP_MANGLE_TOGGLE_AT
:
19284 SET_NAME (rule
, rule_buf
[rule_pos
]);
19285 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19288 case RULE_OP_MANGLE_REVERSE
:
19289 SET_NAME (rule
, rule_buf
[rule_pos
]);
19292 case RULE_OP_MANGLE_DUPEWORD
:
19293 SET_NAME (rule
, rule_buf
[rule_pos
]);
19296 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19297 SET_NAME (rule
, rule_buf
[rule_pos
]);
19298 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19301 case RULE_OP_MANGLE_REFLECT
:
19302 SET_NAME (rule
, rule_buf
[rule_pos
]);
19305 case RULE_OP_MANGLE_ROTATE_LEFT
:
19306 SET_NAME (rule
, rule_buf
[rule_pos
]);
19309 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19310 SET_NAME (rule
, rule_buf
[rule_pos
]);
19313 case RULE_OP_MANGLE_APPEND
:
19314 SET_NAME (rule
, rule_buf
[rule_pos
]);
19315 SET_P0 (rule
, rule_buf
[rule_pos
]);
19318 case RULE_OP_MANGLE_PREPEND
:
19319 SET_NAME (rule
, rule_buf
[rule_pos
]);
19320 SET_P0 (rule
, rule_buf
[rule_pos
]);
19323 case RULE_OP_MANGLE_DELETE_FIRST
:
19324 SET_NAME (rule
, rule_buf
[rule_pos
]);
19327 case RULE_OP_MANGLE_DELETE_LAST
:
19328 SET_NAME (rule
, rule_buf
[rule_pos
]);
19331 case RULE_OP_MANGLE_DELETE_AT
:
19332 SET_NAME (rule
, rule_buf
[rule_pos
]);
19333 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19336 case RULE_OP_MANGLE_EXTRACT
:
19337 SET_NAME (rule
, rule_buf
[rule_pos
]);
19338 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19339 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19342 case RULE_OP_MANGLE_OMIT
:
19343 SET_NAME (rule
, rule_buf
[rule_pos
]);
19344 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19345 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19348 case RULE_OP_MANGLE_INSERT
:
19349 SET_NAME (rule
, rule_buf
[rule_pos
]);
19350 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19351 SET_P1 (rule
, rule_buf
[rule_pos
]);
19354 case RULE_OP_MANGLE_OVERSTRIKE
:
19355 SET_NAME (rule
, rule_buf
[rule_pos
]);
19356 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19357 SET_P1 (rule
, rule_buf
[rule_pos
]);
19360 case RULE_OP_MANGLE_TRUNCATE_AT
:
19361 SET_NAME (rule
, rule_buf
[rule_pos
]);
19362 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19365 case RULE_OP_MANGLE_REPLACE
:
19366 SET_NAME (rule
, rule_buf
[rule_pos
]);
19367 SET_P0 (rule
, rule_buf
[rule_pos
]);
19368 SET_P1 (rule
, rule_buf
[rule_pos
]);
19371 case RULE_OP_MANGLE_PURGECHAR
:
19375 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19379 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19380 SET_NAME (rule
, rule_buf
[rule_pos
]);
19381 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19384 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19385 SET_NAME (rule
, rule_buf
[rule_pos
]);
19386 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19389 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19390 SET_NAME (rule
, rule_buf
[rule_pos
]);
19393 case RULE_OP_MANGLE_SWITCH_FIRST
:
19394 SET_NAME (rule
, rule_buf
[rule_pos
]);
19397 case RULE_OP_MANGLE_SWITCH_LAST
:
19398 SET_NAME (rule
, rule_buf
[rule_pos
]);
19401 case RULE_OP_MANGLE_SWITCH_AT
:
19402 SET_NAME (rule
, rule_buf
[rule_pos
]);
19403 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19404 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19407 case RULE_OP_MANGLE_CHR_SHIFTL
:
19408 SET_NAME (rule
, rule_buf
[rule_pos
]);
19409 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19412 case RULE_OP_MANGLE_CHR_SHIFTR
:
19413 SET_NAME (rule
, rule_buf
[rule_pos
]);
19414 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19417 case RULE_OP_MANGLE_CHR_INCR
:
19418 SET_NAME (rule
, rule_buf
[rule_pos
]);
19419 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19422 case RULE_OP_MANGLE_CHR_DECR
:
19423 SET_NAME (rule
, rule_buf
[rule_pos
]);
19424 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19427 case RULE_OP_MANGLE_REPLACE_NP1
:
19428 SET_NAME (rule
, rule_buf
[rule_pos
]);
19429 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19432 case RULE_OP_MANGLE_REPLACE_NM1
:
19433 SET_NAME (rule
, rule_buf
[rule_pos
]);
19434 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19437 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19438 SET_NAME (rule
, rule_buf
[rule_pos
]);
19439 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19442 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19443 SET_NAME (rule
, rule_buf
[rule_pos
]);
19444 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19447 case RULE_OP_MANGLE_TITLE
:
19448 SET_NAME (rule
, rule_buf
[rule_pos
]);
19457 if (rule_pos
< rule_len
) return (-1);
19462 int kernel_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], kernel_rule_t
*rule
)
19466 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19470 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19474 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19478 case RULE_OP_MANGLE_NOOP
:
19479 rule_buf
[rule_pos
] = rule_cmd
;
19482 case RULE_OP_MANGLE_LREST
:
19483 rule_buf
[rule_pos
] = rule_cmd
;
19486 case RULE_OP_MANGLE_UREST
:
19487 rule_buf
[rule_pos
] = rule_cmd
;
19490 case RULE_OP_MANGLE_LREST_UFIRST
:
19491 rule_buf
[rule_pos
] = rule_cmd
;
19494 case RULE_OP_MANGLE_UREST_LFIRST
:
19495 rule_buf
[rule_pos
] = rule_cmd
;
19498 case RULE_OP_MANGLE_TREST
:
19499 rule_buf
[rule_pos
] = rule_cmd
;
19502 case RULE_OP_MANGLE_TOGGLE_AT
:
19503 rule_buf
[rule_pos
] = rule_cmd
;
19504 GET_P0_CONV (rule
);
19507 case RULE_OP_MANGLE_REVERSE
:
19508 rule_buf
[rule_pos
] = rule_cmd
;
19511 case RULE_OP_MANGLE_DUPEWORD
:
19512 rule_buf
[rule_pos
] = rule_cmd
;
19515 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19516 rule_buf
[rule_pos
] = rule_cmd
;
19517 GET_P0_CONV (rule
);
19520 case RULE_OP_MANGLE_REFLECT
:
19521 rule_buf
[rule_pos
] = rule_cmd
;
19524 case RULE_OP_MANGLE_ROTATE_LEFT
:
19525 rule_buf
[rule_pos
] = rule_cmd
;
19528 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19529 rule_buf
[rule_pos
] = rule_cmd
;
19532 case RULE_OP_MANGLE_APPEND
:
19533 rule_buf
[rule_pos
] = rule_cmd
;
19537 case RULE_OP_MANGLE_PREPEND
:
19538 rule_buf
[rule_pos
] = rule_cmd
;
19542 case RULE_OP_MANGLE_DELETE_FIRST
:
19543 rule_buf
[rule_pos
] = rule_cmd
;
19546 case RULE_OP_MANGLE_DELETE_LAST
:
19547 rule_buf
[rule_pos
] = rule_cmd
;
19550 case RULE_OP_MANGLE_DELETE_AT
:
19551 rule_buf
[rule_pos
] = rule_cmd
;
19552 GET_P0_CONV (rule
);
19555 case RULE_OP_MANGLE_EXTRACT
:
19556 rule_buf
[rule_pos
] = rule_cmd
;
19557 GET_P0_CONV (rule
);
19558 GET_P1_CONV (rule
);
19561 case RULE_OP_MANGLE_OMIT
:
19562 rule_buf
[rule_pos
] = rule_cmd
;
19563 GET_P0_CONV (rule
);
19564 GET_P1_CONV (rule
);
19567 case RULE_OP_MANGLE_INSERT
:
19568 rule_buf
[rule_pos
] = rule_cmd
;
19569 GET_P0_CONV (rule
);
19573 case RULE_OP_MANGLE_OVERSTRIKE
:
19574 rule_buf
[rule_pos
] = rule_cmd
;
19575 GET_P0_CONV (rule
);
19579 case RULE_OP_MANGLE_TRUNCATE_AT
:
19580 rule_buf
[rule_pos
] = rule_cmd
;
19581 GET_P0_CONV (rule
);
19584 case RULE_OP_MANGLE_REPLACE
:
19585 rule_buf
[rule_pos
] = rule_cmd
;
19590 case RULE_OP_MANGLE_PURGECHAR
:
19594 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19598 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19599 rule_buf
[rule_pos
] = rule_cmd
;
19600 GET_P0_CONV (rule
);
19603 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19604 rule_buf
[rule_pos
] = rule_cmd
;
19605 GET_P0_CONV (rule
);
19608 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19609 rule_buf
[rule_pos
] = rule_cmd
;
19612 case RULE_OP_MANGLE_SWITCH_FIRST
:
19613 rule_buf
[rule_pos
] = rule_cmd
;
19616 case RULE_OP_MANGLE_SWITCH_LAST
:
19617 rule_buf
[rule_pos
] = rule_cmd
;
19620 case RULE_OP_MANGLE_SWITCH_AT
:
19621 rule_buf
[rule_pos
] = rule_cmd
;
19622 GET_P0_CONV (rule
);
19623 GET_P1_CONV (rule
);
19626 case RULE_OP_MANGLE_CHR_SHIFTL
:
19627 rule_buf
[rule_pos
] = rule_cmd
;
19628 GET_P0_CONV (rule
);
19631 case RULE_OP_MANGLE_CHR_SHIFTR
:
19632 rule_buf
[rule_pos
] = rule_cmd
;
19633 GET_P0_CONV (rule
);
19636 case RULE_OP_MANGLE_CHR_INCR
:
19637 rule_buf
[rule_pos
] = rule_cmd
;
19638 GET_P0_CONV (rule
);
19641 case RULE_OP_MANGLE_CHR_DECR
:
19642 rule_buf
[rule_pos
] = rule_cmd
;
19643 GET_P0_CONV (rule
);
19646 case RULE_OP_MANGLE_REPLACE_NP1
:
19647 rule_buf
[rule_pos
] = rule_cmd
;
19648 GET_P0_CONV (rule
);
19651 case RULE_OP_MANGLE_REPLACE_NM1
:
19652 rule_buf
[rule_pos
] = rule_cmd
;
19653 GET_P0_CONV (rule
);
19656 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19657 rule_buf
[rule_pos
] = rule_cmd
;
19658 GET_P0_CONV (rule
);
19661 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19662 rule_buf
[rule_pos
] = rule_cmd
;
19663 GET_P0_CONV (rule
);
19666 case RULE_OP_MANGLE_TITLE
:
19667 rule_buf
[rule_pos
] = rule_cmd
;
19671 return rule_pos
- 1;
19689 * CPU rules : this is from hashcat sources, cpu based rules
19692 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19693 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19695 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19696 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19697 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19699 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19700 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19701 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19703 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19707 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19712 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19716 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19721 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19725 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19730 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19735 for (l
= 0; l
< arr_len
; l
++)
19737 r
= arr_len
- 1 - l
;
19741 MANGLE_SWITCH (arr
, l
, r
);
19747 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19749 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19751 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19753 return (arr_len
* 2);
19756 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19758 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19760 int orig_len
= arr_len
;
19764 for (i
= 0; i
< times
; i
++)
19766 memcpy (&arr
[arr_len
], arr
, orig_len
);
19768 arr_len
+= orig_len
;
19774 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19776 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19778 mangle_double (arr
, arr_len
);
19780 mangle_reverse (arr
+ arr_len
, arr_len
);
19782 return (arr_len
* 2);
19785 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
19790 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
19792 MANGLE_SWITCH (arr
, l
, r
);
19798 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
19803 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
19805 MANGLE_SWITCH (arr
, l
, r
);
19811 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19813 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19817 return (arr_len
+ 1);
19820 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19822 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19826 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19828 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19833 return (arr_len
+ 1);
19836 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19838 if (upos
>= arr_len
) return (arr_len
);
19842 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
19844 arr
[arr_pos
] = arr
[arr_pos
+ 1];
19847 return (arr_len
- 1);
19850 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19852 if (upos
>= arr_len
) return (arr_len
);
19854 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
19858 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
19860 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
19866 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19868 if (upos
>= arr_len
) return (arr_len
);
19870 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
19874 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
19876 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
19879 return (arr_len
- ulen
);
19882 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19884 if (upos
>= arr_len
) return (arr_len
);
19886 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19890 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
19892 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19897 return (arr_len
+ 1);
19900 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
)
19902 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
19904 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
19906 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
19908 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
19910 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
19912 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
19914 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
19916 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
19918 return (arr_len
+ arr2_cpy
);
19921 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19923 if (upos
>= arr_len
) return (arr_len
);
19930 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19932 if (upos
>= arr_len
) return (arr_len
);
19934 memset (arr
+ upos
, 0, arr_len
- upos
);
19939 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
19943 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19945 if (arr
[arr_pos
] != oldc
) continue;
19947 arr
[arr_pos
] = newc
;
19953 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19959 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19961 if (arr
[arr_pos
] == c
) continue;
19963 arr
[ret_len
] = arr
[arr_pos
];
19971 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19973 if (ulen
> arr_len
) return (arr_len
);
19975 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19977 char cs
[100] = { 0 };
19979 memcpy (cs
, arr
, ulen
);
19983 for (i
= 0; i
< ulen
; i
++)
19987 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
19993 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19995 if (ulen
> arr_len
) return (arr_len
);
19997 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19999 int upos
= arr_len
- ulen
;
20003 for (i
= 0; i
< ulen
; i
++)
20005 char c
= arr
[upos
+ i
];
20007 arr_len
= mangle_append (arr
, arr_len
, c
);
20013 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20015 if ( arr_len
== 0) return (arr_len
);
20016 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20018 char c
= arr
[upos
];
20022 for (i
= 0; i
< ulen
; i
++)
20024 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20030 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20032 if ( arr_len
== 0) return (arr_len
);
20033 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20037 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20039 int new_pos
= arr_pos
* 2;
20041 arr
[new_pos
] = arr
[arr_pos
];
20043 arr
[new_pos
+ 1] = arr
[arr_pos
];
20046 return (arr_len
* 2);
20049 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20051 if (upos
>= arr_len
) return (arr_len
);
20052 if (upos2
>= arr_len
) return (arr_len
);
20054 MANGLE_SWITCH (arr
, upos
, upos2
);
20059 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20061 MANGLE_SWITCH (arr
, upos
, upos2
);
20066 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20068 if (upos
>= arr_len
) return (arr_len
);
20075 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20077 if (upos
>= arr_len
) return (arr_len
);
20084 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20086 if (upos
>= arr_len
) return (arr_len
);
20093 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20095 if (upos
>= arr_len
) return (arr_len
);
20102 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20104 int upper_next
= 1;
20108 for (pos
= 0; pos
< arr_len
; pos
++)
20110 if (arr
[pos
] == ' ')
20121 MANGLE_UPPER_AT (arr
, pos
);
20125 MANGLE_LOWER_AT (arr
, pos
);
20132 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20134 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20140 for (j
= 0; j
< rp_gen_num
; j
++)
20147 switch ((char) get_random_num (0, 9))
20150 r
= get_random_num (0, sizeof (grp_op_nop
));
20151 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20155 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20156 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20157 p1
= get_random_num (0, sizeof (grp_pos
));
20158 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20162 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20163 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20164 p1
= get_random_num (1, 6);
20165 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20169 r
= get_random_num (0, sizeof (grp_op_chr
));
20170 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20171 p1
= get_random_num (0x20, 0x7e);
20172 rule_buf
[rule_pos
++] = (char) p1
;
20176 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20177 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20178 p1
= get_random_num (0x20, 0x7e);
20179 rule_buf
[rule_pos
++] = (char) p1
;
20180 p2
= get_random_num (0x20, 0x7e);
20182 p2
= get_random_num (0x20, 0x7e);
20183 rule_buf
[rule_pos
++] = (char) p2
;
20187 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20188 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20189 p1
= get_random_num (0, sizeof (grp_pos
));
20190 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20191 p2
= get_random_num (0x20, 0x7e);
20192 rule_buf
[rule_pos
++] = (char) p2
;
20196 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20197 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20198 p1
= get_random_num (0, sizeof (grp_pos
));
20199 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20200 p2
= get_random_num (0, sizeof (grp_pos
));
20202 p2
= get_random_num (0, sizeof (grp_pos
));
20203 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20207 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20208 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
20209 p1
= get_random_num (0, sizeof (grp_pos
));
20210 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20211 p2
= get_random_num (1, sizeof (grp_pos
));
20213 p2
= get_random_num (1, sizeof (grp_pos
));
20214 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20218 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
20219 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
20220 p1
= get_random_num (0, sizeof (grp_pos
));
20221 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20222 p2
= get_random_num (1, sizeof (grp_pos
));
20223 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20224 p3
= get_random_num (0, sizeof (grp_pos
));
20225 rule_buf
[rule_pos
++] = grp_pos
[p3
];
20233 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
20235 char mem
[BLOCK_SIZE
] = { 0 };
20237 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
20239 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
20241 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20243 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
20245 int out_len
= in_len
;
20246 int mem_len
= in_len
;
20248 memcpy (out
, in
, out_len
);
20252 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
20257 switch (rule
[rule_pos
])
20262 case RULE_OP_MANGLE_NOOP
:
20265 case RULE_OP_MANGLE_LREST
:
20266 out_len
= mangle_lrest (out
, out_len
);
20269 case RULE_OP_MANGLE_UREST
:
20270 out_len
= mangle_urest (out
, out_len
);
20273 case RULE_OP_MANGLE_LREST_UFIRST
:
20274 out_len
= mangle_lrest (out
, out_len
);
20275 if (out_len
) MANGLE_UPPER_AT (out
, 0);
20278 case RULE_OP_MANGLE_UREST_LFIRST
:
20279 out_len
= mangle_urest (out
, out_len
);
20280 if (out_len
) MANGLE_LOWER_AT (out
, 0);
20283 case RULE_OP_MANGLE_TREST
:
20284 out_len
= mangle_trest (out
, out_len
);
20287 case RULE_OP_MANGLE_TOGGLE_AT
:
20288 NEXT_RULEPOS (rule_pos
);
20289 NEXT_RPTOI (rule
, rule_pos
, upos
);
20290 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
20293 case RULE_OP_MANGLE_REVERSE
:
20294 out_len
= mangle_reverse (out
, out_len
);
20297 case RULE_OP_MANGLE_DUPEWORD
:
20298 out_len
= mangle_double (out
, out_len
);
20301 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20302 NEXT_RULEPOS (rule_pos
);
20303 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20304 out_len
= mangle_double_times (out
, out_len
, ulen
);
20307 case RULE_OP_MANGLE_REFLECT
:
20308 out_len
= mangle_reflect (out
, out_len
);
20311 case RULE_OP_MANGLE_ROTATE_LEFT
:
20312 mangle_rotate_left (out
, out_len
);
20315 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20316 mangle_rotate_right (out
, out_len
);
20319 case RULE_OP_MANGLE_APPEND
:
20320 NEXT_RULEPOS (rule_pos
);
20321 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
20324 case RULE_OP_MANGLE_PREPEND
:
20325 NEXT_RULEPOS (rule_pos
);
20326 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
20329 case RULE_OP_MANGLE_DELETE_FIRST
:
20330 out_len
= mangle_delete_at (out
, out_len
, 0);
20333 case RULE_OP_MANGLE_DELETE_LAST
:
20334 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
20337 case RULE_OP_MANGLE_DELETE_AT
:
20338 NEXT_RULEPOS (rule_pos
);
20339 NEXT_RPTOI (rule
, rule_pos
, upos
);
20340 out_len
= mangle_delete_at (out
, out_len
, upos
);
20343 case RULE_OP_MANGLE_EXTRACT
:
20344 NEXT_RULEPOS (rule_pos
);
20345 NEXT_RPTOI (rule
, rule_pos
, upos
);
20346 NEXT_RULEPOS (rule_pos
);
20347 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20348 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
20351 case RULE_OP_MANGLE_OMIT
:
20352 NEXT_RULEPOS (rule_pos
);
20353 NEXT_RPTOI (rule
, rule_pos
, upos
);
20354 NEXT_RULEPOS (rule_pos
);
20355 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20356 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
20359 case RULE_OP_MANGLE_INSERT
:
20360 NEXT_RULEPOS (rule_pos
);
20361 NEXT_RPTOI (rule
, rule_pos
, upos
);
20362 NEXT_RULEPOS (rule_pos
);
20363 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
20366 case RULE_OP_MANGLE_OVERSTRIKE
:
20367 NEXT_RULEPOS (rule_pos
);
20368 NEXT_RPTOI (rule
, rule_pos
, upos
);
20369 NEXT_RULEPOS (rule_pos
);
20370 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20373 case RULE_OP_MANGLE_TRUNCATE_AT
:
20374 NEXT_RULEPOS (rule_pos
);
20375 NEXT_RPTOI (rule
, rule_pos
, upos
);
20376 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20379 case RULE_OP_MANGLE_REPLACE
:
20380 NEXT_RULEPOS (rule_pos
);
20381 NEXT_RULEPOS (rule_pos
);
20382 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20385 case RULE_OP_MANGLE_PURGECHAR
:
20386 NEXT_RULEPOS (rule_pos
);
20387 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20390 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20394 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20395 NEXT_RULEPOS (rule_pos
);
20396 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20397 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20400 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20401 NEXT_RULEPOS (rule_pos
);
20402 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20403 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20406 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20407 out_len
= mangle_dupechar (out
, out_len
);
20410 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20411 NEXT_RULEPOS (rule_pos
);
20412 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20413 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20416 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20417 NEXT_RULEPOS (rule_pos
);
20418 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20419 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20422 case RULE_OP_MANGLE_SWITCH_FIRST
:
20423 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20426 case RULE_OP_MANGLE_SWITCH_LAST
:
20427 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20430 case RULE_OP_MANGLE_SWITCH_AT
:
20431 NEXT_RULEPOS (rule_pos
);
20432 NEXT_RPTOI (rule
, rule_pos
, upos
);
20433 NEXT_RULEPOS (rule_pos
);
20434 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20435 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20438 case RULE_OP_MANGLE_CHR_SHIFTL
:
20439 NEXT_RULEPOS (rule_pos
);
20440 NEXT_RPTOI (rule
, rule_pos
, upos
);
20441 mangle_chr_shiftl (out
, out_len
, upos
);
20444 case RULE_OP_MANGLE_CHR_SHIFTR
:
20445 NEXT_RULEPOS (rule_pos
);
20446 NEXT_RPTOI (rule
, rule_pos
, upos
);
20447 mangle_chr_shiftr (out
, out_len
, upos
);
20450 case RULE_OP_MANGLE_CHR_INCR
:
20451 NEXT_RULEPOS (rule_pos
);
20452 NEXT_RPTOI (rule
, rule_pos
, upos
);
20453 mangle_chr_incr (out
, out_len
, upos
);
20456 case RULE_OP_MANGLE_CHR_DECR
:
20457 NEXT_RULEPOS (rule_pos
);
20458 NEXT_RPTOI (rule
, rule_pos
, upos
);
20459 mangle_chr_decr (out
, out_len
, upos
);
20462 case RULE_OP_MANGLE_REPLACE_NP1
:
20463 NEXT_RULEPOS (rule_pos
);
20464 NEXT_RPTOI (rule
, rule_pos
, upos
);
20465 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20468 case RULE_OP_MANGLE_REPLACE_NM1
:
20469 NEXT_RULEPOS (rule_pos
);
20470 NEXT_RPTOI (rule
, rule_pos
, upos
);
20471 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20474 case RULE_OP_MANGLE_TITLE
:
20475 out_len
= mangle_title (out
, out_len
);
20478 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20479 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20480 NEXT_RULEPOS (rule_pos
);
20481 NEXT_RPTOI (rule
, rule_pos
, upos
);
20482 NEXT_RULEPOS (rule_pos
);
20483 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20484 NEXT_RULEPOS (rule_pos
);
20485 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20486 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20489 case RULE_OP_MANGLE_APPEND_MEMORY
:
20490 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20491 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20492 memcpy (out
+ out_len
, mem
, mem_len
);
20493 out_len
+= mem_len
;
20496 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20497 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20498 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20499 memcpy (mem
+ mem_len
, out
, out_len
);
20500 out_len
+= mem_len
;
20501 memcpy (out
, mem
, out_len
);
20504 case RULE_OP_MEMORIZE_WORD
:
20505 memcpy (mem
, out
, out_len
);
20509 case RULE_OP_REJECT_LESS
:
20510 NEXT_RULEPOS (rule_pos
);
20511 NEXT_RPTOI (rule
, rule_pos
, upos
);
20512 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20515 case RULE_OP_REJECT_GREATER
:
20516 NEXT_RULEPOS (rule_pos
);
20517 NEXT_RPTOI (rule
, rule_pos
, upos
);
20518 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20521 case RULE_OP_REJECT_CONTAIN
:
20522 NEXT_RULEPOS (rule_pos
);
20523 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20526 case RULE_OP_REJECT_NOT_CONTAIN
:
20527 NEXT_RULEPOS (rule_pos
);
20528 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20531 case RULE_OP_REJECT_EQUAL_FIRST
:
20532 NEXT_RULEPOS (rule_pos
);
20533 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20536 case RULE_OP_REJECT_EQUAL_LAST
:
20537 NEXT_RULEPOS (rule_pos
);
20538 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20541 case RULE_OP_REJECT_EQUAL_AT
:
20542 NEXT_RULEPOS (rule_pos
);
20543 NEXT_RPTOI (rule
, rule_pos
, upos
);
20544 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20545 NEXT_RULEPOS (rule_pos
);
20546 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20549 case RULE_OP_REJECT_CONTAINS
:
20550 NEXT_RULEPOS (rule_pos
);
20551 NEXT_RPTOI (rule
, rule_pos
, upos
);
20552 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20553 NEXT_RULEPOS (rule_pos
);
20554 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20555 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20558 case RULE_OP_REJECT_MEMORY
:
20559 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20563 return (RULE_RC_SYNTAX_ERROR
);
20568 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);